Afterburner

Afterburner makes Minecraft run faster without changing how the game looks or plays. It works on a client, on a server, or both. The mod is customizable, and you can check out video settings for configuration. (or config/afterburner.properties)

What it improves

Rendering

• Batched chunk drawing: each 128x64x128 block region is drawn with one call instead of one call per chunk section.
• Smaller chunk vertices: 16 bytes per vertex instead of 28, so the graphics card reads less for every block face. Chunks also take less graphics memory.
• Occlusion culling: chunks hidden behind nearer terrain (hills, caves, walls) aren't drawn. Works on OpenGL and Vulkan.
• Entity culling: mobs, chests, signs and other entities hidden behind terrain aren't drawn.
• Face culling: block faces that point away from the camera are skipped.
• Translucent face culling: the same for water, glass and ice.
• Leaf culling: faces deep inside a tree's leaves, which the leaves in front hide, are skipped.
• Faster draw prep: skips the per-frame work for chunk layers that have nothing to draw.
• Off-screen chunk building: chunks around you get built while the builders have time, not only once you look at them, so turning around shows fewer holes.
• Cheaper texture filtering: smooth filtering reads each texture 4 times per pixel instead of 8 or 9. The picture stays the same.

Memory

• Smaller chunk buffers: GPU memory for chunks grows as needed instead of being reserved 128 MB at a time. On laptops with built-in graphics, that memory is your normal RAM.
• Freed build copies: chunks let go of the copy of the blocks they were built from. Vanilla keeps one per chunk.
• Memory trim: while the game is paused or in the background, Java gives unused memory back to the system.
• Leaner chunk sections, shared block shapes, leaner block states: less memory for every block and biome container.

World and server

• Parallel world generation: trees, ores and structures are placed on every CPU core instead of one. If a generation step ever fails, Afterburner goes back to one thread for the rest of that run.
• Faster lighting: light updates remember the sections they're working in instead of looking them up for every block. It uses the same algorithm as vanilla, so the result is the same.
• Faster collisions, entity searches, mob AI, explosions, redstone dust and spawning: less work per block, per search and per mob.
• Sleeping idle furnaces and campfires, and scheduled ticks parked where nothing is happening.

New in 0.2.10 (Fabric 26.3), each checked against vanilla with identical results before it was switched on:

• World generation: the step that fills in new land uses about 30% less CPU (runs of the same block down a column are written at once), and fewer surface rule checks are made per column.
• Redstone: redstone dust remembers its power until a block next to it changes, about 22% less tick time on a redstone-heavy test world; comparators read their container once.
• TNT: explosions look each block's shape up once per explosion instead of at every step of every ray, about a third off the slowest TNT ticks; drops are stacked by kind.
• Light: the light queue copies less and reports changed light in one message per round, 6-11% less light work.
• Multiplayer: light, block entity and block update packets sent to several players are packed once; the registries and tags sent to a joining player are built once and reused, 15-30 ms less server time per join.
• Saves and ticks: scheduled block ticks are kept in compact arrays, region files reuse one compressor per thread, and ticket and clock files aren't rewritten when nothing changed.

Forge and NeoForge only (server side)

• Hoppers: a hopper that has nothing to do goes to sleep until something changes (and wakes now and then to double-check), and hoppers remember the container next to them. In our Forge 26.3 test, a server with 1,800 stuck hoppers took 18.5 ms a tick without Afterburner and 8.8 ms with it.
• Faster water and lava flow, pathfinding, entity tracking, item merging, and finding structures off the main thread.
• Cheaper network work: chunk packets are shared between the players who get them, packed once, and packed at a lighter zlib level.

Other

• Lower worker priority: background workers run just below normal priority, so frames come first when every core is busy.
• Accurate ping and Clicks at Once (26.3): a player's ping is measured when the reply arrives, not when the busy main thread gets to it; an attack or placed block is sent the moment it is pressed.

Slow connections (Minecraft 26.3)

For a player with very little bandwidth, on a Forge 26.3 server:

• /afterburner slow <player> (op) gives a listed player a smaller view distance and the strongest packing. A player whose connection stays backed up gets it on their own.
• /afterburner net (op) shows what the server sends each player, by kind of packet.
• Smaller chunks from Afterburner servers (Fabric 26.3 client, in the settings, off by default): chunks arrive packed with LZMA2, without their light (the game works it out), and as a 16-byte reference when you kept the chunk on your disk from last time. In our tests: about a third fewer bytes for chunks seen the first time, two thirds to four fifths fewer when you've seen them before. Other servers are not affected, and ViaProxy passes it through.

