Changelog

This page records user-visible Compukters changes. The newest version is first; releases remain as permanent section headings so this page has one stable URL that can be shared outside the repository.

0.5.0 — In development

This release expands the Kotlin available to computer programs and introduces support for independently installed addon mods, beginning with an optional Create integration for Minecraft 1.21.1.

Guest Kotlin

• Computer programs can use unboxed Long and Float values, including mixed numeric arithmetic and comparisons, explicit conversions, Long bitwise and shift operations, constants, string interpolation, and console output.
• Float values retain their binary32 representation through arithmetic, equality, host responses, and conversion to text, including signed zero, infinities, NaN, and subnormal values.
• Operations that wait for the world, another task, or a channel now block transparently inside ordinary functions; source-level suspend declarations are not part of the supported Guest Kotlin subset.
• Tasks.sleepTicks(n) lets a program pace world interactions by server ticks while other Guest tasks continue and without spending its instruction budget during the wait.
• Guest classes and interfaces support ordinary non-suspending instance methods, overrides, and runtime class or interface dispatch. Primary-constructor var properties can be assigned through object references and instance methods; aliases observe the updated field. Class-body properties and init blocks run in source order after the superclass initializer on the same object, including construction through a constructor reference. Primary constructors can use Guest expressions for default arguments in ordinary calls, including values derived from earlier parameters; explicit arguments run before omitted defaults. Computed class properties and custom getters/setters can read or update backing fields and dispatch through base-class references. Abstract class and interface val/var properties dispatch to concrete implementations without storing fields in their abstract declarations. Interfaces can also provide default method bodies and computed property accessors; classes inherit them unless they override the member. An override can call a chosen interface implementation with super<Interface>, including methods inherited by that interface.
• Guest programs can use sealed interfaces, data class values, and stateless enums for type branches, property reads, and enum identity comparisons.
• Int for loops support downTo and positive step, including dynamic steps and integer boundary values.
• IntArray values can be traversed directly with for, including empty arrays and in-loop element updates.
• Non-null function values with Guest-supported parameter and result types can be passed, returned, stored locally, and invoked without a fixed two-argument or JVM 22/23 cut-off. Lambdas use ordinary managed closure objects, preserve reference aliasing for immutable captures, and share mutations through unboxed typed cells when local var values are captured, including across nested lambdas. Tasks.launch accepts () -> Unit values as bounded cooperative tasks. Unbound references to Guest top-level functions can be passed, returned, stored, and invoked as typed function values. Bound Guest instance-method references retain their receiver and preserve virtual and interface dispatch. Unbound Type::method references accept the receiver as their first argument and use the same dispatch. References to supported Guest class constructors can also be passed, returned, stored, and invoked as typed function values, including references adapted to omit supported trailing constructor defaults.

Addons and Create

• Independently installed addon mods can provide typed Guest Kotlin APIs without becoming dependencies of Compukters. An independently versioned Gradle SDK generates their stable ABI lock, typed host contract, capability schema, bindings and packaged Guest API bundle from Kotlin declarations; addon authors do not maintain numeric operation IDs or wire decoding. Its Minecraft-independent host API and thin version-specific NeoForge adapter remain compile-only, so ordinary Compukters releases do not force an SDK version update or expose implementation classes. The compiler and IDE expose only the addons available on the attached server.
• Addon projects register one atomic Guest API by addon ID; its version defaults to the addon’s Gradle project version, while platform dependencies and capability wiring remain internal. Compukters projects list only addon IDs in compukter.toml, with exact versions and hashes retained in compukter.lock.
• The separately installed Create addon supports Create 6.0.x on Minecraft 1.21.1 while the base Compukters mod remains usable without Create.
• Added passive peripheral cables for orthogonal, branching and looping connections between computers and supported addon devices. Their thin model follows the actual connections in all six directions. Cables discover loaded chunks only and do not require adapters or a controller block.
• Added a one-block text display to the base mod. Guest programs can address it beside the computer or by name over peripheral cables, write to an independent 20x10 grid, and clear it. One computer controls a display at a time; the screen clears when its writer stops or disconnects.
• Added a Peripheral Configurator editor that opens on supported devices and inspects their bounded cable network. It reports available and duplicate names before assignment, while using it on a cable opens a read-only list of every connected device and its name when assigned. The server rejects stale or conflicting changes; Shift-use clears a name. The configurator item remains unnamed, while device names persist with the world independently of computers and cable topology.
• The create addon reads exact Float speed, stress, and capacity values from adjacent or named cable-connected speedometers and stressometers, waits for value changes without Guest-side polling, and controls rotation speed controllers.
• The create addon also exposes adjacent or named Stock Tickers. Computer programs can search bounded stock snapshots by item ID, distinguish exact item variants, and request packaging to an address; acceptance is reported without implying delivery.
• The create addon monitors active steam boilers through any Fluid Tank segment, reporting sampled water supply in mB/t, the water gauge level, active heat, effective boiler level, and passive heating.
• Device handles remain bound to the exact acquired block, and named handles expire when their cable path disconnects. Missing, disconnected, unloaded, removed, or replaced devices fail deterministically and produce a descriptive terminal diagnostic.
• Addon SDK 0.3.1 lets independent addons map a cable touching any supported block or multiblock part to one canonical logical device, validate retained handles against current reachability, and preserve the existing adjacent-side registration API.

