Argomenti trattati
The Nintendo 64 has long been associated with a thick, distance-hiding fog that masked rendering issues. That reputation was as much a symptom as a solution: developers used fog to hide problems the console’s hardware made difficult to solve. Now, a small project called Junkrunner 64 has shown a different path. Built by James Lambert with map contributions from Pyroxene, the demo runs on actual N64 cartridges as well as on high-fidelity emulators like Ares, and it demonstrates a horizon visibility more commonly associated with modern titles such as Skyrim.
Rather than accept obscured vistas, Lambert approached the problem by reimagining how the scene is drawn. The result is a playable, large-scale environment where players can stand at one edge of the map and see to the opposite side without relying on a fog wall. While the project began as a game jam experiment and follows in the maker’s lineage of retro tech work including Portal 64 and a VR-enabled Super Mario 64 romhack, its significance lies in the rendering techniques that can be reused in larger N64 projects.
Why classic N64 games used fog
At the heart of the old limitation is a hardware issue known as Z-fighting. The console’s Z-buffer, which tracks pixel depth to decide what should appear in front of what, lacks fine granularity at long ranges. When distance values become too close to each other, the buffer can no longer reliably order geometry, causing visual artifacts where far objects draw on top of nearer ones. Historically, teams masked these errors with fog because it blended distant geometry into an indistinct backdrop before artifacts became visible. That choice hid the symptoms but did not solve the underlying precision problem.
How Junkrunner 64 solves the problem
Lambert’s approach is elegantly straightforward and borrows ideas familiar to modern graphics engines. He performs two distinct rendering passes: a far pass and a near pass. In the far pass, distant parts of the world are rendered at low resolution and scaled down — a technique that effectively reduces the precision demands on the console’s Z-buffer. The near pass then draws higher-detail geometry where precision is still manageable. This layered rendering produces a coherent scene from back to front without fog covering the transitions.
Tiles, LOD and visibility checks
The world is split into tiles that each have multiple LOD variants. Before any tile gets drawn, the engine performs a visibility test; if a tile is outside the player’s view frustum it is skipped entirely. If a tile is visible but distant, the engine draws its low-detail version; as the player approaches, higher-detail versions replace the low-detail tiles. This combination of level of detail management and conservative visibility culling keeps processing needs within the console’s capabilities while preserving long-range scene integrity.
Designing a map worth exploring
A big map alone does not make a satisfying experience, so the team paired the technical feat with gameplay choices that support exploration. To address traversal boredom, Junkrunner 64 equips the player with a fast hover vehicle: the hover cycle can hit roughly 180 mph with upgrades and boost, making long distances feel traversable rather than tedious. More importantly, the map begins concealed and is revealed gradually as players travel, turning discovery into a deliberate experience rather than an instantly readable checklist.
Performance, collaboration and availability
Map construction and LOD authoring were handled by Pyroxene, who built multiple detail levels for each chunk of the environment. Tests on hardware and emulators reported a generally solid frame rate, an impressive outcome for an engine producing a world comparable in scope to later-generation titles. Junkrunner 64 is distributed as a ROM on GitHub for those who want to try it on real hardware or in accurate emulators, and Lambert has indicated the rendering techniques will feed into his larger, Magicka-style N64 project. Supporters can also follow his progress on Patreon.
What this means for retro development
Beyond the immediate novelty, Junkrunner 64 represents a proof of concept: classic consoles can sometimes do more than their early libraries implied if developers rethink how content is rendered and organized. By blending dual-pass rendering, conservative visibility checks, and pragmatic LOD use, Lambert turned a decades-old limitation into a solvable engineering problem. Retro enthusiasts who once accepted the fog as a fact of life now have a clear example of how those visual constraints can be overcome.
For anyone curious to experiment, the demo is available to download, and the breakdown video walks through the rendering pipeline in detail. Whether this technique spreads into full-scale commercial releases on vintage hardware remains to be seen, but the technical lessons are already influencing new N64 work and reminding developers that sometimes solving an old problem simply requires rethinking the drawing order.