Factory

Rebuild The System

Factory is a top-down building & automation game where you rebuild "The System" — a computational entity — by transforming digital resources across five layers, from raw extraction up to metacomputation. The world is a physical space rendered in digital terms.

There's no playable character: you act entirely through an orbital cursor, placing structures and wiring production chains. The ending isn't fixed — it emerges from the Will and Identity your economic decisions shape along the way.

Optimisation under tension

The whole economy is squeezed by three simultaneous pressures. No upgrade is free — improving one dimension almost always piles pressure on another, and that trade-off is the game.

Five layers, three raw resources

Everything starts from three base resources — Data, Energy and Silicon — each existing in four states or variants. Every process also spits out subproducts and hazardous waste (toxic gas, mutant code, failure cascades) that has to be contained or recycled rather than ignored.

Chains climb five layers — extraction, refining, synthesis, advanced computation and metacomputation. Each layer's outputs feed the next, and the top of the stack is where raw materials finally become Will, Identity and the narrative payoff.

Machines that run themselves

Dozens of machines span the five layers, from the first Excavator and Silicon Mine to fission reactors, defragmenters, cycle condensers, heat dissipators and entropy neutralisers. Each carries its own input/output inventory, a cost in all three pressures, module slots and HP. Processing machines pick a recipe from a pool; extractors sit on a world node and pull from it at a rate scaled by node purity.

Automation is the heart of it: machines are wired with direct links, recipes run on their own, and a full output slot applies backpressure that propagates backwards and makes the bottleneck visible. Speed, Efficiency, Specialisation and Resilience modules let you push any machine further — at a cost somewhere else.

Decay you have to fight for

Entropy and corruption accumulate per sector — the zone of influence around each machine. Push a sector past its thresholds and structures lose output, subproducts turn hazardous, and corruption sets in as permanent damage that only active repair undoes.

Decay spreads on its own through proximity and faster through active connections, so every sector is a containment decision. Cleaning one is a two-stage cost — stabilise the entropy, then repair the corruption — and abandoning it frees resources but leaves a persistent corruption focus on the map. That tension turns layout into strategy.

Built to reuse

The project is Blueprint-first and engineered around reusable systems rather than one-off scripts: a single inventory component, a BP_Producer_Base family every machine inherits, and a generic area-drag layer shared by demolition and selection. The build loop — select, ghost, validate, place, demolish — closes end to end, with placement validated against grid or free-snap modes.

Decisions are measured, not eyeballed: a frame-independent "eased" camera (input sets a target, Tick chases it), a push-based UI architecture that killed per-frame casts and a whole class of Accessed-None errors, and a 1,000-building stress test that held frame on the logic side. Currently in the resources-and-processing phase: nodes, extractors and a live machine-status system that halts production when the output backs up.