Minestom, FerrumC and Pumpkin: Minecraft Servers From Scratch

Pumpkin, FerrumC and Minestom: The Minecraft Servers Built Without Mojang's Code

Pumpkin and FerrumC are Minecraft servers written from scratch in Rust, and Minestom is a Java library for building a server of your own; none of them contains a line of Mojang's server code. None of them runs Bukkit, Spigot or Paper plugins natively or Forge, NeoForge or Fabric mods, and only Pumpkin comes close to vanilla survival, so a community server that needs plugins today should stay on Paper or Purpur. Minestom suits development teams building minigames, Pumpkin is worth testing on a spare machine, and FerrumC is for people who want to contribute to its rewrite.

Every option on our server software comparison, from vanilla through Paper to NeoForge, is built on Mojang's server code or patched into it. Leaving that code out is where these three get the speed and small memory footprint they claim (no Java runtime for the two Rust servers, no vanilla gameplay at all in Minestom), and also where their limits come from. Everything below was checked against each project's own repository and documentation on 4 October 2026.

Compared with Paper

Software	Language and licence	Minecraft version	Loads a vanilla save	Bukkit, Spigot or Paper plugins	Forge, NeoForge or Fabric mods	Vanilla mechanics
Paper (baseline)	Java. GPL-3.0, inherited from Spigot and CraftBukkit.	Java 26.3: alpha builds from Mojang's release day, beta builds since 28 September 2026.	Yes. It is Mojang's server with patches, so the world format is the same.	Yes, natively. This is the ecosystem everyone else is measured against.	No.	Complete, with Paper's documented deviations from vanilla.
Pumpkin	Rust. GPL-3.0 for the server; the plugin API crates are MIT or Apache-2.0.	Java 26.3 and Bedrock 26.51, since its 20 September 2026 release.	Yes, Anvil region files, but only in the latest world format for its target release.	Not natively. Some run through PatchBukkit, which embeds a JVM, with gaps expected.	Not documented anywhere we could find.	Partial: 72 percent of tracked items implemented, 26 percent partial. Entities are the weak area at 31 percent.
FerrumC	Rust. MIT.	Java 1.21.8 only. The v2 rewrite calls the 2026 releases out of scope.	The 1.21.8 master branch says it can import existing vanilla worlds. For the v2 rewrite the repository disagrees with itself: the master README banner says it can, the rewrite branch's own README lists Anvil import as roadmap.	No. The README FAQ says this will not happen even with a perfect API match, because Java plugins depend on reflection and dynamic class loading.	No, same answer and same reason.	Very little. v2 is flat world, creative, offline mode, no mobs, no redstone, no survival, by its own feature list.
Minestom	Java. Apache-2.0.	Java 26.2. Support for 26.3 was still an open pull request on 4 October 2026.	Yes, through its AnvilLoader, once your code wires it in.	No, by design: it implements none of the Bukkit, Forge or Sponge APIs.	No, same reason.	None by default. Every mechanic, from opening a chest to generating terrain, is code you write.

Pumpkin

Repository: Pumpkin-MC/Pumpkin, created 28 July 2024. On the day we checked it had 11,914 stars, 867 forks, 619 open issues, 306 contributors, and commits merged that same morning. It is by far the most active project of the three.

Version target. The latest tagged release is 0.2.0+26.3-26.51, published 20 September 2026. The tag encodes what it supports: Minecraft Java 26.3 and Bedrock 26.51. The previous release, 0.1.0-dev+26.2-26.45, came out on 4 September 2026, and Mojang published Java 26.3 on 15 September 2026, so Pumpkin followed the Minecraft update within five days. Nightly and canary builds are published as prebuilt binaries for Linux, Windows, macOS and Android, and there is a Docker image. Release 0.2.0 also removed built-in support for multiple Java client versions from the core; backwards compatibility now lives in a separate plugin called pumpkin-java-multiversion.

How finished it says it is. The README states "Pumpkin is currently under heavy development", the front page says "Pumpkin is not finished. Not every vanilla mechanic is in yet, worlds can break between versions, and config keys still move. Run it on a test server first, keep backups", and the documentation's quick start is headed "Pre-release". The 1.0.0 roadmap issue, open since January 2025 and last updated 5 September 2026, plans the first stable release for 2026 and still has two boxes unticked: a stable plugin ABI and a private community test run.

