Axyon

A performance mod for modern Minecraft

Axyon makes the game faster by removing wasted work. It does not change how the game looks or plays. One rule covers everything:

If vanilla would render it, Axyon renders it. If vanilla would simulate it, Axyon simulates it.

No missing mobs. No broken farms. No lowered graphics. Just a faster game.

Most performance mods focus on one thing. Axyon does several: it puts you on the new Vulkan renderer automatically and runs its own terrain engine natively on it, caches mob and chest models instead of rebuilding them every frame, skips rendering things hidden behind walls, cuts most of the game's memory garbage, smooths out chunk-loading stutter, and gives you tools to see exactly what your FPS is doing. Every feature is tested against vanilla on every build to make sure the picture on screen is identical.

The big one: Axyon runs on Vulkan — natively

Minecraft 26.2 has a new Vulkan renderer. In our tests it runs at about twice the FPS of OpenGL, but the game's "Default" setting still picks OpenGL, so most players never get it. Axyon fixes that at launch: if your renderer is set to "Default," Axyon switches it to Vulkan. If you pick a renderer yourself in Video Settings, Axyon never touches it. Prefer OpenGL? Set preferOpenGL=true in the config.

As of 0.7.6, Axyon's terrain engine doesn't just tolerate Vulkan — it's built for it. Terrain draws are submitted in Vulkan's native indirect form: the draw commands live on the GPU, and when nothing changed since last frame, the whole batch is re-issued with a single call instead of being rebuilt. Compact 16-byte terrain vertices (vanilla uses 28) cut GPU memory on top.

Benchmarks — Axyon vs vanilla, both on Vulkan

Six test scenes, same computer, same settings (render distance 16, uncapped FPS), both sides on the Vulkan renderer. Every number is the median of repeated, deterministic runs on an idle machine — random world ticks are frozen in test scenes so a run can be repeated exactly, and every run saves the game's own log line proving which renderer was used. If a scene fails to render, the benchmark refuses to give a number at all.

Average FPS — Axyon 0.7.6, all six scenes won:

Composite score across all measurements (FPS, lows, frame-time variance, memory, GC): Axyon 96.3 — vanilla 90.7. Axyon also has the better worst-frame times in five of the six scenes — the frames you actually feel.

What about Sodium? Sodium 0.9.1's Vulkan support is new and experimental — in our test it drew nothing, so a fair same-renderer comparison isn't possible yet (we retest every Sodium release). Against Sodium's best OpenGL results, Axyon-on-Vulkan is ahead in every scene by wide margins — but that's partly the renderer, which is exactly why Axyon switches you to it.

Real-world check (same base, same spot): moving to Vulkan took the benchmark average from 552 to 1,048 FPS — about double. The 0.7.6 engine added another +7% in chunk-loading flight on top.

What each part does

Vulkan terrain engine — batches terrain draws GPU-side in Vulkan's native indirect form and keeps them there between frames. Only real events (a chunk changing, settings changing) rebuild a batch — never just time passing. Its per-frame bookkeeping table resets by bumping one counter instead of being wiped, so small scenes like caves don't pay big-scene costs. This engine is why every scene above is green.

Mob rendering engine — vanilla rebuilds every mob's model from scratch, vertex by vertex, every single frame. In a crowd, that's about 65% of all CPU time. Axyon saves each still-standing mob's model once and writes it back in one go each frame. Mobs that are moving or animating use the normal path, so nothing ever looks wrong. Tested byte-for-byte against vanilla on every build, including hurt flashes and multi-layer models. Result: +69% over vanilla in a 600-mob field on Vulkan.

Chest and sign caching — the same trick for chests, signs, and banners, plus one extra: a cube has 24 vertices but only 8 corners, so Axyon does the math once per corner instead of once per vertex. Big storage rooms run 2–4× vanilla FPS.

Chunk-update pacing (experimental, off by default — uploadPacing) — when a batch of chunks arrives, up to 200 mesh rebuilds can land in a single frame; that one long frame is the stutter you feel even at high FPS. Pacing caps how many are accepted per frame and lets the rest wait a frame or two. Measured 25% faster worst-frames during chunk-loading flight. Your own block edits are always exempt — breaking a block never waits.

Hidden-object culling — mobs and chests fully sealed behind solid blocks stop being drawn. They keep ticking — farms and hoppers work exactly like vanilla. The checks run with a strict time budget, and anything uncertain gets drawn. It only ever errs toward drawing more, never less.

Memory cleanup — profiling found single lines of vanilla code producing most of the memory garbage: a new rotation object for every item, every frame; pointless empty-list copies for every mob, every tick; five throwaway objects per model quad. Axyon reuses one object instead in each case. Less garbage means fewer GC pauses, which means fewer micro-stutters. Measured: garbage cut by more than half, GC pause time roughly halved.

Lag Detective — when your FPS dips, Axyon tells you why: GC pause, chunk rebuilds, particle storm, mob crowd, server lag, or memory pressure. If nothing in the game changed, it says so honestly instead of inventing a cause. Silent when the game is smooth.

Benchmark mode — a 30-second test with a fixed camera spin, so every run is fair to compare. Gives you average FPS, 1% and 0.1% lows, variance, and a smoothness grade. Remembers your last run at the same spot and compares automatically.

Commands

There's also a clean F3 overlay: FPS with a true 10-minute average, a frame time line (current + average, in milliseconds), your 1% and 0.1% lows, TPS with its tick time clearly labeled, steady GPU and CPU readouts (rolling averages, not flickering snapshots), memory, coordinates, facing, mob count — and the Lag Detective's verdict when something happens.

Config

Everything is in config/axyon.properties — created on first run, fully commented, applied live with /axyon reload. Every feature has its own on/off switch. You can tune the culling distances and time budget, pick your renderer with preferOpenGL, and blacklist any mob or block type that should never be culled. Settings from older versions carry over automatically.

The picture never changes

• Rendering never touches game logic. Hidden hoppers move items and hidden mobs grow up on exact vanilla timing — checked by automated tests on every build.
• What's on screen matches vanilla pixel for pixel. The test suite compares Axyon's cached geometry byte-for-byte against vanilla's output on every build. The one option that changes visuals (leaf culling) ships off, and is never on in any benchmark we publish.
• If another mod does something unexpected, the affected Axyon feature quietly turns itself off and vanilla takes over. No crashes.
• Client-side only. Works on any server.

Works with other mods

Axyon detects Sodium and hands the entire terrain system over to it automatically — no conflicts. It detects Iris and works with shader shadow passes through the optional Onyx Shaders companion mod. Any single feature can be turned off if some mod doesn't get along with it.

About the numbers

Our benchmark checks itself: scenes are verified to actually render (a blank scene refuses to produce a number), test worlds are deterministic so runs can be repeated exactly, results are medians of repeated runs on an idle machine, every run saves its full settings, and the renderer used is proven from the game's own log — never assumed. When a result surprised us, we retested it before believing it — including results that made us look better, and results that made us look worse. The full test setup and raw results ship in the project repository.

This is alpha software. If anything looks odd, report it — every feature can be switched off separately while you keep playing.

Transparency note: this mod is coded entirely by AI (Anthropic's Claude) as an experiment — I don't take credit for the code, only for the direction, testing, and quality control behind every release.