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.3.1 (Fabric, Forge and NeoForge 26.3):

• Faster graphics card: on Windows PCs with a built-in and a separate graphics card, Windows often starts Java on the built-in one. The title screen now says so once, and the settings have a button that sets Windows' graphics preference for the game's Java to the faster card (from the next start; nothing changes unless you press it).
• Opal (Fabric): with Opal installed, Afterburner leaves drawing to it: its rendering options, its graphics-side memory and texture options, the shader pack loader and far terrain switch off; world, server, network and memory options keep working.

New in 0.3.0 (Fabric, Forge and NeoForge 26.3; Forge and NeoForge 26.3 also get the 0.2.10 list below), each checked against vanilla with identical results before it was switched on. On the standard route at render distance 12 the Fabric build averages 175-252 FPS on our test laptop, 10-18% more than 0.2.10, using about 0.5 GB less memory:

• Chunk building: a chunk's blocks and the ring around it are read out once into an array, about 12% less meshing time.
• Mobs and items: model boxes are written into the vertex buffer in one go, about twice as fast to draw.
• Mob ticks: mobs in crowds and near walls skip repeated ladder, wall and push checks; mobs near water remember their fluid check; walking mobs skip the block-effects step while nothing around them changes.
• Collisions: full blocks, slabs, farmland and paths are clipped straight from their numbers instead of making a shape object per block, same results to the last digit (about 7% less tick time in a crowded village).
• Redstone: the dust memory only forgets an answer when a block within 2 blocks changes; redstone worlds tick about 15% faster.
• Far terrain (experimental) is built faster.
• Fixes: no more crash with Opal; worlds on PCs under 6 GB load as fast as vanilla again; items dropped in lava burn again; tall mobs notice lava and cobwebs at head height; a world used with /locate is no longer kept in memory after you leave it; far less garbage while generating bedrock and deepslate.

Options still being tried (less world generation garbage, skipping repeated light, and others) are off by default and can be switched on in the settings.

From 0.2.10:

• 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):

	Launcher default (G1)	ZGC
Longest pause	8-15 ms	under 0.5 ms
Worst frame	11.5-24.8 ms	12.0-22.0 ms
Average FPS	no difference	no difference
Peak memory	about 2.1 GB	about 3.1 GB

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.

Minecraft	Fabric	Forge	NeoForge
26.3	yes	yes	yes
26.2, 26.1.2		yes (beta)
1.21.11	yes (beta, partial)	yes
1.21.10, 1.21.8, 1.21.5, 1.21.4, 1.21.3		yes (beta)
1.21.1	yes	yes	yes

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):

Scene	Off	On
World alone, 2,304 loaded chunks	14.3	10.9
400 cows	18.0	12.2
1,800 idle hoppers	11.3	8.9
1,800 stuck hoppers	18.5	8.8

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:

	Off	On
Average FPS	108.6	213.4
1% low FPS	59.3	96.3

Compatible with

Afterburner is built to leave a part to the mod that does the same job: Sodium, Embeddium and Opal (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.