What works, by its own tracker. The project publishes a vanilla parity tracker that regenerates from the source tree, so it is the place to check whether the numbers below have moved. The snapshot we read was generated from commit 742beaf for Minecraft 26.3 on 30 September 2026: 564 entries, of which 406 (72 percent) are implemented, 145 (26 percent) partial and 13 (2 percent) planned. By category: commands 96 percent, items 93 percent, redstone 93 percent, combat 93 percent, blocks 83 percent, world systems 81 percent, entities 31 percent. The tracker's own caveat: "green means the code exists, not that every edge case matches." The entity number is the one that matters for survival. Of 40 hostile mobs, 6 are marked implemented and the rest partial; of 46 passive mobs, 6 are implemented. The Ender Dragon and Wither are both partial. A mob brain framework and an A-star navigation system landed in 2026, so mobs exist and move, but they do not yet behave like vanilla mobs.

Redstone. The redstone tracking issue, updated 29 September 2026, ticks wire propagation, tick order, hard and soft power, comparators, repeaters, observers, hoppers, droppers, dispensers, the crafter, note blocks, rails and TNT. Two items are open: the daylight detector, and pistons, which the issue itself describes as "currently broken". If your community builds piston doors or flying machines, that is the line that decides it.

World generation and your existing world. The chunk generation tracking issue is closed with every phase ticked: noise terrain, all Overworld, Nether and End biomes, carvers, features, ores and every vanilla structure from strongholds to end cities. The 0.2.0 release notes still contain fixes like "Prevented Overworld biomes from leaking into the Nether and End dimensions", so generation is implemented and still being debugged. For existing saves, Pumpkin reads standard Anvil .mca files and can also store chunks in the third-party "linear" region format or in its own "pump" format. The migration guide is explicit about the one trap: "Pumpkin only supports the latest world format and latest data pack format for its target Minecraft release. Older world formats or legacy data pack versions are not automatically converted at runtime." You upgrade the world first, with the client's Optimize World or a vanilla server on the matching version, then copy it over. The tracker also marks "world loading (level.dat, DIM1, DIM-1)" and "world saving" as partial, so treat the Nether and End halves of an existing world as unproven.

Plugins. Pumpkin has its own API, and its primary plugin format is WebAssembly: a .wasm component compiled from Rust, Python, Go, C#, C or Kotlin runs sandboxed inside the server through Wasmtime, with native Rust shared libraries as a second loader. The front page advertises nine languages. The plugin development guide opens with a warning that "the Pumpkin Plugin API is still in a very early stage of development and may change at any time". There is a plugin marketplace and a set of example plugins.