In-game IDE

• Member completion includes the supported operations of built-in Guest Kotlin numeric types.
• Completion, automatic imports, parameter information, and source navigation include compatible APIs supplied by installed addons. Selecting Kinetics or Logistics also enables the create addon for the project.

Computer runtime

• Active computers now share a calibrated server-wide Guest instruction capacity each tick. Reservations rotate fairly between computers under overload, while waiting computers leave the runnable pool until input or a world completion wakes them. Server operators can inspect the capacity and throttling counters with vmbench status.

0.4.0 — 2026-09-12

This release makes the integrated multi-file Kotlin IDE available on both supported Minecraft versions, adds a Java 21 / NeoForge 1.21.1 build, and moves computer execution onto the bounded asynchronous Runtime 0.12 architecture.

Guest Kotlin

• Added bounded cooperative tasks through Tasks.launch, task handles, and join.
• Added VM-owned bounded IntChannel communication between Guest tasks with suspending send(Int) and receive().
• Added immutable top-level Guest state, including scalar constants and channel declarations.
• Added default Int arguments to platform calls.
• Added bounded computer beeps through the Guest sound API.

Runtime and computers

• Added a NeoForge 1.21.1 / Java 21 port backed by the JNI runtime transport; the existing 26.1.2 build continues to use JDK 25 FFM.
• Fixed 1.21.1 computer startup on Java 21 and restored its block and item models and crisp terminal rendering.
• Unified the terminal panel, border, background, title, and resource-gauge palette across both supported Minecraft versions.
• Moved production computers onto the asynchronous actor runtime with bounded admission, worker execution, result delivery, and clean close barriers.
• Moved Guest task scheduling and channel handoff into the Rust VM; channel traffic does not make a server request.
• Preserved redstone transitions while VM work is in flight and aligned redstone and sound effects with fixed server tick phases.
• Allowed terminal, compiler, and redstone waits to coexist with host operations from other Guest tasks without starvation or missed redstone edges while another task publishes output.
• Restored live terminal observation after leaving the IDE.
• Reduced the default Guest heap and removed unused runtime tracing overhead.
• Improved VM register access, host continuation delivery, result pumping, and scheduler capacity.
• Added terminal gauges for observed VM CPU utilization, heap use, and resident execution state.

Profiling

• Added the packaged vmbench program and in-world controls for deterministic headless VM fleets.
• Added CPU and capacity benchmark modes, automatic status output, scheduler/result metrics, phased sampling, physical computer area fanout, and a redstone pulse workload.
• Raised the supported actor capacity to 4096 and allowed benchmark areas larger than 1000 computers.

In-game IDE and tooling

• Ported the integrated IDE and its icon toolbar to Minecraft 1.21.1 while retaining version-specific screen and rendering adapters.
• Added remembered project workspaces and a project switcher.
• Added parameter information and replaced IDE toolbar labels with icons.
• Fixed analysis failures involving synthetic Kotlin declarations.
• Reused verified Kotlin worker caches and reduced packaged tooling size with solid XZ compression and shared compiler files.

Persistence and verification

