A 1500×1500 HTML proof-of-concept that demonstrates a multi-stage production economy where value is created by time + transformation + capacity constraints, not by collecting a single “currency” number.
It models a small factory line:
Ore Silo → Smelter → Ingot Bin → Fabricator → Part Crate
…and makes the flow visible with animated material tokens moving along the line.
What it proves
1) Multi-stage value creation (not “collect coin”)
Ore is useless until processed:
- Smelting converts Ore into Ingots.
- Fabrication converts Ingots into Parts.
This forces the player to think in chains, not piles.
2) Two machines can run concurrently
The Smelter and Fabricator each have their own queue and can operate at the same time, as long as their gating conditions are satisfied.
This is the critical improvement over “one global queue”: the player now experiences real production behavior:
- Smelter can keep feeding Ingots while Fabricator consumes them.
- Fabricator can run continuously if the Smelter sustains supply.
- Both can stall independently for different reasons.
3) Buffers are real constraints (bottlenecks are visible)
Each stage has hard buffer caps:
- Ore Buffer (0–200)
- Ingot Buffer (0–50)
- Part Buffer (0–20)
This creates authentic bottlenecks:
- If Ingot buffer is full, Smelting stalls (OUTPUT BLOCKED).
- If Part buffer is full, Fabrication stalls (OUTPUT BLOCKED).
- If Ore is insufficient, Smelting stalls (WAITING FOR INPUT).
- If Ingots are insufficient, Fabrication stalls (WAITING FOR INPUT).
These stalls are not hidden—both the ledger and the output panel report them.
4) Atomic production completion (no partial outputs)
Each job progresses over time and completes atomically:
- Only at completion are inputs deducted and outputs deposited.
- No fractional items or “drip output” that muddies system clarity.
System mechanics (exact rules)
Recipes
Smelt
- Input: 10 Ore
- Output: 5 Ingots
- Time: 5s
Fabricate
- Input: 4 Ingots
- Output: 1 Part
- Time: 6s
Execution model
- Smelter processes the first Smelt job in its queue if:
- Ore ≥ 10
- Ingots + 5 ≤ 50
- Fabricator processes the first Fabricate job in its queue if:
- Ingots ≥ 4
- Parts + 1 ≤ 20
- Both machines evaluate and run every tick, so concurrency is real.
UI architecture (what each area is for)
Refinery Ledger (top)
A transparent ledger showing:
- Smelter status + queue
- Fabricator status + queue
- Each job’s progress, time remaining, and stall reason
This is the “truth screen” for debugging bottlenecks.
Input Buffers (left)
Manual controls to add/remove Ore so you can intentionally:
- starve the line
- restore supply
- test gate conditions
Output Buffers (right)
Buffers + dumps that let you intentionally:
- fill the line to trigger output blocking
- clear output space to resume production
Factory View (center)
The visual proof:
- A straight-line production path
- Tokens physically moving between stages
- Clear correspondence between buffer changes and on-screen flow
Machine-local controls
“+ Smelt” sits near the Smelter, and “+ Fabricate” sits near the Fabricator.
This makes actions feel local to the machine instead of abstract UI buttons “somewhere else.”
How to “demo” it in 15 seconds
- Click + Smelt a few times → Ingots start accumulating.
- Click + Fabricate → Parts start appearing while Smelter continues feeding.
- Keep Fabricating until Parts fill → Fabricator stalls (OUTPUT BLOCKED).
- Keep Smelting until Ingots fill → Smelter stalls (OUTPUT BLOCKED).
- Dump Parts or Ingots → the appropriate machine resumes immediately.
That’s the full economic proof: flow, bottlenecks, and staged transformation.