Compukters: Propulsion

Release downloads include the base mod and Create, CreateAddition, Sable and Propulsion addons. Cosmonautics remains development-only and is not published with this release.

Addon development builds support Gradle task discovery during IntelliJ composite-build synchronization with Loom 1.17 and Gradle 9.8.

Cosmonautics exposes read-only planet shape, surface border, dated rotation model and Deep Space region geometry, clocks and construction sharing to Guest Kotlin; space-telemetry reports these navigation observations.

IDE rebases pasted multiline Kotlin code to the insertion indentation, preserving relative nesting and atomic undo; insertion inside literals/comments and fragments containing raw strings stay literal.

IDE supports Alt+Up/Down to move the current line or selected block, preserving selection and one-step undo.

Added an experimental rocket-landing Guest project for a controlled vertical climb, height hold and soft descent onto a known launch pad, with bounded horizontal return within a 6 m corridor, final descent after centering, configurable faster ascent/descent with braking-distance planning and height-dependent timeouts, and immediate near-pad stop detection using measured position changes, plus named phases and landing diagnostics. Preparation failures explain paused physics, inconsistent dimensions and a mismatched engine construction.

IDE supports Ctrl+D to duplicate the current line below or the exact selection with one-step undo.

IDE remembers the last opened project separately for each computer and restores it on reopening, including after a client or world restart. Missing projects return to the project selector.

IDE Devices inserts a peripheral name constant on double-click and copies the selected device's exact network name with Ctrl+C while the device window has focus.

Guest Kotlin supports covariant read views for custom out interfaces, Sequence and Iterator, including primitive-to-nullable and Any views. Widening preserves object identity and scalar storage, boxing only widened reads; nested results and precompiled library owners share the same model.

Tagged releases can submit both supported NeoForge base-mod JARs and the separate Create, CreateAddition, Sable and Propulsion addons to CurseForge with required dependency relations, recorded upload outcomes and explicit recovery after interrupted submissions. Modrinth base-mod publication remains independent.

IDE checks constant named peripheral lookups against the attached computer’s current network, with warnings for mandatory searches and informational hover/Problems entries for optional searches. Network observations refresh independently of Devices and explain unavailable devices without blocking compilation.

Configurator outlines on Sable constructions transform block coordinates into the world before applying the camera offset, preserving their placement and rotation while the player moves.

IDE automatic completion after dots and identifier edits starts without preparation or request debounce delays. Variable, parameter and destructuring declaration names suppress completion candidates while types, initializers and existing-variable references retain semantic suggestions.

Added programmable Create pumps with persistent remotely reversible fluid flow and normally disengaged programmable clutches that release their load when the controlling program or peripheral connection ends. The clutch has a blue casing band preserving the original redstone stripe's contour and shading, with a one-pixel grey outline around the blue stripe. Flush, grey-framed rectangular indicators show its state on all four sides. The bars have grey end caps: green parallel to the shaft when engaged, or red across it when disengaged. It retains cutout rendering around its shaft openings. The pump has an unmarked copper tube and continuous dark display rings at both ends, with three subdued cyan flow arrows on each of their four faces and no protruding controller or socket; the pipe ends retain Create's original recessed shading. Its casing and displays stay stationary when flow reverses; only the arrows change. Their Guest value classes use the shared typed and named peripheral discovery; addon blocks share the Compukters creative tab.

Retained peripheral handles restore network devices by their saved instance UUID after address changes; translated direct devices use computer-relative locations. Replacements and competing process owners remain rejected.

Addon SDK 0.6.0 supports transient actuator acquisition/release callbacks and lazy item groups in the shared Compukters creative tab. Base items stay first; addon groups follow in stable order without extra tabs.

Guest files support eager readLines and scoped streaming useLines, with strict UTF-8 across transfer chunks, LF/CRLF/CR delimiters, explicit byte limits and guaranteed reader cleanup. Low-level readers expose a single-pass line sequence; optional Path extensions retain the separation between paths and storage.

Agent sandbox builds share one workspace build slot across worktrees and the all-addon development stand, with eight Gradle workers and eight Rust jobs by default. Explicit build limits remain configurable.

