Project Epoch: The Century-Long Simulation

Project Epoch is not a game you beat; it's a world you inhabit across generations. The core concept is a single, persistent MMO server running at real-time speed, with a planned lifespan of exactly 100 years—from launch in 2025 to sunset in 2100. The world is procedurally generated but with a twist: the initial seed is derived from real-world data (topography, climate, resources), creating a plausible alternate Earth. Players can explore, build, trade, and fight, but the big picture is a collaborative narrative that unfolds over decades.

The game is divided into five 20-year epochs, each with distinct themes and global events that ripple from player decisions. Epoch 1 (2025-2045) is the Age of Discovery: settling the land, establishing first cities, and exploring the map. Epoch 2 (2045-2065) is the Age of Empires: nations rise, warfare mechanizes, and early industrialization begins. Epoch 3 (2065-2085) is the Age of Mechanization: steam and electricity emerge, altering society and the environment. Epoch 4 (2085-2105) is the Digital Age: computers, AI, and global networking—but still in a 19th-century-feeling world (steampunk/dieselpunk aesthetic). Epoch 5 (2105-2125) is the final epoch, the Age of Legacy: no new tech, only consequences. By then, the world's condition is entirely player-driven—maybe a utopia, a wasteland, or something in between.

To last 100 years, Project Epoch is designed as a living artifact. The source code and all assets are open-sourced (with a commons license) after the first 10 years. A decentralized foundation holds the IP and enforces the roadmap, ensuring no corporation can pivot or shut it down. The game's economy is non-monetary—no microtransactions—instead fueled by in-game reputation and resource scarcity modeled on real-world economic principles. Modding is sandboxed but powerful, allowing player-run servers to fork from the main timeline.

Central to the design is the concept of 'Legacy': every player's account is immortal. Characters grow old and can pass possessions and knowledge to an heir (a new character with inherited skills and memories). Death is permanent but respawning as the same character is impossible; you age and eventually die, contributing your life's data to the world's history. This creates a natural cycle that mirrors real human generations, making the 100-year span feel like multiple lifetimes.

Most MMOs reset every expansion, have no long-term consequences, and are beholden to profit motives that kill them when they stop being profitable. Players want a world that matters, where their choices echo beyond the current patch cycle. There is no game explicitly designed to last a century and treat its players as part of a ongoing historical process.

• Build a single, persistent world that runs for at least 100 real years.
• Create a simulation engine that governs ecology, economy, and conflict based on player actions, not scripted events.
• Ensure the game can survive its creators: open-source after 10 years, with a decentralized governance model.
• Implement a generational character system where players can pass down legacy to heirs.
• Design five distinct epochs with thematic technological escalations, each lasting 20 years.
• Foster emergent narratives by giving players tools to write their own history (in-game books, monuments, treaties).
• Keep the game free-to-play forever, funded by a public trust and crowdfunded pledges.

• Not a fast-paced shooter or arena game; focus on thoughtful, slower-paced interaction.
• Not a game with a traditional leveling system or classes; skills are learned and improved through use.
• Not trying to appeal to a mass audience; it's a niche product for players who value longevity and deep simulation.
• Not introducing content patches that break the world's continuity; all additions must pass a 'lore council' of players.
• Not supporting resets or wipes; the world's state is cumulative.
• Not being a moneymaker; the goal is to exist, not to turn a profit.

Custom game engine written in Rust for performance and safety, with a deterministic, lockstep server architecture to prevent cheating. Client built using WebGPU and ECS (Entity Component System) for modularity. The server simulates the entire world at 20 Hz, but only streams relevant data to clients via a custom UDP protocol with TCP-like reliability (similar to Netcode). Procedural generation uses a combination of Perlin noise, Voronoi diagrams, and ecosystem simulation (soil, water, creature behavior). A blockchain (or a ledger) for storing historical events and player legacies to ensure immutability. Distributed storage (IPFS) for game assets to avoid a single point of failure. Machine learning models (optional) for natural language processing of player-written texts to influence NPC behavior and world events.

The game is a client-server architecture with a single authoritative server hub. The world is divided into regions (chunks) of 1km², each managed by a separate server thread or process for load balancing. Regions are loaded and unloaded based on player presence. The simulation engine runs in discrete ticks (50 ms each). Each tick, all simulated entities (players, NPCs, animals, plants, weather systems) update their state based on deterministic rules and external inputs. Player actions are queued as commands and executed in order per tick. The world's 'history' is a log of every significant event (city founded, war declared, resource depleted) stored in an append-only ledger. The ledger is used to generate the world's timeline and to seed the next epoch's procedural generation (e.g., if a forest was depleted, the next epoch's map reflects a desert). The client is responsible for rendering and input, sending action packets to the server, and receiving state updates. The client also performs local interpolation for smooth visuals. The entire stack is designed to be runnable on a single modern server for up to 10,000 concurrent players (estimated). For scale, a cloud-based horizontal scaling layer using Kubernetes can spin up more region servers. The architecture emphasizes predictability and modability: all game rules are data-driven and exposed in Lua scripts that can be hot-reloaded.

• Technical risk: Running a game for 100 years requires code maintenance and deals with bit rot, hardware changes, and language evolution.
• Social risk: The player base might dwindle, leaving a ghost town. The game needs to be meaningful even with low population.
• Governance risk: The decentralized foundation might fracture, leading to forks that dilute the main timeline.
• Financial risk: Sustaining server costs for a century without microtransactions is daunting; endowment funds or perpetual pledges needed.
• Creative risk: Players might not find the slow pace engaging; the game could be boring without enough emergent action.
• Legal risk: Long-term commit to open-source and no IP enforcement could lead to clones or abuse.

• How do we guarantee the server can run continuously for 100 years? Possibly using a 'Phoenix' mechanism: the server code saves its state regularly and can be restored on new hardware.
• Should we allow player-run servers to connect to an inter-universe federation, or keep a single canon timeline?
• What happens if the foundation's funds run dry before year 100? Could players crowdfund to keep the lights on?
• How do we handle real-world events (like the internet changing) that could break the game? We might need a backward-compatibility layer.
• What is the exit strategy? On the final day, the server does one final simulation and outputs an immutable archive (the 'Chronicle of Humanity') that anyone can read.

I sketched this idea over a weekend in 2023, wrote a few pages of design doc, and even started learning Rust to build the prototype. But then I realized the sheer scope required a team of 50, a multi-million-dollar budget, and a commitment that felt overwhelming for a side project. The '110-year vision' seemed too audacious to execute as a hobby, so I shelved it—but the concept still haunts me as a perfect 'what if.'

The 100-year time frame is not arbitrary: it corresponds roughly to three human generations, making it a multi-life commitment. The game's ultimate legacy is not just code but a community tradition that could outlive the original creators. The project's motto: 'Build a world that will miss you when you're gone.'