MCHPRS: the per-plot multithreaded Minecraft server built for computational redstone

Per-plot threading and Redpiler: the two design choices that set this server apart

MCHPRS describes itself as very different from traditional Minecraft servers. Two decisions make that concrete. First, each 512x512 plot runs on a separate thread, so redstone circuits in different plots do not compete for CPU time. Second, Redpiler ships as part of the server. Described in the README as the Redstone Compiler, Redpiler compiles redstone circuits to run faster than per-tick simulation.

A demonstration linked in the README shows running what it calls a limited form of Minecraft on CPUs built from redstone inside MCHPRS, cited as an example of the speed Redpiler makes possible. That is the target use case: computational redstone where circuits implement actual logic, not decorative contraptions.

Many features present in vanilla Minecraft servers are absent. MCHPRS is explicit about this in its README. Operators expecting a general-purpose server should read the description as a hard constraint, not a caveat.

Building from source requires Rust; the dev profile carries a note about why opt-level 0 fails

MCHPRS requires a Rust toolchain. An install link for Rust is in the README. Building and running:

git clone https://github.com/MCHPR/MCHPRS.git
cd MCHPRS
cargo build --release

Output lands at ./target/release/mchprs on Linux and macOS, or ./target/release/mchprs.exe on Windows.

Cargo.toml contains a comment that is easy to miss. Under [profile.dev], opt-level is set to 1 with this comment: "MCHPRS runs far too slow without any optimizations to even be usable for testing." Rust's default dev profile uses opt-level = 0. For MCHPRS, testing without at least opt-level = 1 is documented as not viable. lto = "fat" is enabled in the production build profile, with a comment in Cargo.toml saying it speeds up Redpiler compile times.

A Docker path also exists. A multi-stage Dockerfile builds from rust:alpine and runs from a scratch base image. Port 25565 is exposed, /data/ is mounted as a volume, and /mchprs is the entrypoint. No OS layer is included in the runtime image.

Config.toml is auto-generated; plot size is not in the config and requires a source edit

MCHPRS generates Config.toml in the working directory on first start. Documented toplevel fields include bind_address (default 0.0.0.0:25565), motd, chat_format, max_players (99999), view_distance (8), whitelist (false), schemati (false), block_in_hitbox (true) and auto_redpiler (false).

Keeping max_players at its default of 99999 means no enforced player cap. Setting schemati to true enables compatibility with the Open Redstone Engineers Schemati plugin's verification and directory layout. auto_redpiler defaults to false, so Redpiler must be triggered manually unless the value is changed.

Plot size is the notable absence from Config.toml. Changing it requires editing constants in crates/core/src/plot/mod.rs and rebuilding. There is no runtime option. 512x512 blocks per plot is the hardcoded default.

Whitelist defaults to false, meaning any player can join unless whitelist.json is configured and whitelist is set to true. On any public-facing deployment, this field needs attention before port 25565 is opened.

/rtps and /radvance control simulation speed; /container calibrates comparator power levels

Commands in MCHPRS are tailored to redstone development, not general gameplay. /rtps sets redstone ticks per second, accepting a numeric value, fractional values, or unlimited; default is 10. /radvance (alias /radv) advances the plot by a given number of redstone ticks. Two game ticks make up one redstone tick. Used together, these two commands let a developer slow down or step through a circuit during debugging without touching the circuit itself.

/container gives the player a container, such as a barrel, configured to output a specific power level when read by a comparator. This is a calibration utility for comparator-based circuits: rather than filling a container to exactly the right item count, the command sets the output directly.

/worldsendrate (or /wsr) controls the rate at which world updates are sent to clients, in hertz, from 0 to 1000; 0 disables periodic sends. Default is 60. /toggleautorp switches automatic Redpiler compilation on or off. /stop stops the server.

No built-in player authentication; Velocity modern forwarding is the only documented option

MCHPRS has no support for player authentication on its own. Operators who want authenticated players must run a Velocity proxy. Velocity's player-info-forwarding-mode must be set to modern, and Config.toml must include a velocity block:

[velocity]
enabled = true
# This is the secret contained within `forwarding-secret-file` from your velocity config,
# NOT the path to the file.
secret = "<secret>"

LuckPerms is supported for permissions, but only with MySQL or MariaDB remote database storage. Its implementation has no commands or interface inside MCHPRS; management goes through LuckPerms running on a proxy (/lpb) or another server (/lp). Adding LuckPerms requires appending a [luckperms] section to Config.toml with host, db_name, username, password and server_context fields.

Neither authentication nor permissions management is handled locally. Both depend on external infrastructure that must be configured and maintained separately.

Vanilla Minecraft features are absent; a standard Minecraft server is the comparison point

MCHPRS targets Minecraft 1.20.4. Clients connecting on any other protocol build will fail, since no other compatibility is described in the README.

A vanilla Minecraft server or a Paper-based server runs all game logic in a single tick loop and simulates redstone block by block. MCHPRS runs each plot in its own thread and compiles circuits with Redpiler. The trade-off is the absence of the full vanilla feature set: mob spawning, survival mechanics, economy plugins and anything outside the redstone domain are all out of scope. For teams who need standard gameplay alongside redstone, a general-purpose server covers both while MCHPRS covers only the latter.

For redstone-only work, MCHPRS offers per-plot isolation and compiler-level speed. For anything beyond that, it is the wrong tool.

The workspace separates redpiler, redstone, schematic and world into distinct crates

Cargo.toml reveals a workspace with members named block_data_gen, proc_macros, redpiler_graph, rilc, schematic, world_exporter, core, world, blocks, redpiler and redstone. Separating redpiler and redstone into their own crates means compiler changes and simulation changes can be developed independently. schematic and world_exporter handle file import and export, which connects to the schemati compatibility feature in Config.toml.

No plugin API or extension mechanism is documented in the README or visible in the workspace layout. Redpiler has its own documentation file at docs/Redpiler.md, not included in the README. The last push was on 2026-09-28, and the MIT licence applies to the project.

Editorial conclusion

MCHPRS suits Minecraft redstone engineers who want to build and test computational circuits without the per-tick overhead of a standard server. Skip it if you need vanilla gameplay, mob support, or any feature the README says does not exist in this server. Before deploying, confirm that your Minecraft clients connect to a 1.20.4 server, since no other compatibility is described. Also verify authentication: there is no built-in player auth, and Velocity modern ip-forwarding is the only documented path for authenticated players.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. MCHPR/MCHPRS on GitHub
4. README
5. Releases