Added read-only Cosmonautics space telemetry for Guest Kotlin: Deep Space membership, linked planet parameters, instance orbital observations and an atomic snapshot of orbital guidance directions in Sable world axes. Telemetry reports orbital radial/transverse speeds and a circular-speed reference for assessing burns. Examples cover telemetry, experimental prograde pointing and a bounded vertical rocket ascent with a creative vector engine. Cosmonautics construction transfers checkpoint the computer before copying and preserve peripheral network addresses and exact-device handles across dimensions. The ascent example confirms Deep Space after interrupted world calls and cuts engine throttle; physics continues during asynchronous restoration. Orbital insertion remains separate work.

The addon development stand loads optional Connector, Forgified Fabric API, Sodium, Voxy and Voxy Worldgen through Gradle; their dependency lines can be commented out. Loom supplies Connector's clean Minecraft path and remaps every Fabric API module for the development environment.

Immutable Guest records now use native value classes throughout the platform API, addon observations, system programs and examples, including terminal events, process/compiler results and boiler telemetry. Recompile Guest programs against the updated platform and addon bundles. Boiler controller checks execute in the Guest VM.

Cosmonautics and Crafts & Additions are independent addons pinned as submodules; the all-addon development stand loads their upstream dependencies.

The Crafts & Additions integration exposes named liquid Blaze Burners with atomic fuel quantity, capacity, heat and remaining burn-time readings. The separate boiler-scada project starts water/fuel pumps from a kinetic battery, switches to steam self-power with battery charging, and reverses one programmable fuel pump on STOP until every configured burner is empty. Programmable clutches isolate the battery, steam, fuel pump and load branches; flow direction changes only while the fuel clutch is disconnected. Only battery discharge uses a named Redstone Port. A separate load clutch protects the pump and battery-charge circuit: sustained rotation loss or overload triggers delayed battery-assisted recovery, verifies isolated steam power, then reconnects the load automatically. A Stressometer after the load clutch supplies the panel's stress/capacity readings; failed recovery drains fuel. Its panel shows boiler readings, per-burner fuel, cooldown and fault states; normal cooldown allows an explicit restart before the burners finish burning. The development stand includes Crafts & Additions and Create: Connected.

Task worktree completion checks active builds in nested independent Gradle projects and excludes their sandbox caches from its archive while retaining worlds and IDE data.

Guest Kotlin provides lazy Sequence<T> chains with Iterable.asSequence(), map, mapNotNull, filter, filterNot, filterNotNull, take, firstOrNull and toList, with terminal forEach, fold, count, any, all and none. Terminal callbacks support non-local returns; predicate queries stop as soon as their result is known. Chains defer callbacks until consumption, stop at the requested prefix or first match and retain independent iterator state, including nullable elements. Nullable selection skips nulls on demand and exposes non-null result types. Filtering caches all twelve non-null primitive families in unboxed scalar fields. Generic helpers can construct retained callbacks and bound member references for filter, filterNot and map, including escaping captures.

Guest Kotlin supports direct generic methods on ordinary classes and objects, combining class and method type specialization with defaults, local helpers and escaping callbacks. Final generic methods can be inherited through generic class hierarchies, with concrete superclass fields, constructors and shared method specializations across subclasses and base aliases.

Guest generic classes support callbacks and local helpers in primary-constructor initialization, field initializers and init blocks, with concrete capture types and independent state for each instance.

Added terminal history for the last 512 scrolled rows, available after reopening, with mouse-wheel and keyboard navigation, rectangular selection/copy, and ordinary input paste in standalone and IDE terminals.

Guest Kotlin enums expose immutable EnumType.entries in declaration order, including empty enums and enums from platform/addon libraries. Entries expose their declaration name and zero-based ordinal, including through Enum<E> and Enum<*> references. Indexing, iteration, membership and IDE completion share the typed EnumEntries<E> API.

Joining a peripheral network assigns unnamed devices unique numbered names such as display_1; existing names are preserved and generated names remain stable across reloads.

Create boilers appear as one whole structure in the configurator: every tank segment shares its controller's name and network, with one outline around the complete tank. Explicit interaction consolidates older per-block bindings; addon providers can opt into the same bounded structure geometry.

