Benchmark Methodology
This page explains how VoxelBench benchmarks work, how to get reliable and reproducible results, and what factors influence your score.
The Benchmark Process
A VoxelBench benchmark runs 14 automated tests on your Minecraft server, covering three areas:
- Single-Core Performance — How fast your CPU handles Minecraft's main thread
- Hardware — Raw memory, disk, and multi-core capabilities
- Gameplay Stress — How the server performs under real Minecraft workloads
The plugin orchestrates all tests automatically. You start the benchmark, and the plugin handles the rest: spawning entities, loading chunks, activating redstone, triggering explosions, etc. No manual intervention needed.
Test Duration
A full benchmark takes 5 to 40 minutes depending on your server's performance. Faster servers complete tests quicker — this is itself a performance indicator and is factored into the score.
Preparing for a Reliable Benchmark
Getting consistent, comparable results requires controlling the test environment. Here's a complete checklist.
Server Configuration
Minecraft Version
- Use a stable release (not snapshots or pre-releases)
- The same Minecraft version should be used when comparing results
- Newer versions may have different performance characteristics
Server Software
- Paper is recommended for the most optimized results
- Spigot, Purpur, and Folia are supported
- Vanilla servers will score lower due to lack of optimizations — this is expected and reflects real-world performance
Java Version
- Use Java 21 (LTS) or newer
- Java 17 works but Java 21 has measurable performance improvements
- Avoid Java 8 — it lacks modern GC algorithms and optimizations
JVM Arguments (Critical)
The garbage collector configuration has a major impact on results:
- Aikar's flags are the recommended baseline for most servers
- ZGC (
-XX:+UseZGC) produces very low GC pause times but may use more memory - G1GC (default with Aikar's flags) is a good balance of throughput and latency
- Avoid default JVM flags without tuning — they lead to long GC pauses that directly penalize your score
Key JVM settings to verify:
-Xmsand-Xmxshould be equal (prevents heap resizing during tests)- Allocate enough RAM for the tests (8 GB minimum recommended, 10-12 GB ideal)
- Don't over-allocate (32 GB for a test server wastes memory and can increase GC pauses)
Environment
No Players
- Run benchmarks with zero players online
- Player activity creates unpredictable load that varies between runs
- Even AFK players generate chunk ticks and entity interactions
No Other Plugins (Ideal)
- For the most accurate hardware comparison, test with only the VoxelBench plugin
- If you need to test your production configuration, understand that other plugins add overhead
- Anticheat plugins especially can interfere with entity spawning and block physics tests
Dedicated Resources
- Close other applications on the machine (or VM/container)
- On shared hosting: other customers' servers affect your results
- CPU throttling (power saving modes, thermal throttling) will produce inconsistent results
- If possible, run the benchmark during low-activity hours on the host machine
World State
- Use a fresh world or one with minimal builds
- Large existing worlds add overhead to chunk ticking and world save tests
- The plugin creates its own test areas, but existing loaded chunks still consume resources
- Officials benchmark use a flat world with seed "benchmark"
Network
- Network latency does not affect the score (all measurements are server-side)
- However, the connection between plugin and VoxelBench servers must be stable for result submission
What Makes Results Comparable
Two benchmarks are directly comparable when:
| Factor | Must Match | Why |
|---|---|---|
| Minecraft version | Yes | Performance varies significantly between versions |
| Server software | Yes | Paper vs Spigot have different optimization levels |
| Java version | Ideally | Java 21 vs 17 can show 5-15% difference |
| JVM flags / GC | Ideally | GC strategy affects pause times and MSPT stability |
| RAM allocation | Similar | Too little = OOM pressure, too much = longer GC pauses |
| Player count | Yes (0) | Players add variable load |
| Plugin set | Ideally | Each plugin adds baseline overhead |
When comparing hosting providers, VoxelBench controls for all these factors by using identical server configurations across providers.
Hosting Provider Comparison
When we benchmark hosting providers on the Hosting Comparison page:
- Same server JAR — Identical Paper version and build
- Same Java version — Same JDK distribution and version
- Same JVM flags — Identical startup arguments
- Same world — Fresh world, no builds, seed "benchmark"
- Same plugins — VoxelBench plugin only
- Same configuration — Default server.properties and Paper config
- Multiple runs — Several benchmarks per provider to account for variance
- Different times — Tests at various times of day to catch resource contention
This ensures the only variable is the hosting infrastructure itself: CPU, RAM speed, disk I/O, and how well resources are isolated from other customers.
Factors That Hurt Your Score
| Factor | Impact | How to Fix |
|---|---|---|
| Long GC pauses (>100ms) | Heavy penalty on stability | Tune JVM flags, use ZGC or G1GC with Aikar's flags |
| High MSPT (>50ms) | Directly reduces single-core score | Better CPU, fewer plugins, optimize configs |
| Inconsistent TPS across tests | Cross-validation penalty | Check for background tasks, other processes |
| Failed tests | -8% per failed test (up to -40%) | Ensure enough RAM, no interference from other plugins |
| Slow completion (>20 min) | Duration penalty | Better hardware |
| High TPS variance | Stability penalty | Consistent load, no CPU throttling |
| Slow disk I/O | Reduces hardware score | SSD vs HDD, NVMe vs SATA |
| Low memory bandwidth | Reduces hardware score | Faster RAM, proper DIMM configuration |
Factors That Don't Affect Your Score
| Factor | Why Not |
|---|---|
| Network latency / ping | All measurements are server-side |
| Number of worlds | Tests use their own areas |
| Server uptime before test | Tests are self-contained |
| Time of day (unless shared hosting) | Measurements are relative |
| Operating system (mostly) | Java abstracts most OS differences |