• Moved bounded filesystem persistence work off the server thread and strengthened store shutdown, failure isolation, stale-lock recovery, and crash-point coverage.
• Added complete native FFI symbol/descriptor parity checks and expanded Kotlin-to-VM conformance coverage.
• Added pinned dual-transport Runtime bundles and release gates for both the Java 25 FFM and Java 21 JNI artifacts.
• Non-interactive agent Gradle runs now keep their complete logs in build/agent-logs/ and print a concise summary.
• Added this continuous repository-owned changelog as a permanent page on the documentation site.

Compatibility notes

• Minecraft 1.21.1 with NeoForge 21.1.250 or newer is supported on Java 21. Its initial compatibility build includes computers, persistence, redstone, sound, compilation, the terminal, the integrated IDE, and VM benchmark commands.
• Channel-enabled executables use artifact/runtime contract 1.2 and require the matching 0.4 runtime. Older artifacts whose channel limits are zero remain valid under the extended contract.
• Minecraft 26.1.2 with NeoForge 26.1.2.97 or newer remains the primary Java 25 baseline.

GitHub release · Compare v0.3.0…v0.4.0

0.3.0 — 2026-09-06

This release focused on programmable redstone I/O, a native Compukters K2 platform, a richer in-game IDE, and a substantially reworked managed runtime.

Redstone GPIO

• Added first-class analog redstone input and output on all six computer-local sides.
• Added suspending waits for the next change, an exact level, or a minimum level.
• Added weak and direct output power modes.
• Made outputs persistent across program completion, reboot, VM faults, VM replacement, and chunk reload.
• Sampled and coalesced input changes at Minecraft tick boundaries without Guest-side polling.

Guest Kotlin

• Replaced the JVM-bootstrap Guest environment with a native Compukters K2 platform.
• Made compiler and IDE analysis consume the same explicit platform metadata and source declarations.
• Added modular Guest platform libraries selected through compukter.toml.
• Added allocation-free primitive-backed value classes, scalar string interpolation, bounded Int ranges, break, continue, and specialized IntArray operations.
• Added lazy type initialization for enum and platform-library static state.

In-game IDE

• Added semantic hover, Go to Declaration, source navigation history, and read-only platform source views.
• Added context-aware keyword completion, explicit Kotlin reformatting, automatic delimiter pairing, structural editing, copy/cut, word navigation, page navigation, multi-line indentation, and double-click selection.
• Improved syntax highlighting, Unicode handling, caret behavior, incremental analysis, and analysis diagnostics.

Runtime, compiler, and verification

• Updated to Compukter Runtime 0.9.0 with FFI ABI 9.
• Reworked VM frames, compact Guest references, exact GC safepoint liveness, memory accounting, and managed reference storage.
• Changed host-request limits into tick-scoped backpressure for valid long-running I/O programs.
• Improved linking, reachability, dead-code elimination, artifact validation, and compiler/VM conformance coverage.
• Expanded verifyLocalFull to every Gradle subproject, Rust/FFI checks, runtime integration, GameTests, and the production JAR while keeping tagged multi-platform release verification separate.

Breaking changes

• Executables from 0.2.x must be rebuilt from Kotlin source for the 0.3 artifact/runtime contract.
• Projects using the former JVM-bootstrap Guest platform may need their dependency lock resolved again.
• Guest Kotlin exposes only declarations provided by selected Compukters platform modules, not the arbitrary JVM Kotlin standard library.

GitHub release · Compare v0.2.0…v0.3.0

0.2.0 — 2026-08-29

In-game IDE

• Added build, verify, deploy, and run support for attached computers.
• Added an interactive target terminal and a read-only filesystem explorer with file preview and import.
• Added overload/signature completion and automatic completion-list scrolling.
• Moved Kotlin tooling initialization off the render thread and improved initial focus and semantic highlighting.

Terminal and UI

• Added an IDE button and Ctrl+I shortcut to the computer terminal.
• Made Compukters UI scaling independent of Minecraft GUI scale.
• Improved bitmap-font rendering and the IDE terminal layout on smaller screens.
• Fixed delayed terminal submission, terminal ownership handoff, dialog layering, and font-change layout issues.

Computers, runtime, and distribution

• Restored the blue workbench-style computer appearance.
• Added secure revision-aware executable deployment and improved computer, IDE, and server-VM communication.
• Updated to Compukter Runtime 0.5.1.
• Added pinned and verified Linux and Windows runtime bundles, shared deterministic Kotlin tooling, and stronger production JAR assembly and release checks.

GitHub release.