Redstone Ports show input/output strength independently on all six faces; the central and all four edge indicators on each face light together according to that face’s signal.

Newly compiled Guest programs allow 64 nested calls, matching the runtime limit, so framed nested UI drawing fits within the declared stack budget.

The shell repeats the failure reason beneath multiline program diagnostics so it remains visible after a long stack trace.

Guest Kotlin supports classic compile-time contracts for callback invocation counts, definite local initialization and conditional null/type smart casts. Contracts cover standard scope functions, preconditions, buildString and nested display UI construction; narrowed primitives retain explicit same-type casts and Elvis behavior. Declarations add no runtime builder or VM operations.

Display frames record bounded drawing packets through DisplayFrame, reducing host round trips while retaining clipping, atomic publication and drawing quotas. Canvas/widgets/UI draw through the frame recorder. Retained UI rendering skips unchanged frames and repaints damaged regions, with explicit invalidation for custom animation. Display synchronization sends RGB rectangles, keeps multi-panel updates coherent and restores missing client bases from complete snapshots; unchanged panels avoid texture uploads.

Guest displays provide a lightweight declarative widget DSL with explicit pixel viewports, rows/columns, reusable mutable widgets, a clipped drawing canvas and a rotation-slider cube example. Server-validated held-right-click gestures support captured dragging, release and cancellation without a reactive runtime; display clicks and dragging do not trigger the player's hand-swing animation.

Typed peripherals are exclusive to the acquiring program, including reads and competing processes on one computer. Program exit and lost connectivity release ownership. The built-in Redstone Port provides remote six-face input sampling, asynchronous waits and weak/direct output control through peripheral networks, including atomic all-face writes with Side.ALL as the default port-level output selection; its transient outputs clear when control is released.

All main, addon, development-stand and API-documentation builds use Gradle 9.8.1, with the binary distribution verified against its published SHA-256.

The IDE has a named peripheral selection window with shared window controls, block item icons and project-style cards. Selected cards offer plain network-name copying, server-validated rename, typed lookup copying with an API choice for shared devices, and explicit undoable const val insertion beneath imports in the active Kotlin source. Rename rejects stale or replaced devices and name conflicts throughout the network. Constants use uppercase snake-case identifiers, duplicate reuse and collision suffixes; copying and rename leave existing source unchanged.

Displays accept empty-hand front-face clicks in whole-screen pixel coordinates, exposed through GraphicalDisplay.pollClick(). Input belongs to the drawing program and is bounded and transient. Guest widgets provide buttons, indicators, gauges and history charts. The create-scada example controls a Create kinetic drive with real speed/load readings, RPM commands and connection/load alarms. Its input loop runs independently of telemetry sampling, applies commands before drawing and avoids unchanged redraws.

The all-addon development build uses Loom directly and enables Configuration Cache and parallel execution, allowing independent built-in program artifacts to compile concurrently inside the included Compukters project.

Addon SDK accepts immutable value-class host responses, nested data/value mixtures and canonical stdlib geometry. Value layouts coexist with precompiled interface methods and companion providers. Inline record fields avoid Guest record allocations while retaining bounded copying, GC and checkpoint support. Sable 2.0 exposes value snapshots with Vector3d, validated Rotation3d and Matrix3d mass tensors.

Guest stdlib provides immutable Vector2d, Vector3d and Vector4d with Double arithmetic, robust normalization and explicit conversions to/from existing vectors. Distinct Quaternionf/Quaterniond preserve quaternion identity and support explicit conversions with the corresponding four-dimensional vectors. Rotation3f/Rotation3d represent spatial rotations through normalized quaternions, with composition, inverse, axis-angle and direction-to-direction factories, shortest-arc spherical interpolation, angular distance, vector transforms, matrix conversion and read-only quaternion component access through x, y, z, w. Float rotations use Double intermediates for composition. Matrix3f, Matrix3d and Matrix4d provide row-major transforms and bounded native matrix kernels; Double variants retain Double precision through multiplication and projection.

IDE tooling loads canonical platform navigation sources under a separate bounded budget, so expanding the standard library does not consume the user project or addon source budgets.

