Busy stays local
When one area fills with players and mobs, the rest of the world keeps running smoothly — the load stays where it happened.
In active development
Divine
Performance you can feel.
A next-generation Minecraft server core — engineered so crowded worlds stay smooth, and every claim is backed by a measurement.
Why Divine
Built for servers that refuse to slow down
Divine keeps crowded worlds responsive by treating every millisecond of tick time as a budget — and every optimization as a measurement.
Work, spread out
The world's workload is divided into independent areas and processed in parallel, instead of piling onto a single queue.
No wasted motion
Repeated work is identified and removed. In measured tests, most redundant packet encoding simply stopped happening.
Stable under pressure
Spikes happen — events, farms, peak hours. Divine is designed so busy moments stay busy instead of becoming broken ones.
Performance
Measured. Not promised.
Every number on this page comes from a real benchmark run on the Divine development harness — simulated players, real server, repeatable conditions.
Tick time as a crowded area fills up
Everyone in one place
Players spread out
Simulated playersTick time (ms)
−11.7%
Region tick time — 150 players in one busy area
MeasuredDevelopment build
~90%
Repeated packet encodes eliminated in broadcast load
MeasuredDevelopment build
−23%
Sampled CPU work under moving-hotspot profiling
MeasuredDevelopment build
20
TPS held with 250 idle players in a single area
MeasuredBaseline
Benchmarks run on Ryzen 7 9800X3D · 4 GB heap · Java 25 · Minecraft 26.x · simulated players (bots) on a single machine. Early development results — some workloads still show regressions under investigation. Full reports ship with releases.
How it stays light
Fast is a design decision, made every tick
Divine doesn't chase a single magic trick. It's a discipline: profile the real server, remove real work, verify nothing broke, repeat.
See how it works- 01
Profile the real thing
Every change starts with a recording of a real server under real load — not a guess.
- 02
Remove work, not features
Optimizations target duplicated or invisible work. Gameplay semantics stay vanilla.
- 03
Prove it, or revert it
Every patch faces the same gate: correctness suite, interleaved A/B benchmark, keep-or-revert decision.
Ecosystem
A plugin platform built for speed
Divine ships with its own contained plugin runtime — designed so plugins get power without ever touching the server's fragile internals.
Divine Plugin Runtime
In developmentA sandboxed, high-throughput plugin environment with its own API surface — plugins are contained by default and measured by design.
Download
First public builds are on the way
Divine is still in active development. Builds will appear here the moment they pass the keep-or-revert gate.
Stable
Divine CoreVerified builds that hold up under the full benchmark matrix.
Experimental
Divine CoreCutting-edge builds for testers who want every optimization the day it lands.
Overview
Minecraft at scale, without compromise
Divine is a next-generation Minecraft server core. It builds on the region-based architecture of Folia and pushes it further — with an engineering loop where every optimization must prove itself on a benchmark, or be reverted.
What is Divine?
A normal Minecraft server processes the whole world in lockstep. When hundreds of players gather in one place, that place becomes a bottleneck — and everyone feels it.
Divine divides the world into independent regions that tick in parallel, then removes wasted work inside them: redundant packet encoding, pointless entity tracking, duplicated effort. The result is a server that stays calm when the world doesn't.
Who it's for
Large SMPs
Survival communities where spawn is always crowded and farms never sleep.
RPG & economy worlds
Dense hubs, custom mobs, and busy markets that punish weak tick discipline.
Networks & hubs
Lobbies and minigame nodes where presence alone is a load.
Operators who measure
Teams that want benchmark reports and correctness gates — not marketing numbers.
Principles
01
Measure first
No patch ships on intuition. Profile, hypothesize, patch, verify, benchmark — then keep or revert.
02
Vanilla-faithful
Worlds, mechanics, and client behavior stay true to vanilla Minecraft. Performance must never change the game.
03
Contained by design
Features ship behind flags, plugins run in a sandbox, and failures stay inside their region.
04
Honest numbers
We publish what's measured — including regressions we're still fixing. If it isn't benchmarked, it isn't claimed.
Where we are
Foundation
Fork baseline built, reproducible benchmark harness, 90+ quality-gated runs.
Core engine
Region tick engine, plugin runtime, and first measured optimizations landed.
Hardening
Current phase: fixing regressions, expanding coverage, more benchmark passes.
Public builds
First downloadable builds once the gates are consistently green.
At a glance
- BaseFolia architecture (region-based ticking)
- TargetMinecraft 26.x
- RuntimeJava 25
- StatusActive development — pre-release
- MethodProfile → patch → verify → benchmark → keep/revert
How it works
One crowded plaza shouldn't freeze the whole city
A Minecraft world is like a city. On a normal server, every road leads through a single intersection. Divine gives each district its own roads — then keeps the traffic lean.
-
01
The world divides itself
Divine splits the world into independent regions. Your spawn plaza, a distant farm, a faraway base — each becomes its own workload.
-
02
Each area works on its own
Regions tick in parallel on separate threads. A mob farm melting down at spawn can't stall someone building ten thousand blocks away.
-
03
Shared work is done once
When a hundred players watch the same thing, Divine prepares the data once and shares it — instead of doing the same work a hundred times.
-
04
Everything is measured
A built-in profiler watches where every millisecond goes. If a change doesn't help in benchmarks, it doesn't ship.
The engineering loop
Every optimization survives the same cycle — no exceptions.
Profile→
Hypothesize→
Patch→
Verify→
Benchmark→
Keep or revert
Divine is in active development. Diagrams simplify; numbers on this site are always measured.
Official Plugins
An ecosystem built for speed
Official plugins run on the Divine Plugin Runtime — a contained environment where plugins get a stable, high-throughput API without touching server internals.
Divine Plugin Runtime
In developmentSandboxed by default. Contained failures. An API surface designed so fast plugins are easy to write and slow ones are hard to hide.
The official ecosystem is growing
First-party plugins are being built alongside the runtime. They'll appear here with compatibility notes and measured overhead — not just feature lists.
Benchmarks
Measured, never promised
Every number below comes from a real benchmark run on the Divine development harness — simulated players, real server, repeatable conditions.
Test environment
- CPURyzen 7 9800X3D
- Memory4 GB heap
- RuntimeJava 25
- Minecraft26.x
- Method90 quality-gated runs · simulated players (bots)
Worst-region tick time under load
Lower is better. MSPT = milliseconds per tick; a tick must stay under 50 ms for the game to hold 20 TPS.
| Scenario | Simulated players | MSPT avg | p95 | p99 |
|---|---|---|---|---|
| Everyone in one place | 25 | 3.69 | 4.94 | 6.22 |
| 50 | 6.10 | 7.85 | 8.80 | |
| 100 | 9.89 | 11.46 | 12.67 | |
| 150 | 15.88 | 19.91 | 30.33 | |
| Players spread out | 10 | 2.62 | 3.24 | 4.14 |
| 20 | 2.89 | 3.73 | 4.76 |
Measured Development build Early development results — some workloads still show regressions under investigation.
Benchmarks run on Ryzen 7 9800X3D · 4 GB heap · Java 25 · Minecraft 26.x · simulated players (bots) on a single machine. Early development results — some workloads still show regressions under investigation. Full reports ship with releases.
Tools
Utilities for Minecraft server operators
Free browser-based tools for understanding server performance. They are being built alongside Divine and will appear here as they ship.
Server RAM Calculator
PlannedEstimate how much heap your server actually needs from player count, view distance and plugins — instead of guessing.
MSPT Explained
PlannedInteractive walkthrough of what a server tick is, where the 50 ms budget goes, and why MSPT matters more than average TPS.
TPS & MSPT Analyzer
PlannedPaste timings or spark output and get a plain-language read on where your tick time is going.
Capacity Calculator
PlannedEstimate a sensible player ceiling for your hardware before opening the doors — based on measured workloads.
View Distance Calculator
PlannedSee how view-distance and simulation-distance settings translate into chunk load and tick cost.
Guides
Understand what makes a server fast
Short, honest explainers on Minecraft server performance — written for operators, not kernel engineers. Articles are in preparation.
What is TPS?
PlannedThe 20-ticks-per-second heartbeat of a Minecraft server — and what it means when it dips.
What is MSPT?
PlannedMilliseconds per tick is the number that actually decides whether your server feels smooth.
Why servers lag
PlannedEntities, chunks, hoppers and farms — a tour of the usual suspects behind tick spikes.
Paper vs Folia
PlannedWhat region-based ticking changes, what it doesn't, and who should care.
Server optimization basics
PlannedThe settings and habits that matter before you ever touch a custom server core.