Early stage · 70 mechanics ready · 35 partial

A Minecraft server in Rust.
Paper plugins run without a rewrite.

Engine, networking, worldgen and lighting are Rust, with no GC pauses. A real paper-api.jar lives in a JVM inside the server process. One binary: game data and the plugin API are embedded.

chunkwake setup --dir ./server

Quick start Download

Windows x86_64 · Linux x86_64 (musl) · Java 25+ only for plugins

chunkwake doctor~/server

$chunkwake doctor --dir ./server

server.properties ok

embedded vanilla data 26.3

port 25565

java 25 (plugins) found

ready in 34 ms

paper-api.jar embedded · 1 binary

●engine: rust · plugins: jvm · ticking: 20 tps

Benchmark

One bench. Two servers.

Not synthetic: the same world, the same bots and the same scenarios. Switch metrics and see where the difference actually shows up.

Vanilla 26.36.6–11.4 s

Chunkwake0.6–0.9 s

×12faster · Lower is better

From process start to accepting players. Game data is already in the binary. Ryzen 9 7945HX, release, flat world, view distance 2, 20 bots, 20 s warmup, 45 s measurement, two runs. Animation is accelerated; proportions between measurements are preserved. Full method and raw data ↗

Compatibility

Ordinary Paper plugins on a multithreaded core.

Chunkwake runs Paper plugins while the engine is built around Rust and tokio.

Core	Paper/Folia plugins	Multithreading
Paper	Ordinary plugins	Single main thread
Folia	folia-supported only	Regions
Chunkwakethis	Paper and Folia APIs	By stages

The compatibility boundary is plugins that reach into NMS and CraftBukkit internals. Vanilla classes are on the classpath and some of those plugins work; this is not promised in full.

What works

World, mechanics and plugins already work.

World generation, redstone, mobs, inventory and plugins are implemented. The line-by-line status matrix is in the docs.

worldgen

World

Vanilla overworld generation
Nether and End
Anvil read and write
Light, spawn, world border
Villages and structures

tick

Mechanics

Redstone and pistons
Fluids, fire, random ticks
Mobs, projectiles, XP
Furnaces, anvil, stations
Signs and books

jvm

Plugins

The real paper-api.jar
Events in Paper order
Folia schedulers
Maven libraries, loader/bootstrapper
NMS classes on the classpath

ops

Operations

One binary
setup, doctor, config set
Backups and rollback
Built-in metrics dashboard
Vanilla commands

Full feature matrix: 70 ready · 35 partial · 7 not started.Open matrix

Plugin developers

Plugins compile and run as they do on Paper.

The official paper-api.jar is on the classpath. The API behaviour is implemented, so code compiles and runs as it does on Paper.

Bukkit and Paper events in Paper order, with cancellation and data replacement.
GlobalRegionScheduler, RegionScheduler, AsyncScheduler and EntityScheduler for every plugin.
plugin.yml and paper-plugin.yml, Maven libraries, loader and bootstrapper.
PDC, Metadatable, registries, tags, attributes and plugin channels.

Plugins need Java 25+. The server finds it via java-path, CHUNKWAKE_JAVA or PATH.

Plugins paper-api

.java / .kt

public final class HelloPlugin extends JavaPlugin {
  @Override
  public void onEnable() {
    getServer().getPluginManager().registerEvents(new Listener() {
      @EventHandler(priority = EventPriority.NORMAL)
      public void onJoin(PlayerJoinEvent event) {
        event.getPlayer().sendMessage("chunkwake is awake");
      }
    }, this);
  }
}

class HelloPlugin : JavaPlugin() {
  override fun onEnable() {
    server.pluginManager.registerEvents(object : Listener() {
      @EventHandler(priority = EventPriority.NORMAL)
      fun onJoin(event: PlayerJoinEvent) {
        event.player.sendMessage("chunkwake is awake")
      }
    }, this)
  }
}

plugin.ymlyaml

name: HelloPlugin
version: 1.0.0
main: dev.chunkwake.hello.HelloPlugin
api-version: "26.3"

Architecture

A Rust core with plugins in the JVM.

The core and the world live in Rust. Plugins live in a real JVM next to it through a JNI bridge. If an event has no listeners, Rust never sends it anywhere.

workspacetree

crates/
├── protocol    packets 26.3, NBT, text components
├── net         connections, game, commands, events
├── worldgen    noise, biomes, surfaces, structures
├── world       chunks, palettes, Anvil, light
├── bridge      JVM over JNI, embedded API
├── server      binary: CLI, setup, console, backups
├── metrics     metrics and dashboard
└── lab         vanilla comparison and benchmarks

java/
├── api-impl    Bukkit / Paper / Folia on top of Rust
└── test-plugin live event checks

runtime graphhover a node

Client 26.3

net · tokio

world · worldgen

redstone · mobs

JNI bridge

JVM · paper-api

plugins/*.jar

React Flow

About 170k lines of Rust and 14k lines of Java.

What is planned.

These features are not in a release yet. The design is described in ARCHITECTURE.md.

01STM tick

Parallel ticking with Paper semantics

Plugins see one main thread while executing in parallel.

02Islands

Dynamic islands instead of regions

The world is split by load, not by Folia’s fixed grid.

03Event log

The world as an event log

Rollback and replay instead of whole-world backups.

04Panama

An FFM bridge with shared memory

The next generation of the Rust/JVM boundary.

All milestones and current focus

Try it on your server.

Release builds will appear here as soon as the first tag ships. For now, build from source in a couple of minutes.

Open documentation Download page