There are two separate performance problems in Minecraft: client FPS and server TPS. Most players confuse them, install the wrong mods for the wrong problem, and wonder why their farm still lags even though the framerate is smooth.

This guide covers the full Fabric performance stack for Minecraft 1.21.4, sorted by what each mod actually fixes, in the order you should install them.

The mental model first

Before the mod list: understand what you're optimizing.

  • Client FPS — frames per second on your screen. Bad FPS means your GPU or CPU can't render the scene fast enough. The fix is render-pipeline mods.
  • Server TPS — ticks per second. Bad TPS means the game simulation is behind. The fix is logic-optimization mods. A fast client with a slow server produces rubber-banding, delayed block updates, and farms that produce at a fraction of their rated rate.
  • Memory usage — how much RAM the JVM holds. Matters on machines under 8 GB, affects garbage collector pauses, which cause stutters rather than sustained low framerate.

Each mod in this list targets one of these three problems. Mixing them is fine and expected — they don't overlap on vanilla systems.

The core four

These four mods are the baseline. Every Fabric performance pack ships them. Install all four.

Sodium 0.6.7 — render pipeline

Replaces Minecraft's chunk meshing and rendering system. CaffeineMC's benchmark reports ~90% less CPU overhead on chunk rendering versus vanilla, roughly 2–3× the FPS improvement OptiFine delivers on the same hardware.

On 1.21.4, Sodium 0.6.x integrated the Fabric Rendering API (FRAPI) natively. Do not install Indium with 0.6+ — it's built in and the extra dependency causes a crash.

Modrinth: modrinth.com/mod/sodium

Lithium 0.13.x — game logic

Lithium optimizes the server-side simulation: AI pathfinding, chunk ticking, entity processing, block entity loops, and more. The same jar runs on both client and dedicated server. It's zero-config and never changes vanilla behaviour — every optimisation is a non-observable speedup, not a gameplay change.

If you host a server, Lithium is probably the single highest-value mod you can install. TPS improvement depends heavily on what's loaded, but iron farms and mob farms run noticeably faster at the same simulation distance.

Modrinth: modrinth.com/mod/lithium

Krypton 0.2.x — network stack

Krypton rewrites Minecraft's networking layer: faster packet compression, reduced memory allocation per packet, pipeline reordering. Transparent to gameplay. Most noticeable on servers with 10+ players, where vanilla's network handling was a measurable bottleneck.

On a solo LAN world you won't feel it. On a populated SMP it's worth having.

Modrinth: modrinth.com/mod/krypton

FerriteCore 7.x — memory

Minecraft's block state system creates enormous numbers of small Java objects. FerriteCore deduplicates them at the JVM level, which can cut memory usage by 200–500 MB in a loaded world — sometimes more in modded packs with hundreds of additional block states. Less memory means less GC pressure, which means fewer 300ms freeze stutters.

Required by several popular modpacks, and one of the few performance mods that genuinely helps on memory-constrained machines.

Modrinth: modrinth.com/mod/ferrite-core

Client-only additions

Install these on your client. Don't put them on a dedicated server — they're render-side only.

EntityCulling 1.21.4 — entity rendering

Vanilla renders every entity in the loaded view, even ones behind walls or solid terrain you can't see. EntityCulling fires asynchronous visibility raycasts and skips rendering occluded entities. In a village or mob farm with dozens of entities in view, the FPS gain can be significant.

The async architecture means it adds almost no overhead when everything is visible — it only pays off when there's something to cull.

Modrinth: modrinth.com/mod/entityculling

Iris 1.8.x — shaders (optional)

If you want shaders, Iris is the Fabric-native solution. It hooks into Sodium's render pipeline rather than replacing it, which is why it delivers better shader performance than OptiFine's GL implementation. BSL, Complementary, and most major shader packs support Iris.

Iris is bundled in Fabulously Optimized. Install it separately if you're building your own stack.

Modrinth: modrinth.com/mod/iris

Sodium Extra 0.6.x — settings UI

Adds a full video settings screen to Sodium covering animations, particles, fog, entity distance, and more. Sodium itself intentionally ships minimal settings; this fills the gap. Not a performance mod per se, but helps you tune the tradeoffs.

Modrinth: modrinth.com/mod/sodium-extra

Server-side additions