Guest Kotlin provides reusable StringBuilder and buildString, full CharSequence support for strings, builders and user implementations, text iteration, take/drop helpers, padding and repetition, plus signed and unsigned integer parsers with radices 2–36. Search, whitespace checks, splitting and sizing accept CharSequence; specialized String overloads preserve String results. Text operations preserve UTF-16 units and respect managed heap quotas; malformed integer text returns null or throws NumberFormatException according to the selected API.

Guest Kotlin supports named local functions with direct calls, recursion, nested helpers and escaping references. Mutable captures share state with surrounding code and lambdas; direct immutable captures stay in typed arguments. Local functions can use expression defaults and appear in class initializers. Generic local functions and local helpers inside generic top-level functions specialize concrete calls, defaults and escaping captures; primitive arguments remain unboxed within bounded compiler expansion. Generic class methods and custom accessors also admit local helpers and callbacks capturing their concrete owner, parameters and shared mutable locals; captured owners observe later field updates. Class val/var properties can store, replace and invoke callbacks, including concrete generic holders, constructor defaults and custom/inherited accessors. Nullable callbacks can default or reset to null, use safe invocation, Elvis and smart casts, and retain separately held aliases after reset. Safe Unit calls can produce a retained Unit? result. Stored callbacks retain their captures until unreachable.

Guest Kotlin functions accept expression default arguments using earlier parameters, receivers, helpers, lambdas and concrete generic types. Explicit arguments evaluate before omitted defaults; inherited defaults preserve overriding method dispatch. Function references can omit trailing default parameters; bound receivers are captured once and defaults evaluate on every invocation, including inherited method and platform array defaults.

Guest Kotlin provides kotlin.random.Random with reproducible Int/Long seeds, a fixed-seed shared default generator, signed and unsigned ranges, floating draws and byte-array filling. Generator state survives instruction slices and computer checkpoints.

The built-in cmatrix program draws animated green terminal rain with bright stream heads, configurable tick delay and Ctrl+C return to the shell. Its rain uses the reproducible Guest stdlib random generator with uniform bounded selection; glyph drawing creates no temporary Guest strings.

The built-in shell supports cursor editing, Unicode-aware deletion, horizontal scrolling and a bounded 32-command history that restores unfinished input. Ctrl+U clears the line; Ctrl+C cancels input or stops the foreground command tree and returns to the shell. IDE Run submits a complete command atomically at an empty prompt; unfinished input and running editors remain protected.

Guest Terminal provides owned typed Text/Key/SubmittedLine events, named keys and modifiers, standard-library integer geometry for cursor/drawing operations, terminal size observations and named palette colors. Output accepts CharSequence via toString(), individual Char values and CharArray ranges; char/buffer output avoids temporary Guest strings, including glyphs in cmatrix and row buffers in edit. The old public raw event protocol is replaced; built-in shell, editor and benchmark agent use the new API.

Gradle Configuration Cache is enabled by default for built-in program generation, Minecraft classes, shared tooling assembly, SDK staging, development runs and the global build and verifyLocalFull task graphs. Dependency isolation, archive and license checks remain active on replay, including detection of newly added media files. Independent built-in compiler tasks can run in parallel within the same project; cached build-version selection tracks Git tags on HEAD. Minecraft builds use Loom directly for common module packaging and development runs, without the Architectury Plugin transformer or Java agent.

Guest compilation and process launch accept lexical Path values and normalize dot components before native access. Compiler.compile returns a typed result with its own diagnostics and the canonical installed output; failed compilation preserves existing executables. Built-in kotlinc, shell and boot use these APIs.

The built-in shell provides cat, mkdir (including -p), mv and rm, plus command-specific help. File commands support quoted names and normalized dot paths. Text output preserves Unicode across bounded writes; moves refuse replacement and deletion is limited to files and empty directories. Executable paths normalize before foreground launch.

