Compukters

Program computers in Minecraft with Kotlin through an integrated in-game IDE.

Compukters is an in-game programming platform built around Kotlin projects, programmable computers, persistent storage, redstone automation, and a deterministic resource-bounded virtual machine.

Compukters is experimental and under active development.

The complete programming loop works, but Guest Kotlin, its APIs, and the player-facing experience continue to evolve. Breaking changes may occur between releases.

Write Kotlin in the integrated IDE

Create persistent multi-file projects without leaving Minecraft. The client-side IDE provides:

• syntax highlighting, diagnostics, completion, hover information, and parameter information;
• declaration navigation, Kotlin-aware formatting, smart typing, and editor history;
• a project explorer, remembered workspaces, and versioned Compukters platform configuration;
• attachment to a computer with verified build, deploy, and run actions;
• read-only previews and imports from the attached computer's filesystem;
• an attached terminal for interacting with the target computer directly.

Code analysis and compilation run in isolated Kotlin K2 workers using the same Guest API definitions as the target computer.

Run programs on real computers

Every computer boots into an interactive shell and owns an isolated persistent /home filesystem. Programs and files survive chunk unloads and world restarts. For quick edits, the computer also includes compact terminal tools:

edit hello.kt
kotlinc hello.kt
hello

Guest programs can launch bounded cooperative tasks, communicate through IntChannel, start other programs, wait for terminal input, and produce computer sounds.

Automate with redstone

Programs can read and control all six sides of a computer relative to its facing. The Guest Kotlin API supports:

• immediate redstone input reads;
• efficient waits for the next change, an exact level, or a minimum level;
• output levels from 0 to 15;
• persistent weak and direct power modes.

Kotlin, without unrestricted JVM access

Compukters uses the Kotlin K2 frontend, but Guest programs do not run as Kotlin/JVM and cannot access arbitrary Java classes, Minecraft internals, the server filesystem, or the host operating system:

Kotlin source
    ↓
Kotlin K2 / IR
    ↓
verified Compukter bytecode
    ↓
managed runtime

The runtime controls memory, execution quotas, scheduling, and every capability exposed to programs. Guest Kotlin is a deliberately bounded subset of the language and standard library; consult the support matrix for exact details.

Compatibility

• Minecraft 1.21.1 — NeoForge 21.1.250 or newer, Java 21
• Minecraft 26.1.2 — NeoForge 26.1.2.97 or newer, Java 25
• Operating systems: Linux x86_64 and Windows x86_64

Each Minecraft version has its own download. No Architectury runtime dependency is required.

Links

• Documentation and getting started
• Guest Kotlin support matrix
• Redstone API and behavior
• Changelog
• Source code
• Development blog — in Russian
• Software license — Apache-2.0
• Media licenses and credits

Compukters

Compukters brings programmable computers to Minecraft, powered by Kotlin and a custom sandboxed virtual machine.

Write programs, run them from an in-game shell, and keep their files between world sessions. Behind the scenes, Kotlin source is compiled into verified Compukter bytecode and executed by a resource-bounded Rust VM built specifically for the mod.

Compukters is still in early development.

The foundations are working, but the programming tools, APIs, and player-facing experience are evolving quickly. Expect incomplete features and breaking changes between development builds.

What works today

The current development version includes:

• an in-game computer block with an interactive terminal;
• Kotlin source compilation through an isolated compiler process;
• a shell and boot system written as ordinary guest programs;
• foreground program execution;
• a persistent virtual filesystem for each computer;
• verified Compukter bytecode;
• deterministic, resource-bounded execution;
• a managed virtual machine written in Rust;
• integration with Minecraft world saves and the computer lifecycle.

There is also a standalone playground for running Kotlin projects through the same compiler and runtime used by the mod.

Programming in Kotlin

Programs for Compukters are written in Kotlin, but they do not run on the JVM inside the virtual computer.

Instead, player code passes through the Kotlin K2 compiler frontend and is translated into Compukter's own bytecode:

Kotlin source
    ↓
Kotlin K2 / IR
    ↓
Compukter bytecode
    ↓
Managed Rust VM

This provides a familiar statically typed language while allowing the mod to control memory, execution time, available APIs, and access to the Minecraft server.

Guest programs cannot access arbitrary Java classes, Minecraft internals, the server filesystem, or the host operating system. They interact with the outside world only through explicit capabilities provided by the computer.

Built for automation

Compukters is intended to grow beyond a single computer block.

Future devices may range from small programmable controllers to full computers with storage, networking, peripherals, and richer runtime services. Compatible devices will share the same language and program format while differing in resources and available capabilities.

The long-term goal is to support practical automation without requiring every computer to behave like a permanently running heavyweight emulator. Programs should be able to sleep while waiting for events, operate within predictable resource limits, and scale to larger builds and multiplayer servers.

Development status

Compukters is experimental and under active development.

The runtime, compiler, filesystem, terminal, and basic program execution are already connected end to end. The next major areas of work include expanding the guest APIs, improving filesystem and shell tooling, and building a more complete in-game programming workflow.

Currently targeting:

• Minecraft 26.1.2
• NeoForge
• Java 25

Links

• Source code
• Development blog — in Russian
• License: Apache-2.0