Paper plugins. Not on Pumpkin itself. They can run through PatchBukkit, a separate repository (Pumpkin-MC/PatchBukkit, GPL-3.0, created 21 January 2026, 197 stars, releases matched to Pumpkin's). PatchBukkit embeds a Java virtual machine inside Pumpkin, reimplements parts of the Bukkit API and bridges calls over JNI and FFI; you need Java 25 or newer installed and the jars go in patchbukkit/patchbukkit-plugins/. Pumpkin's migration guide states the limits: "plugins that depend on internal NMS (net.minecraft.server) classes, CraftBukkit internals, or bytecode manipulation may not function properly." Its front page comparison table rates its own Bukkit and Paper plugin support as partial with the note "Early, through PatchBukkit. Expect gaps." A plain Bukkit API plugin may work, anything that touches server internals is expected not to, and nobody, the project included, promises your plugin list will load. Check each of the plugins most servers rely on against that warning before assuming anything, and note that the embedded JVM gives up the no-Java advantage for that process.

Mods. We looked for Forge, NeoForge or Fabric mod support in the README feature list, the documentation navigation and the issue tracker, and found none. Mods load Java code into Mojang's game classes, and Pumpkin has none of those classes, so there is nothing for a mod to attach to.

Performance, in their words. The front page headline is "A Minecraft server that boots in 5 ms", with a startup comparison of 0.005 seconds for Pumpkin against 15 seconds for vanilla "on the same world, same machine", and a memory figure of about 100 MB at idle with a world loaded against "near 1.8 GB" for vanilla before anyone joins. The 1.0.0 roadmap ticks a stress test of "1000+ simulated players moving and interacting simultaneously" and "a steady 20 TPS under moderate load". These are the project's measurements, not ours, and the Benchmarks page linked from the front page, which should explain how they were measured, returned a 404 when we opened it. The design supports the direction of the claim: no JVM to start, and a tick loop built to run game logic across cores instead of on one main thread. Nobody can yet say whether that holds with a full survival world, vanilla-complete mobs and PatchBukkit's embedded JVM running your plugins, because that configuration does not exist.

Other features. Pumpkin supports Velocity and BungeeCord forwarding, RCON and Query, configures everything in TOML files instead of server.properties, and lets Bedrock players join without a separate Geyser install, which on Paper means installing Geyser. It added server telemetry in 0.2.0. Without a JVM there are no JVM flags to tune and no heap to size (its migration guide spells out that -Xms and -Xmx do not exist), and none of the JVM-side profiling you know applies either.

FerrumC

Repository: ferrumc-rs/ferrumc, created 2 September 2023, MIT licence, 2,418 stars, 99 forks, 43 contributors.

Activity. The last push to any branch of the repository was 14 August 2026, and that commit fixed a chart in the README. The last code change on the master branch is dated 6 June 2026. The rewrite branch, rework/v2-skeleton, last received a commit on 18 July 2026. The only tagged releases are v0.1.0-rc1 and v0.1.0-rc2, both published on 16 February 2026, with prebuilt binaries and a Docker image. The project blog has one post, from 30 November 2025, and the website banner says "Alpha. FerrumC is under active development and not production-ready."

Version target. Both branches target Minecraft Java 1.21.8, protocol 772. The v2 branch's SUPPORTED_VERSION.md is explicit: "FerrumC v2 supports exactly one Minecraft client", "a client on any other version will be rejected", and the 2026 calendar releases are "out of scope for FerrumC v2". A player on today's 26.3 client cannot connect without a protocol translation layer in front, and FerrumC documents none.

What works. The master README describes a 1.21.8 server that is "completely multithreaded", imports existing vanilla worlds, uses its own Anvil and NBT code and an LMDB key-value store for chunks, and runs on Bevy ECS. Its "upcoming" list is where the gameplay is: "PvE mechanics, and entities", a web dashboard, and plugin support. Its FAQ calls terrain generation "very rudimentary" today and says vanilla-accurate terrain is not the goal if accuracy costs performance. The v2 branch's feature document, which the maintainers say is "verified against the code, not the plan", lists a flat creative world you can build in, correct block states for logs, slabs, stairs, fences and doors, multiplayer visibility, chat and command autocomplete, persistence of placed blocks across restarts, and Rust plugins that can allow, deny or replace block edits. Its limitations list: flat world only, offline mode only, full-bright placeholder lighting, "no survival, mobs, redstone, or full vanilla parity", and player position and inventory not yet persisted. The README banner calls it "a creative and minigame server" and "not a drop-in replacement for Paper or Spigot."

Plugins and mods. The plan is Rust plugins over a foreign function interface. The README FAQ answers the Paper question without hedging: "Will I be able to use plugins or mods from paper/spigot/bukkit/forge/fabric etc.? No. Even if we did implement a perfect 1:1 API match for the vanilla server, the underlying implementation is still completely different." The website adds that "the plugin system is currently in development and not yet generally available". One line on the documentation site's landing page mentions "basic JVM-based plugins"; it contradicts the README and no documentation page backs it, so we treat the README as the project's position.

Performance, in their words. The README's feature headings are "Extremely fast", "Highly efficient memory usage" and "Crazy fast K/V database", illustrated with animated screenshots including a 32 chunk render distance demo. The website's performance section says "early benchmarks show what happens when you replace a JVM with bare-metal Rust" and footnotes it: "Benchmarks are from internal testing and may vary. FerrumC is experimental software." No methodology is published. The FAQ also positions FerrumC against Pumpkin: "Pumpkin aims to match the vanilla server as closely as possible, often sacrificing performance and referencing decompiled vanilla code to achieve 1:1 parity. FerrumC prioritizes performance and takes a clean-room approach."

Minestom

Repository: Minestom/Minestom, created 3 August 2019, Apache-2.0, 3,297 stars, 513 forks, 192 contributors, with commits merged on the day we checked. Releases go to Maven Central as net.minestom:minestom roughly every two weeks; the latest was 2026.09.12-26.2 on 12 September 2026, following 28 August, 16 August, 7 August and 22 July releases.

Version target. The release name carries the version: Minecraft 26.2. Minestom "only aims to keep up-to-date with the latest version of Minecraft", and a pull request titled "feat: 26.3", opened on 15 September 2026, the day Mojang published 26.3, was still open on 4 October. A server built from the current release speaks 26.2, so a 26.3 client is rejected unless protocol translation sits in front. Older clients are never supported directly; the documented route is ViaVersion on a proxy, or ViaProxy standalone, and the wiki says you will get no support for either.

It is a library. The repository's one-line description calls Minestom a lightweight Minecraft server, but its documentation is stricter, in three places: "Minestom is not installed like Bukkit/Forge/Sponge", "it is a library, not a server JAR", and "this is a developer API not meant to be used by end-users". There is no jar to download and no plugins folder. You create a Java or Kotlin project, add Minestom as a dependency, write the server, and compile it. If you are not a developer, and do not employ one, Minestom is not an option.

What it does and does not do. Minestom implements the protocol, networking, chunks, entities, inventories, commands, scoreboards, advancements, and a thread model where a pool of threads ticks chunks across lightweight "instances" instead of worlds. It implements no vanilla gameplay. The wiki's own examples: "A chest is a block like any other until you tell it to open an inventory, and hitting a player does nothing by default." Mobs do nothing until you give them goals through its AI API (attack a target, stroll randomly, target the nearest player). Terrain generation is a Generator interface you implement; the wiki's first example is a flat stone slab and its second is a noise heightmap, and there is no vanilla terrain generator. Lighting for generated chunks is computed by a LightingChunk supplier on first send. Existing vanilla worlds load through AnvilLoader, which reads blocks, biomes, block entities, heightmaps and baked lighting from region files and saves back through the same path, but the default loader is a no-op that loads and saves nothing until you wire one in. A sister project, VanillaReimplementation, tried to supply vanilla features on top; it is archived and its README says it "has only a very limited list of features, consider alternatives or implementing your own".

Plugins and mods. The wiki: "Nothing written for Bukkit, Spigot, Paper, Forge, or Fabric will run." Extending a Minestom server means adding libraries to your build; the project site keeps a list of them.

Performance, in their words. Minestom's claim is about skipping vanilla, and the wiki makes it this way: "many servers today overlook the built-in mechanics in favor of custom gameplay, leading to wasted performance", and "it makes sense to use Minestom when it will take less time implementing every missing feature you want, rather than removing every vanilla feature that will slow you down." The site says it "can handle large numbers of players without any performance issues", and the README lists multi-threading and instances as advantages, alongside disadvantages it names itself: longer to reach something playable, a smaller ecosystem, and "multi-threaded environments need extra consideration".

Who should run one

• A minigame or network team with developers: Minestom. Minigames, KitPvP and creative servers are the audience its documentation names, and this is the one case where a from-scratch server is the mainstream choice rather than an experiment: per-match instances that are created and thrown away in memory, no vanilla overhead in a lobby or a KitPvP arena, and no NMS to chase after every update. You still write every mechanic you want, and your players have to be on the one version Minestom currently targets, or behind a Via proxy.
• Someone with a spare machine and curiosity: Pumpkin. Download one file, point it at a copy of your world upgraded to the current format, join, and see what breaks. Assume any mechanic your players rely on is missing or different until you have tested it, and do not move a community or its live world onto it.
• A Rust developer who wants to write server plugins in Rust, Python or Go: Pumpkin. The API may change at any time, so expect to rebuild what you write as it moves.
• Someone who wants to contribute to a rewrite: FerrumC. There is no other reason to run it in October 2026.

Who should not: anyone with a plugin list they depend on, such as LuckPerms, WorldGuard, CoreProtect or EssentialsX; any survival or SMP community; anyone running a modpack; any server with technical players who care whether a piston door or a mob farm behaves exactly as it does in vanilla; and anyone whose players are on the current Minecraft release and expect to join the day it comes out. For all of those, Paper or Purpur today, Fabric or NeoForge if you run mods, as the main comparison lays out. You would also leave Paper's support base behind: most Paper errors have been seen and written up before, while a Pumpkin crash on your world is a GitHub issue you will probably be the first to file.

Related projects: Folia and Valence

Folia is PaperMC's own answer to the complaint behind these projects: Paper ticks the world on one main thread, so extra cores do little for tick speed. Folia keeps Mojang's code and the Bukkit API shape and changes the threading model: nearby chunks are grouped into regions, each region has its own tick loop, and the regions tick in parallel on a thread pool. Its README says "There is no main thread anymore." Like the from-scratch servers, it pays in plugin compatibility: the README tells plugin authors to "have your expectations for compatibility at 0", Folia loads only plugins that declare folia-supported: true, and it recommends "ideally, at least 16 cores". In return it keeps vanilla mechanics, the Anvil world you already have and a plugin API that existing developers know, and it suits spread-out player bases such as skyblock and large SMP. If "Paper is single threaded" is your actual problem and you have a plugin list, read Folia versus Leaf first; it is the realistic path, and it keeps your world and most of your knowledge.

Valence (valence-rs/valence, Rust, MIT, 3,277 stars) is a framework for building a server on Bevy ECS, closer to Minestom's model than Pumpkin's. Its README calls it "still early in development with many features unimplemented or incomplete", and on 4 October 2026 its most recent commit was from 15 June 2026. FerrumC's own FAQ uses it as the example of what FerrumC is not: a framework for assembling your own server rather than a replacement for the vanilla one.

Hosting

We run Vanilla, Paper, Purpur, Spigot, Fabric, Forge and NeoForge servers. Those seven cover every production use today: plugins on the Bukkit side, mods on the loader side, exact vanilla for the people who want it. We do not offer Pumpkin, FerrumC or Minestom as server types. Minestom is a library you compile into a server of your own, so it is not something a host installs for you, and Pumpkin and FerrumC describe themselves as pre-release and alpha software. If Pumpkin reaches the 1.0 it has planned and PatchBukkit or native plugins close the gap, this page will say so, with dates.

Frequently asked questions

Is Pumpkin a real Minecraft server?

Yes. Java 26.3 and Bedrock 26.51 clients can join it, and it generates worlds, runs redstone and combat, and loads its own plugins. It is also pre-release software whose front page says to run it on a test server first and keep backups.

Can Pumpkin run Paper plugins?

Not natively. Paper and Bukkit jars can load through PatchBukkit, a separate project that embeds a Java virtual machine (Java 25 or newer) inside Pumpkin and reimplements part of the Bukkit API. Plugins that use NMS classes, CraftBukkit internals or bytecode manipulation may not work, so test every plugin before you depend on it.

Is Minestom a server?

No. Minestom is a Java library: you add it to your own Java or Kotlin project, write the gameplay and compile the server yourself. It ships with no vanilla gameplay, so the result does exactly what its developers coded and nothing else.

What is FerrumC?

FerrumC is an MIT-licensed Minecraft server written in Rust, started in 2023, that accepts Minecraft 1.21.8 clients only. Its maintainers are rewriting it from scratch, and the rewrite is currently a flat creative world in offline mode with no mobs, redstone or survival.

Is Pumpkin faster than Paper?

Unproven. Pumpkin's published figures, a 5 ms startup and about 100 MB at idle, are its own measurements against vanilla rather than Paper, taken on a server that implements 72 percent of its own vanilla checklist. A fair test needs equal mechanics on equal worlds, which is not possible yet.

Can I move my Paper world to Pumpkin?

You can try, on a copy. Paper keeps the Nether and End in separate world_nether and world_the_end folders, while vanilla keeps them inside world, so move them into the vanilla layout and upgrade the world to the current format (the client's Optimize World, or one load on a matching vanilla server) before Pumpkin reads it. Plugin data stays behind, as in any world migration off a plugin server.

Does any of this run on Bedrock?

Pumpkin accepts Bedrock clients directly and targets Bedrock 26.51, though its README marks Bedrock support as work in progress. Minestom and FerrumC are Java Edition only; on Paper, Bedrock players still need Geyser and Floodgate.

Related guides

• Vanilla, Paper, Purpur, Spigot, Fabric, Forge and NeoForge compared
• Folia and Leaf: the Paper fork performance question
• Minecraft 26.3 and the 2026 release cycle for server owners
• Choosing server plugins for a Paper stack
• Velocity and BungeeCord proxy setup
• Geyser: letting Bedrock players join a Java server
• Upgrading a Java server without losing the world
• Minecraft server setup for Java 21 and Java 25

Run Paper, Purpur or any of the seven production server types on Supercraft Minecraft hosting. Each is installed the way its own project intends, with daily backups, full file access and 4 region options.