Project · Godot authoring system · Systems architecture
VOID
VOID is an authoring system for simulation games — the tools and the architecture that let a whole living world be built as data instead of code. The bet behind it: most engines are a pile of separate subsystems glued together, and the glue is where the bugs and the labor live. So VOID collapses them — every subsystem is one graph queried differently, every behavior a chain of nine verbs. The editor tools that author against that architecture are built and run in Godot today; the game on top is the demo, not the product.
The bet: one graph, nine verbs
What looks like many systems — NPC behavior, reputation, economy, quests, factions, ecology — is one typed weighted graph queried differently. The subsystems are views of the substrate, not separate systems: the engine runs one query machinery (graph traversal with weight composition) and presents its output through many interfaces. Fewer code paths, fewer integration bugs, and — the actual point — content that is authored, not coded.
Behavior gets the same reduction. Every action — cooking, combat, prayer,
mining, dying — is a chain of nine atomic verbs (go_to,
do_work, choose, interact, and five
more). One verb, do_work, carries most of the weight through a
requirement/effect system. Chains are data loaded at runtime; the only
compiled logic is the scheduler. New content is a new chain, not new
code. The same instinct sits under the world model too:
agency is substrate access — an NPC’s identity is which slice
of the graph it can reach, so a hermit’s worldview is thin because its
neighborhood is small, and a dragon’s power is that its neighborhood
is larger than any human’s.
What’s built: the tools are the product
The authoring layer is a compiled C++ GDExtension (~5,300 lines) — real Godot editor tooling, not a script pretending to be a plugin:
- a dialogue-graph editor and a behavior-chain graph editor — the nine-verb chains, built visually;
- an object builder with a 3D viewport and a parts catalog;
- a vector painter and a manga-page canvas;
- the graph primitive itself, reified as a live Godot resource that builds
its own pathfinding (
AStar2D) from the authored nodes and edges.
This is the least-fakeable part of the project. A compiled extension with
working editor plugins — custom resource types, viewport input forwarding,
graph views — is a different tier of work from gameplay scripting, and it is
the tier that matters here, because the tools are the deliverable.
Everything else is what the tools are for. That discipline shows up
in the engine docs too: rather than assume what the extension layer can do,
I mapped its hard ceiling and verified it against godot-cpp-4.3.
Authoring by demonstration
One design document is mostly an argument against using machine learning. The principle: in a game, ML is almost never a capability you couldn’t write by hand — it’s a labor transfer. It converts authoring from specification (write the rule — requires understanding it) to demonstration (provide examples — requires only recognizing what you want). “ORK by demonstration.” The guard against overreach is a self-test: to make the training data, would I just apply a rule I already know? If yes, write the rule. ML earns its place only where behavior is tacit — demonstrable but not writable — and even then as a tiny CPU-grade net kept honest against a plain-interpolation baseline.
This is how I think about ML in the engine, not something it ships. Which is the point worth making: knowing when not to reach for a model is the harder half of the skill.
- the runtime that executes the substrate — the graph/mesh query engine, NPC simulation, needs and mood, gossip propagation — designed across dozens of documents, not yet in the compiled module;
- the ML layer — trainers, weights, inference — currently empty directories behind the doctrine above;
- the game as showpiece — the eventual demo that runs authored content live and gives the tools something to show off.
Status & access
A personal, in-development project. The architecture is documented at length, and the authoring layer is built as a compiled Godot editor extension.