Jason Rohrer is a name you probably know if you've spent any time in the indie dev scene. He’s the guy behind Passage and The Castle Doctrine. But his most ambitious project—by far—is One Hour One Life. Most people focus on the soul-crushing gameplay where you’re born as a baby to a random player, live 60 minutes, and die of old age. That's the hook. But the actual One Hour One Life engine, written from scratch in C++, is the real reason the game even works.
It's weird.
Honestly, it’s one of the most idiosyncratic pieces of software I’ve ever poked around in. Rohrer didn't use Unity. He didn't use Unreal. He didn't even use a common framework like SDL for the heavy lifting. He built a custom engine to handle a persistent world that is essentially infinite. Think about that for a second. Every single berry picked, every forge lit, and every gravestone placed stays there. Forever. Or at least until the server wipes, which doesn't happen often.
The madness of the One Hour One Life engine architecture
Most modern games are built on "bloat." You’ve got layers of abstraction, middleware for physics, and heavy engines that need a dedicated GPU just to render a menu. The One Hour One Life engine goes the opposite direction. It’s built for low-latency, high-concurrency survival. Because the game runs in real-time and depends on precise interactions between players who might be thousands of miles apart, the engine has to be lean.
The codebase is public. You can go to GitHub right now and look at the "MinorGems" repository. It’s a massive collection of C++ libraries Rohrer has been building for decades.
It’s not just a game engine; it’s a philosophy.
The rendering is handled via a custom OpenGL wrapper. It doesn't use modern fancy shaders or ray tracing. It uses simple sprites, but the way it handles them is unique. The engine uses a "tile-based" system that is deceptively complex. Every object in the game is part of a massive tree of interactions. This is the transition-based logic. If you use a sharp stone on a long stick, the engine checks a massive database of transitions to see what happens. It doesn’t "simulate" physics in the way Skyrim does. It simulates civilization.
Why custom C++ was the only choice
If Jason had tried to build this in Unity, the overhead of the object-oriented approach would have melted the servers within a week. In One Hour One Life, there are millions of objects. Each one needs to be tracked.
👉 See also: The Real Reason Why the Lil Wayne Slot Machine Hits Different in Casinos Today
The engine uses a custom network protocol. It’s incredibly lightweight. When you move, you aren't sending a massive packet of data. You're sending tiny, optimized increments. This is how the game maintains a single, global server. There aren't "East Coast" or "Europe" servers in the traditional sense. Everyone is on the same map. You could walk for hours—real-time hours—and eventually find the ruins of a village another player built three years ago.
That kind of persistence is a nightmare for database management. The One Hour One Life engine handles this by segmenting the world into "chunks" that only load when a player is nearby, but the state of those chunks is saved with extreme efficiency. It’s basically a giant, living spreadsheet that occasionally draws pictures of carrots.
Living in the "Big Sandbox"
The engine supports something called the "Lineage" system. This isn't just a gameplay feature; it’s baked into the data structures of the engine itself. Every time a player is born, the engine generates a unique ID and links it to the mother’s ID. This creates a massive, sprawling family tree that the engine tracks in real-time.
You can actually go to the game's website and see these trees. They are massive. Thousands of generations long.
The engine also has to handle the "Genetic Score." This is a backend calculation that determines where you are born based on how well your previous ancestors survived. It’s a fascinating bit of social engineering hidden inside a game engine. If the engine sees a particular "line" is doing well, it prioritizes keeping that line alive.
- The Object System: There are over 3,000 objects in the game.
- The Transition System: There are tens of thousands of ways these objects interact.
- The Map: It’s roughly 4 billion tiles wide.
Basically, the engine is a giant state machine. Every frame, it checks for inputs and updates the state of the world. It sounds simple until you realize it’s doing this for hundreds of players simultaneously on a map that is technically larger than the surface of the Earth.
The "MinorGems" repository and the DIY aesthetic
One thing that throws people off is the UI. It looks... old. It looks like something from 1998. That’s because the One Hour One Life engine uses a custom GUI toolkit Rohrer wrote himself. He doesn't use standard Windows or Mac buttons. He draws every pixel.
This "no-dependencies" approach is why the game is so portable. It runs on almost anything. You could probably get this thing running on a high-end toaster if you really tried. By avoiding third-party libraries, Rohrer ensured that the game wouldn't break when an OS updates or a middle-ware company goes out of business.
It’s all about the "Diffs"
The way the engine handles updates is also pretty wild. Instead of a massive 2GB patch every week, the engine uses a custom "diff" system. It compares your local files to the server files and only downloads the tiny changes.
This was essential because Rohrer committed to a weekly update schedule for years. Every Friday, new items were added. The engine had to be flexible enough to accept new content without a total rebuild.
You have to respect the grit it takes to build this way. It’s lonely. It’s hard. It’s prone to bugs that only one person in the world knows how to fix. But the result is a game that feels like nothing else. The "clunky" feel of the movement? That’s not a bug. That’s the engine's fixed-step timing. It ensures that everyone sees the same thing at the same time, regardless of their frame rate.
📖 Related: Pokemon Platinum Cheat Codes: What Still Works and How to Avoid Deleting Your Save
The Engine's Legacy: Forks and Open Source
Because the One Hour One Life engine is open source, it has spawned a bunch of "forks." The most famous is You Are Hope on mobile and Two Hours One Life. These versions take the core engine and tweak the rules.
The fact that other developers can take this codebase and make it work on an iPhone is a testament to how clean the C++ actually is. It’s a very "readable" engine if you know what you’re looking at. There aren't a lot of hidden "magic" functions. It’s just straightforward, procedural logic.
- Input comes in.
- Logic checks the transition database.
- State changes.
- The "renderer" draws the new state.
No fluff.
Making your own "Life" engine insights
If you're a developer looking at this and thinking about building something similar, there are a few things to keep in mind. First, don't start with the graphics. Rohrer started with the protocol and the data structures. The visuals are the last thing that matters in a persistence-heavy simulation.
Second, embrace the limitations. The One Hour One Life engine doesn't try to be everything. It doesn't have 3D physics. It doesn't have complex lighting. It does one thing—tracking state changes over time—exceptionally well.
If you want to dive deeper into the technical side, you should look at the "Editor" that comes with the source code. It’s the same tool Rohrer uses to draw the sprites and set up the transitions. It’s an all-in-one ecosystem. It’s not "user-friendly," but it is powerful.
Practical Steps for Aspiring Developers
If you want to learn from the OHOL architecture, start by downloading the source from GitHub. Search for "jasonrohrer/OneHourOneLife."
💡 You might also like: Pokemon Would You Rather: Why These Impossible Choices Still Break the Internet
- Look at the 'server' folder: This is where the real magic happens. Notice how it doesn't use a standard SQL database. It uses flat binary files for speed.
- Check 'gameSource': See how the animations are handled. They aren't traditional spritesheets; they are individual body parts moved by code.
- Examine the 'transitions' folder: This is a giant text file. You can literally add a new recipe to the game by adding a single line of text.
The One Hour One Life engine is a masterclass in "Good Enough" engineering. It’s not "perfect" by AAA standards. It’s better. It’s functional, it’s immortal, and it’s a direct reflection of the person who wrote it.
To really understand how it feels, you have to play it. But to understand why it works, you have to look at the code. It’s a reminder that you don't need a million-dollar engine to create a world that feels infinite. You just need a very good plan and a lot of C++.
If you're interested in building a persistent world, start by defining your "state." What needs to stay forever? What can be lost? Once you solve that, the rest is just drawing pixels on a screen. Focus on the data, and the gameplay will follow. That is the true lesson of the One Hour One Life engine.