Why Nexus

Making games is hard

Years of development. Every time - inventing mechanics and wiring them into systems. Want to add hunger - you write a hunger system. Want hunger to trigger migration - you add migration and build the links between them. Want migrations to cause wars - another link, more code, more months of work.

Every new mechanic multiplies complexity. Not because the idea is complex, but because that's how development works: every connection between systems is separate code, separate debugging, separate maintenance. The deeper the world, the more connections, the harder it is to hold together.

The deepest games in the industry take decades to develop. The price of world depth is years of work.

Copying mechanics

More video games ship every year. With generative AI, this flow will accelerate. The number of players is growing too, but not as fast. Competition for every player intensifies.

Meanwhile, most games within a genre are built the same way. RPGs resemble other RPGs, strategies resemble other strategies. Differences come down to details, art, lore. But every studio rebuilds the foundation from scratch each time: combat systems, economy, AI, events. The same mechanics are reinvented by thousands of studios in parallel.

Even sandbox games remain collections of separate rigid systems. Variety comes from the number of systems, not from a different approach to architecture itself.

The classical approach and its limits

The standard industry approach: look at current trends and propose original solutions by combining ideas from successful projects.

Three main approaches to development:

• Experimentation, the "dream game" - maximally original projects. Risky, but offers a chance to create an unusual hit.
• Cloning - producing games with minimal changes. The lowest-risk path.
• A middle ground - combining proven ideas with new elements. How most developers work.

Whichever path you choose, the process remains evolutionary. You take an idea that looks promising right now and try to ship it. The outcome is unknown in advance. Even after a successful game, the next one effectively starts from zero. Money and proven formulas don't guarantee results.

But the main problem isn't even that. The classical approach doesn't scale in depth. Complexity grows not proportionally to the number of systems, but much faster - because of the connections between them. That's why deep worlds on the classical approach take decades.

A different approach

I used the concept of the Ideal Final Result from the engineering method TRIZ. The core idea: a successful project isn't the result of trial and error, but of precisely defining the problem.

The first step is setting a goal. What do I want? What is the ideal final result? The more precise the goal, the easier it is to evaluate any ideas and trends.

The ideal game as a compass

The ideal game is usually described as a simulation indistinguishable from reality, where the player can do anything. From this definition, requirements follow:

• The player can be a participant or an observer
• No preset genres - the game adapts to what the player wants
• No separation between single-player and multiplayer
• The world reacts naturally, without scripts. A routine trip to the store can turn into an adventure.

Building such a game right now is impossible. But it sets the direction.

Any new idea or mechanic can be measured against this line. Does it align with the course, veer off, or turn back? Ideas closer to the ideal game have greater potential.

The popularity of sandboxes with replayability and mods is growing - the industry is moving in this direction.

Rising player expectations

Players want more freedom, replayability, and possibilities - and these demands point the same way as the ideal game. They want to experiment, to combine things that once seemed incompatible. Established genres are blending more and more.

But the more freedom and depth, the harder the development. The most promising directions turn out to be the most difficult.

The solution: flat complexity

I set out to create a system where complexity doesn't grow with the number of mechanics. Like building blocks: stone, wood, brick. You can build a castle from a million blocks, and the system itself doesn't get more complex. The blocks are the same. The rules are the same. Only the quantity grows, not the complexity. Nexus applies the same principle to all game mechanics.

Adding a new mechanic shouldn't make the system more complex. Not new code, not a new subsystem - a new fact in the same flat structure.

The foundation is triples (facts), a format from knowledge bases and semantic networks: subject, predicate, object. "Drought causes famine" and "war causes migration" share the same structure. Whether you're describing natural phenomena or social processes, the format is the same.

A formal language of facts scales without growing complexity. Ten facts about a world and ten thousand facts - the same structure, the same rules, the same engine.

Nexus is built on facts (statements about the world), not code (instructions for a computer). Facts can be added, removed, combined - and the world reconfigures itself.

Why this way

Cause-and-effect chains instead of scripts. In a conventional game, "drought → famine" is a hand-written script. In Nexus these are facts: "drought reduces grass", "no grass → herbivore famine", "famine → migration", "migration → clashes". Each fact is simple.

Genres as modules. If mechanics are facts, then a genre is a set of facts. Plug in facts about strategic management - you get strategy mechanics. Plug in facts about card combat - you get card mechanics. Plug in both - you get a strategy with card battles.

Existing platforms build worlds from scripts and editors. Nexus builds worlds from facts - statements about how the world works.

Clarus Victoria's experience

Over 13 years Clarus Victoria has released seven games - from historical strategies Stone Age and Egypt: Old Kingdom to the fantasy RPG Next Run. Each covered a narrow setting with a limited set of mechanics. All this time, players kept asking: make other eras, make Rome, China, Mesopotamia. And we genuinely wanted to.