IDE hover displays short Kotlin signatures with explicit return types, compact documentation entries and source information below the documentation. KDoc retains indented code examples and Markdown hard breaks. Editor and long hover scrollbars support thumb dragging and page clicks alongside mouse-wheel scrolling. Hover documentation and Go to Declaration resolve platform callback overloads to their exact attached source, including callbacks with a receiver. Unknown references color their complete identifier; errors and warnings underline their exact source ranges. Hovering a marked token shows its problems together, preserving source editing and horizontal scrolling. Problems and Find Usages align text, selection and click bounds within each row. Argument hints open when typing a call or argument separator, or pressing Ctrl+P; they wrap long signatures, emphasize the current parameter and show its English KDoc. Ctrl+Up/Down selects overloads without moving the caret. IDE controls share an outlined neutral style, with vertically centered labels in toolbars, dialogs, project navigation and status/search bars. Hover and completion popups reserve space around every text row. Floating IDE windows share subtle borders and rounded corners; the embedded terminal shares the standalone terminal background and IDE window chrome and focus accent. Floating windows also cover native block item icons in underlying controls. Attached addon sources have a separate bounded allowance, so bundled library sources do not exhaust it. Closed IDE screens ignore late ticks during screen transitions and client shutdown.

Guest Kotlin specializes Array<T> for all twelve non-null primitive families with dense, unboxed element storage, including constructors, indexed access, direct loops and concrete generic functions/classes. Copies preserve dense storage when types match and box elements when copying into nullable or Any arrays.

Guest Kotlin supports do-while loops with body-local variables in the condition, and labeled break@label / continue@label across nested while, do-while, Int progression, primitive and reference-array, and supported iterable loops. Loop jumps preserve managed exception and finally cleanup across VM instruction slices.

Contributors can create, diagnose and safely complete task worktrees with worktree-task: local dev/main bases, readiness diagnostics, integration checks and cleanup with archived evidence, pinned VM and optional addon initialization, reuse of available local Git objects and automatic independent Gradle-cache preparation. Interrupted setup can resume in a clean checkout without resetting its branch.

Agent Gradle worktrees initialize independent writable caches from a workspace template using reflinks, sharing unchanged disk data while keeping build locks separate. Missing templates bootstrap from idle local caches or a successful first build, including after cache deletion. Template refresh preserves existing homes and rejects active managed sources; unsupported filesystems never silently allocate full cache copies.

Guest reference arrays support direct for loops and Array(size) { index -> value }, including strings, objects, nullable elements, reusable vector value classes and generic container elements. Initializers run once per ascending index and preserve managed exception behavior.

Guest paths are pure portable String-backed value classes, constructed with Path(...) or the explicitly imported String.toPath() extension. Paths support . / .. and pure normalize(), with ascent clamped at root; filesystem operations use canonical virtual targets checked independently by the native boundary. A separate FileSystem API provides typed metadata/errors, binary I/O, strict UTF-8 text, directory snapshots and ordinary create/delete/move operations. Sequential readers pin their file contents; writers stage bounded chunks and publish only through a guarded atomic commit. Program exit aborts drafts, and hibernation preserves resources and their positions. The old string/status FileSystem source facade is replaced without compatibility wrappers. Optional separately imported extensions in compukter.io.path add convenient Path calls without coupling the path type to storage.

The bundled terminal editor atomically saves its complete buffer and preserves the cursor when saving. Pasted text either fits in full, including expanded tabs and automatic indentation, or leaves the document unchanged with a Buffer full message.

The IDE has open-file tabs with retained edits, caret, selection, scrolling and undo history. Tabs show unsaved changes and save conflicts, scroll when space is limited, and save modified files before closing. Screen interaction, frame composition and reusable controls are shared across both supported Minecraft versions; version adapters handle Minecraft input and drawing. Dialog fields support mouse selection, cursor and word navigation, clipboard actions, undo/redo and horizontal scrolling; token fields remain masked. Quick file opening (Ctrl+Shift+N) searches filenames and paths throughout the project, including collapsed folders, with keyboard and mouse navigation. Active tabs use a restrained background and accent underline. The header separates project, file and target; Build and Run use labeled controls when space permits. The status bar shows concise activity, with a scrollable read-only Details window and complete message copying. Source highlighting, caret, selection and mouse pointing share tab and Unicode columns, including horizontally scrolled text; scrolling keeps source text and selection clear of line numbers. Opening a project without a computer automatically creates a missing local dependency lock for Kotlin analysis and Build, without saving source drafts or replacing existing locks. Deploy and Run require an attached computer.

