A backend.Not a backdrop.

The World Engine is a separate C++ project that exposes its systems to Godot through the GDExtension binding. Game logic lives in the engine; presentation lives in Godot. The split means the engine can run on a server, in tests, or headless for tooling without dragging the renderer along.

The engine owns the canonical simulation. Its responsibilities include:

• Characters and parties. Every NPC, monster, and player party member is a Character entity with a behaviour tree, inventory, profession, and essence loadout.
• Cities and markets. Each city tracks population, production, the market object, buy orders, sell flags, and faction membership.
• Factions and diplomacy. All ten major factions plus minor groups maintain bilateral relations, treaties, active wars, and policy stances.
• Quests and stories. Procedural and hand-authored quests live on the same data model; the StorySystem advances arcs while the QuestSystem handles individual quest state.
• Resource nodes and locations. Every harvestable node in the world tracks its own abundance, depletion rate, and respawn timer.
• Time, travel, weather, events. One canonical world clock; deterministic travel times; a weather model; and a propagation system for events that cross region boundaries.

The WorldEventGenerator is a procedural narrative engine that runs on top of the simulation. Its job is to scan the world state, detect imbalances, and turn them into narrative seeds — small data packets that downstream systems can hatch into stories, quests, or news rumors.

“Every systemic imbalance is a narrative seed waiting to bloom.”

The flow:

CitySystem    ──┐
NodeSystem    ──┼── scan_world_state() ── NarrativeSeeds ──┬── StorySystem    (arcs)
FactionSystem ──┘                                          ├── QuestSystem    (quests)
                                                           └── News / Rumor   (board posts)

Where the WorldEventGenerator works at world scale, the StimulusSystem works at character scale. Every entity carries a PerceptionProfile — sensory range, attention weighting, memory capacity — and the StimulusSystem broadcasts events that nearby entities perceive based on that profile. Perceived events fire reaction handlers, which queue follow-up behaviour for the character system to act on.

The flow per entity is:perceive → react → remember → communicate.

Concrete example. You decline a request to escort a relief caravan into a famine-struck region (the request originally generated from a Resource Scarcity seed). What happens afterwards is not scripted:

1. QuestSystem marks your decline. Quest state expires; reward escrow returns to the originating city.
2. CitySystem doesn't get the relief food. Resource scarcity stays severity 0.9. Population health degrades.
3. WorldEventGenerator re-scans on its next tick, sees the scarcity hasn't resolved, and spawns the next-tier seed — Population Crisis if population drops below 50.
4. FactionSystem updates the local faction's relation with you: refusal of assistance during a crisis is a relations hit, propagating through diplomatic channels.
5. TradeSystem sees food prices in the region remain elevated. Long-haul traders re-evaluate. New trade routes open. Other Merchant NPCs accept the work you declined.
6. StimulusSystem broadcasts your refusal as a social event to nearby characters. NPCs who witnessed it adjust their attitude toward you. Some may decline to offer you quests later.

None of these reactions are individually large. The aggregate — over months of in-game time, across multiple decisions — is what makes the world feel responsive. The simulation doesn't punish you for declining a quest; it just refuses to pretend the consequences didn't happen.

The simulation is deterministic given the same seed and the same input event stream. The seed is fixed when you start a new game; every choice you make from that point is part of the input stream. Reloading a save replays the simulation to the saved tick, not just the saved state.

A save file therefore captures: the world seed, every player choice, every committed quest result, the current world clock, and a snapshot of all major systems' state at the save instant. Restoring is exact — including the trader who was halfway through a long-haul convoy when you saved.

Save XML serialization details live in the dev docs (XML_Serialization, SAVE_SYSTEM_GAP_ANALYSIS). A player-facing save-scope summary will live on the FAQ page once that ships.