Why No Diablo II Remake Ever Feels Right (Even with the Source Code)

Every few years, a familiar argument resurfaces in the ARPG community. Someone claims Diablo II could be remade perfectly today. Others respond that it already was. And then the conversation collapses into the same conclusion:

Something still feels off.

This reaction persists even after Diablo II: Resurrected, a remaster built directly on Blizzard’s original codebase. The reason is not nostalgia blindness, bad graphics, or player resistance to change. The reason is deeper and more technical.

Diablo II’s identity is inseparable from how it was built, not just what it contains.

The Myth of the “Perfect Remake”

When players say they want a perfect remake, what they usually mean is identical mechanics with modern visuals and quality-of-life improvements. On paper, this sounds reasonable.

In practice, it is nearly impossible.

Games are not just rule systems. They are simulations running under very specific timing, precision, and architectural constraints. Change those constraints, and the game may still function, but it will not behave the same way.

Diablo II is an extreme example of this problem.

Diablo II Was Built Around Fixed Assumptions

The original Diablo II engine was designed in the late 1990s. It assumes:

• Fixed frame-based logic
• Deterministic but imperfect RNG
• Low-resolution input timing
• Single-threaded execution
• Network latency as a constant factor

Many gameplay systems rely on these assumptions indirectly. Attack speed breakpoints, hit recovery, animation cancel windows, and even monster pathing are tied to how often the game updates its internal state.

These behaviors were not always intentional design choices. Some were technical limitations. Others were side effects. Over time, players learned them, mastered them, and incorporated them into how Diablo II is played.

Those quirks became the game.

Why Source Code Alone Is Not Enough

Having the original source code is necessary, but it is not sufficient.

You can compile the same logic inside a different runtime environment and still get different results. Floating-point precision, thread scheduling, timing resolution, and even compiler optimizations can subtly alter behavior.

This is why Blizzard made a very specific decision with Diablo II: Resurrected. Instead of rewriting the engine, they preserved it. The original gameplay logic still runs exactly as it did before, while a modern rendering layer sits on top.

That approach minimized behavioral drift. Even then, some players noticed differences.

Why Spiritual Successors Struggle Even More

Games inspired by Diablo II often copy surface-level systems: skill trees, loot rarity, procedural maps. What they cannot copy is the emergent behavior created by Diablo II’s engine constraints.

Modern engines are smoother, more precise, more stable, and more correct. Ironically, those improvements remove the friction that defined Diablo II’s feel.

Path of Exile, Last Epoch, and other ARPGs are excellent games, but they feel different because they are built on different assumptions. Their responsiveness, animation blending, and simulation accuracy eliminate many of the rough edges Diablo II players internalized.

The Problem of “Fixing” Bugs Players Love

Many things players consider features in Diablo II began life as bugs.

Desync behavior, odd hit registration, animation locks, and inconsistent enemy responses all contributed to the game’s texture. Removing or correcting these issues makes the game more logical, but also less familiar.

This is one reason rewrites fail. Engineers see problems to fix. Players see identity being erased.

Why This Will Always Be a Problem

No matter how advanced technology becomes, recreating Diablo II perfectly would require more than matching formulas. It would require recreating the entire execution environment, timing model, and historical context in which the game originally ran.

At that point, preservation becomes more practical than modernization.

This is why Blizzard chose to preserve Diablo II instead of rebuilding it. It is also why every attempt to “improve” the game risks making it feel less like itself.

Final Thoughts

Diablo II does not feel the way it does because of any single system. It feels that way because of how everything interacts under constraints that no longer exist.

You can modernize the visuals. You can add quality-of-life features. You can even keep the source code.

What you cannot do easily is change the foundation without changing the result.

That is why no Diablo II remake ever feels quite right, and why preserving the original experience remains the safest choice Blizzard ever made.