Settings by dimension (Forge 26.3 server, off by default)

config/afterburner-dimensions.properties sets things separately for the Overworld, the Nether, the End and any other dimension:

• Dropped items (dimensionItems switch): how long an item lasts, how close items must be to merge, and how many item entities one chunk may hold (past it the oldest go). The file starts the Nether and the End at half the item lifetime and a wider merge range, and leaves the Overworld as in vanilla. Item farms that leave items lying around may want longer lifetimes or no limit.
• Slower AI for far mobs (farMobAi switch): how far from a player mobs start thinking less often, per dimension.

Experimental (off by default)

A shader pack loader, FSR-style upscaling and far terrain (land past the render distance, drawn from chunks the game has seen) come with the mod (Minecraft 26.3, and 1.21.1 on Forge, NeoForge and Fabric). They do nothing until you choose them, far terrain starts off, and they turn themselves off with Sodium or Embeddium, Iris or Oculus, Voxy or Distant Horizons. Expect rough edges and tell us what you see.

Shader packs on Fabric 26.3 (0.2.10): in a test set of 13 popular packs (Complementary, BSL, Bliss, Photon, Noble, Solas, Sildur's, Shrimple, MakeUp, Super Duper Vanilla, Rethinking Voxels), every shader the game loads now compiles; packs that need OpenGL 4.3 say so on older graphics instead of breaking. Packs get per-entity, block entity and item ids, chunk fade, separate ambient occlusion, block light emission and old lighting as they ask for them.

Fewer stutters: an optional Java setting

Java's memory cleanups briefly freeze the game. A mod can't change how they run, because Java picks its collector before the game starts, but you can. In your launcher's JVM arguments, replace -XX:+UseG1GC with -XX:+UseZGC. If both are there, the game won't start.

Measured on Minecraft 26.3 with Java 25, on one laptop with 2 GB for the game, 6 runs each (memory: 3 runs each):

The pauses almost disappear, but the worst frames showed no clear winner, because other work causes those too. Skip it if your PC is short on memory. It hasn't been tested on the 1.21.x builds, which use Java 21.

Versions

The list of optimizations differs between versions: Minecraft 26.3 has the most.

Fabric needs Fabric API. The Minecraft 26.x builds need Java 25; the 1.21.x builds Java 21. Fabric 1.21.11 is a first build: it has the server side and some of the client side, and no chunk batching or occlusion culling yet.

Benchmarks

Afterburner 0.2.2 off and on, in turns, measured on one laptop (i7-1255U, integrated Intel UHD graphics). A dedicated graphics card hasn't been tested, so these frame rates may not carry over.

Forge 26.3 server, 4 runs each way, median ms per tick (lower is better):

Each scene ran on its own after a warm-up, on the CPU's 8 efficiency cores, so a run doesn't depend on which core it lands on.

Fabric 26.3 client, render distance 16, flying over terrain, 3 runs each way, median:

Compatible with

Afterburner is built to leave a part to the mod that does the same job: Sodium and Embeddium (rendering), Lithium and Radium (game logic), FerriteCore and ModernFix (memory), Starlight, C2ME (chunk system), Iris and Oculus (shaders). The overlapping part is simply off while the other mod is there, read below for what was tested:

(Afterburner version 0.2.2)

• Minecraft 26.3 (Fabric): All 8 mods work.
• Minecraft 1.21.11 (Fabric): All 8 mods work.
• Minecraft 1.21.1 (Fabric): C2ME, FerriteCore, Iris, Lithium, and Sodium work.
• Minecraft 1.21.1 (Forge): Entity Culling and ImmediatelyFast work, but a crash occurred. However, the same crash happened without Afterburner, so it wasn't caused by it.
• Minecraft 1.21.1 (NeoForge): All 8 mods work.

Mind you, these were short tests, not extended gameplay sessions. If you experience problems with any mod combination, report them.

Note:

Credits and licenses: MIT. Sodium, Lithium, FerriteCore and Iris are credited for the designs this follows (no code of theirs is used); AMD's FidelityFX Super Resolution 1 (MIT) for the upscaling. The full notices are in THIRD_PARTY_NOTICES.md inside every jar.