Documentation offers a version selector for released 0.5.1 and nightly guides and API references. The released documentation opens by default; nightly identifies its current source commit.

Guest kotlin.math provides reusable Vector2i, Vector2f, Vector3i and Vector3f value classes, Position/Size aliases, arithmetic, dot/cross products, lengths, normalization, interpolation, explicit rounding and half-open 2D rectangles. Displays accept vectors and rectangles while retaining scalar coordinate calls. Infix xy, by and sized provide compact geometry construction. Immutable Matrix4f and homogeneous Vector4f add reusable 3D transformation composition, radians-based axis rotations, perspective/orthographic projection and explicit perspective division with clip-volume checks. Matrix products, point/direction transforms and transposition execute as VM intrinsics with scalar Float semantics.

Guest executables omit unused class and interface methods and their dependencies. Virtual dispatch keeps its required implementations; independently compiled libraries retain their exported method surface.

IDE analysis prepares project snapshots in the background and coalesces rapid edits before preparation. Diagnostics, semantic highlighting and completion retain revision checks; existing presentation follows edits while new results are pending. Worker cancellation no longer blocks typing on pipe writes.

Compukters: Sable 1.2 supports peripheral networks between shore devices and moving constructions. Access follows real world distance, including rotation and scale; assembly and return preserve bindings, names and complete display images. Partial display transfers split into panels with their published tiles and network membership. Physics.massProperties() exposes immutable merged mass, plot-space center of mass and the full inertia tensor for Guest flight-control calculations while retaining the existing pose snapshot API.

The IDE prepares resolved compiler libraries in the background when opening a project and after dependency or target-profile changes. Repeated Guest compilation reuses that library analysis, semantic hashes and export indexes within the retained worker, including across IDE reopenings. Lowering indexes admitted callable names and signatures instead of repeatedly scanning their registries. Final executables are validated and serialized once with compilation limits. Changing the dependency selection replaces the preparation; each project compilation keeps its own source session and specialization state. Queued preparation yields to Build.

Host capabilities and addon SDK bindings exchange ByteArray directly, preserving arbitrary binary data within a 4096-byte call limit. Runtime 0.23.0 / native ABI 23 replaces the previous native boundary; existing VM checkpoints cold boot while retaining persistent files.

Existing Peripheral Cables become Computer Cables: one nonbranching physical line joins two computers, with one cable connection per computer. Placement rejects branches, loops and occupied ports without consuming the item. Guest programs exchange binary messages through Network.send(ByteArray) and Network.receive() with no addresses; bounded inboxes and catchable interruption handle unavailable peers and broken connections.

Displays retain RGB graphics and their resolution across program exit, disconnection, chunk unload and server restart. Programs draw pixels, lines, rectangles, text and images, with optional coherent frames. Scaled text rasterizes the font at the requested size, retaining detailed strokes while preserving text cell spacing.

Holding the Peripheral Configurator reveals nearby devices, networks and screens with animated outlines hidden behind walls. Joined displays have one outer rectangle in every mode, using the network color in Network binding. Screen holes, unjoined replacement panels, selected groups and assembly previews are visible, with context and action hints beside the crosshair.

The Peripheral Configurator assembles and expands planar screens up to 8×8 blocks, including holes. Matching replacement panels automatically rejoin and restore their image and network; removing the last panel deletes the screen. Selecting a screen and Shift-clicking it again splits it into separate panels, preserving their images, resolution and network while removing the shared name. Programs select 16×16, 32×32, 64×64 or 128×128 pixels per block. A screen has one network binding shared by all panels. Assembly inherits a single existing network or clears conflicting bindings; any surviving panel keeps the screen reachable. Existing TextDisplay programs use the same persistent canvas, with their text grid spanning the entire composite screen.

The addon development stand and standalone Propulsion build use Aeronautics/Simulated 1.3.2, fixing the Simulated mixin crash with recent JEI versions.

Development builds use the standard -SNAPSHOT suffix, allowing NeoForge to order them below the matching release and accept them within published addon dependency ranges.