These run on a dedicated server. Many also work on a client, but their impact is server-logic-only.

Chunky 1.4.x — pre-generation

Chunky generates chunks ahead of exploration, eliminating the worst case for TPS: a player exploring ungenerated terrain, triggering cascading chunk generation that tanks the tick rate for everyone else.

Run Chunky once on a new world, pre-generate a radius of 5 000–10 000 blocks around spawn, then let it finish before opening the server to players. Single biggest TPS improvement for new worlds with multiple players.

Modrinth: modrinth.com/plugin/chunky

Spark 1.10.x — profiler

Spark is a profiler, not an optimization mod. It reports where TPS time is actually going: which mob AI, which block entity, which scheduled task. You cannot fix what you haven't measured, and /spark tps + /spark profiler are the two commands you run before tuning anything else.

Install Spark before you make any simulation-distance or entity-limit changes. It tells you whether the change helped.

Modrinth: modrinth.com/mod/spark

Moonrise 0.4.x — chunk system

Moonrise (from the C2ME author) rewrites chunk generation, loading, and saving with better concurrency. On a server with many players exploring simultaneously it reduces the chunk-gen TPS spike. On 1.21.4 it's still in active development — test before deploying on production.

Modrinth: modrinth.com/mod/moonrise

The Fabulously Optimized shortcut

If you want the stack pre-assembled and maintained, Fabulously Optimized ships Sodium + Lithium + Krypton + FerriteCore + EntityCulling + Iris + a dozen supporting mods. It tracks upstream very quickly and has become the de facto baseline for "I just want good Fabric performance."

The only reason to build manually: you have specific mod conflicts, you want to exclude shaders, or you're running a server-only stack where you need Lithium + Krypton + Spark without client-side mods.

Compatibility matrix for 1.21.4

Mod Type Conflicts Safe with Sodium 0.6?
Sodium 0.6.7 Client render OptiFine (incompatible) —
Lithium 0.13.x Client + server logic None known Yes
Krypton 0.2.x Client + server net None known Yes
FerriteCore 7.x Client + server memory None known Yes
EntityCulling 1.21.4 Client entity None known Yes
Iris 1.8.x Client shader OptiFine Yes (designed for it)
Sodium Extra 0.6.x Client settings UI None known Yes (requires Sodium)
Indium Client FRAPI compat — No. Do not install with Sodium 0.6+
Moonrise 0.4.x Server chunk C2ME (same system) Yes
Spark Client + server profiler None known Yes

The one hard rule: no OptiFine on Fabric 1.21.4. It doesn't work, it conflicts with Sodium, and everything it does is covered better by the mods above.

What to skip in 2026

Some mods that dominated older lists are either merged, abandoned, or made redundant:

  • Indium — built into Sodium 0.6. Do not add it.
  • Starlight — the author merged it into Paper and stepped back from Fabric maintenance; Moonrise and Lithium cover the same ground better.
  • LazyDFU — fixed in vanilla since 1.19.4. Do not add it.
  • DashLoader — unmaintained since 2023.
  • Phosphor — the original light engine rewrite, superseded by Starlight then Moonrise/Lithium.

Minimum viable stack for a solo client

If you want the shortest answer:

Solo player, just want more FPS: Sodium 0.6.7 + Lithium 0.13.x + FerriteCore 7.x + EntityCulling 1.21.4

Add for shaders: Iris 1.8.x

Add for settings control: Sodium Extra 0.6.x

Minimum viable stack for a dedicated server

Server TPS: Lithium 0.13.x + Krypton 0.2.x + FerriteCore 7.x

Add for profiling: Spark 1.10.x (always)

Add before launch: Chunky 1.4.x (pre-gen your world)

Optional: Moonrise 0.4.x (test on staging first)

Measuring the result

After installing, use Spark to baseline before and after each change:

/spark tps                # current TPS and system load
/spark profiler start     # start recording
# wait 2 minutes with your farm running
/spark profiler stop      # get a report URL

The profiler output shows you a breakdown by method — if Lithium is helping, you'll see vanilla AI and tick methods replaced by the Lithium equivalents in the hotspot list. If Chunky hasn't been run and chunk gen is your bottleneck, it'll show clearly.

Don't tune without measuring. The stack described here is the right starting point, but real gains come from diagnosing what your specific world is actually spending time on.

Sources & further reading: