Geometry-first computing.
Traditional chips chew through linear instruction streams and heavy arithmetic. Generatica 1.0 flips that model, organizing computation around structured state and the relations between its parts. It is the first iteration in a family of frameworks built from the ground up on frontier geometry.
Workloads are described geometrically, screened upfront so invalid tasks are turned away before they run, tracked dynamically toward a time horizon, and placed on hardware whose layout the geometry itself selects. The Quester GX-1 GPU is our first chip design, and the upcoming photonic Orientational Processing Unit will run the same six-level design on light instead of electrons, encoding orientation directly in the polarization and phase of photons.
Labels used throughout: Result of OCL proved in the OCL papers; Checked on this page recomputed in your browser; Measured independently on a cost model built without the geometry; Prediction from the geometry; Quester GX-1 design; Next result in view.
Below is a working Generatica machine. Every experiment on this page changes the same machine and the same workload, so what you break in one bay is still broken in the next. Run it, break it, give it work it cannot do, change its mind halfway, fork it into parallel versions of itself, and ask it why it did anything at all.
What this is: a simulation of Generatica’s six levels at the scale of chiplets, running in your browser. Its hardware prices (energy per operation and area per unit of throughput for every chiplet) come from the independent cost model, which was built without the geometry and covers all 65,535 sets of characters. Times and energies are in simulation units. It shows how the architecture behaves; it is not a measurement of Quester GX-1 silicon.
Quester GX-1 as specified: eight chiplets, sized by their share of the die. Tap a chiplet to take it offline, slow it down or choke its link, then run the workload and watch the machine adapt or fail.
This is the workload the machine is running. Edit it, or invent one with conflicting constraints, limited room and conditions that change mid-run. The machine decides what it can compute, what must wait and what it must refuse, and records why.
Every decision of the last run, in order. Tap any line and the machine reconstructs why: the orientation it saw, which chiplets served it, the status of its inputs, what was resident where, and what the alternatives would have cost.
Tap a decision.
Change a stage while the machine is running it. The machine can preserve its trajectory, revise the plan, carry the stage’s context to a new chiplet, or start over. All four futures are run, and it keeps the best.
Fork the same workload into several machines at once and compare what each spends, how long it takes, what it admits, and what it finally produces.
Two turns, applied in both orders. Find out for yourself when the order changes the outcome, by how much, and when it secretly does not.
Choose which orientations your chiplet serves and how much of the die it takes from the reconfigurable chiplet. The architecture compiler runs it against a set of workloads and decides whether it earns its place or only adds complexity.
The machine knows the best placement strategy for the workloads it has seen. Give it one it has not seen: the contextual transfer mechanism (level 5, ACX) finds the nearest context, predicts the gain and its uncertainty, and either transfers or abstains. Then it is tested.
A copy of the machine has hidden faults. You cannot see them. Run probes, read the evidence, then spend your repair tokens on the right components until it meets the target.
Enter a level to begin.
The same workload on a conventional GPU of the same total area: one general element, no screening. Change the assumptions and see which architecture wins. Sometimes it is not Generatica.
Set an objective and an area budget. A search explores chiplet arrangements the designers never wrote down, prices every candidate on the same simulation, and explains why the winner won. Candidates are worth investigating; they are not automatically breakthroughs.
Run a search.
Become one stage of work and travel down through the six levels, from a point of geometry to a slice of time on a chiplet. Everything shown is what actually happened to that stage in the last run.
It starts with a strange observation. You get a workspace, not the answer: form a hypothesis, change variables, run tests, then submit an explanation. The machine grades it against its own simulation by undoing the cause you name and checking whether the anomaly disappears.
Everything you have done to the machine is recorded: its configuration, the last execution, the measured outputs and the design decisions you made. Keep it, or send it to someone.
Twelve behaviours are found only by exploring. None is a decoration: each one, when you find it, explains something true about the model.
Choose what your machine will run. Generatica describes every stage by its four signs, groups stages whose orientations agree, and gives each group its own element, sized by the work it carries and priced on the independent cost model. Fewer elements mean more sharing and more overhead per operation; more elements mean more fixed cost. The engine finds the balance and draws the die.
How it works: elements are formed by merging, one step at a time, the two groups whose mean orientations are closest once weighted by the work each carries (Ward’s criterion on the orientation vectors). Every candidate is then priced by the independent cost model, which never sees the geometry, and checked against the exhaustive optimum over every way of grouping the same stage types. Area is per unit of throughput, relative to giving every stage type its own element. This designer uses signs and mean orientation; with amendment A-3.1 now confirmed by T-7, the next version also weighs each group’s orientation tensor, calibrated to the target process.
A processor spends much of its energy and area being ready for everything at once. Generatica starts from the opposite end: describe each piece of work by its geometry first, decide what may run together and where, and only then commit hardware. The gain comes from work that never has to be done and from silicon that never has to be general where generality buys nothing.
Principle 1.1(Full-path accounting) A geometric gain counts only after everything the geometry adds has been paid for: building descriptors, relational processing, admissibility checks, contextual transfer, routing, memory traffic, synchronisation, verification and the conventional path kept for fallback. Every result on this page is stated on that basis.
Principle 1.2(Conservative governance) Missing, stale or indeterminate evidence never becomes permission. A transition is permitted, rejected or left undecided, and only a permitted transition runs.
Definition 2.1(Structured state) A unit of work carries z = (x, R, c, o, h, u, p): its primary state x, typed relations R, context c, geometric descriptors o, bounded history h, uncertainty u and provenance p.
Definition 2.2(Workload orientation) Each stage of a workload is described by four signs: precision (64 or 32 bits, or 16 and fewer), memory access (regular or irregular), what limits it (arithmetic or memory bandwidth), and its output (kept, or passed to the next stage). The sixteen sign patterns are Quester’s characters. A workload is a set of characters; its generality j is the number of signs on which its members disagree, and its mean orientation is the average of their sign vectors.
Definition 2.3(Orientation moments) For orientations sᵢ with weights wᵢ, M₁ = Σ wᵢ sᵢ and M₂ = Σ wᵢ sᵢ sᵢᵀ. For unit vectors and Σ wᵢ = 1, M₂ is positive semidefinite with trace 1. M₂ is the orientation tensor of amendment A-3.1.
Amendment A-3 and A-3.1The next improvement to the mathematics is already approved. Amendment A-3 replaces the four equal-weight signs with graded orientation, so a stage can lean toward a property rather than simply having it or not; A-3.1 adds the orientation tensor M₂ as a first-class part of every workload’s description. On the independent cost model, the exploratory analysis behind the amendment raised held-out prediction of hardware cost from 0.92 to 0.98 (energy) and 0.96 (area). Because every level of Generatica starts from that description, the improvement carries upward through the architecture: sharper relations at level 2, better-sized elements at level 4 and a better-informed search at level 5. A-3.1 is now confirmed by the pre-registered test T-7 on an independently built cost model, used with calibration for each technology (§7, transfer tests); the stricter frozen-transfer test T-6 was not supported. A-3.1 goes next into the reference implementation, the die designer on this page and the next Quester GX-1 demonstrator; graded orientation (A-3) follows with its own test.
Results (OCL and its geometry)An orientation carries its path (holonomy) and its order (rotations do not commute); co-admissibility is a property of the whole set of requirements, not of its pairs; under the Hopf map the sixteen characters fall four to a point under every reading. Proofs and laboratories: the Faciens Frameworks companion and Faciens Technologies Discoveries.
Where a CPU pipeline fetches, decodes and executes, and a GPU schedules threads in lockstep, Generatica passes each unit of work through six levels, each defined by one of the Faciens frameworks.
| Level | Responsibility | Defined by | Input → output | Status |
|---|---|---|---|---|
| 1 | Geometric and symbolic state | Workload orientation, moments (Defs 2.2, 2.3) | stages → characters, j, M₁, M₂ | Implemented |
| 2 | Relational organisation | OCL: frames, the four-coordinate interpretation, P, R, G, C, Service | characters, elements → which element serves which stage | Specified Implemented |
| 3 | Transition governance | TSAM: values 1, 0, κ, ε∞, boundary; horizon; propagation | schedule, faults, horizon → status of every stage at every moment | 264 cases agree with reference |
| 4 | Co-admissibility | CAA: sets of requirements met by one design within a budget | stages, budget → admissible designs, conflict sets | Implemented |
| 5 | Contextual transfer | ACX: guided search with transfer strength ρ | past contexts, new context → order of evaluation | Implemented |
| 6 | Execution, verification, feedback | Gate G (Principle 1.2); algorithm-based checks on results | permitted tasks → verified results, provenance | Implemented |
All six levels run in the Quester GX-1 executable demonstrator, build 0.9.2 (quester.facienstechnologies.com).
Quester GX-1’s organisation is not drawn by hand. The design generator searches organisations of up to eight elements, admits only those OCL and CAA allow, and prices them; the organisation below is the one it recommends. Each chiplet is defined by the sign pattern it serves (a dot means any value), and its share of the die follows from the work it is expected to carry.
Published targetsFP4 60 PFLOP/s, FP8 35, FP16 8, FP32 0.3, FP64 0.1; 512 GB of high-bandwidth memory at 40 TB/s; 1 GB of L2 and 256 MB of on-chip SRAM. The demonstrator shows each target against the reference GPU and states which workloads reach it.
Choose a workload, or build one from the sixteen characters. The page describes it (level 1), finds which chiplets serve each stage (level 2), gives every stage its status (level 3), tests which stage sets can share one chiplet (level 4), and prices the alternative of a single general element on the independent cost model.
DesignFour logically distinct classes: state memory, relational memory, geometric-descriptor memory and history memory. Every descriptor is stored with its source version, context, precision, construction method and the conditions that invalidate it, because a stale descriptor can admit a transition it should reject. Lifecycle: ingest, describe, cache, use or update, verify, archive or expire. HBM holds state and history; on-chip SRAM holds descriptors and relations, which are small and read on every decision.
Every unit of work moves through six stages: describe, relate, propose, govern, execute, verify and learn. It travels as a task descriptor o = (X, R, c, T, A, ε, ρ): state reference, relations, context, requested operation, admissibility policy, error tolerance and provenance. The gate at the govern stage is three-valued.
Each dot is a unit of work. At the gate it is permitted, rejected (it falls away, and the work it would have cost is saved) or left undecided (it waits for evidence and tries again). The counters compare the evaluations Generatica performs with those a conventional machine would perform on the same stream.
Set the evidence from each level. The gate combines it under Principle 1.2: any rejection rejects; otherwise any missing or stale evidence leaves the task undecided; only complete, current, favourable evidence permits.
| Result | Status | Where |
|---|
An independent cost model, built by a separate team without access to the geometry, prices sharing one general element across every one of the 65,535 sets of characters. Choose a set size and the page recomputes, over every set of that size, how well generality j and the mean orientation predict the cost.
Everything above is measured on one cost model, Argon’s, at 45 nm. A result that holds in one model might describe that model’s own arithmetic rather than hardware. So the description was tested on cost models built by others who never saw the geometry, the first model or its results: Grok 4.7 built one at 28 nm for T-6, and Perplexity built one at 45 nm for T-7. Both worked from the same brief, which gives only the four properties of a stage and asks for a bottom-up model from cited physical figures. Each test was locked, with file hashes, before the model it would be scored on existed.
T-6 asked the strictest question: if the weights are learned once on Argon’s model and frozen, do they rank the cost of sharing one element in a model they have never seen? The weights were fitted on all 14,196 sets of four to six characters in Argon’s model, hashed, and scored without any change on Grok’s. The verdict rules were fixed in advance. Supported needed a rank correlation of at least 0.6 for energy and area at every size, and a lead over the best possible flag score. Not supported was triggered by any value below 0.3, or by failing to beat generality j at sizes five and six. Anything between was partial.
The frozen predictors scored between 0.26 and 0.37. At size six both versions fell below the 0.3 line: 0.273 and 0.270 for flags with the mean orientation, 0.293 and 0.264 with the orientation tensor added; the tensor version’s area score at size five, 0.294, was also below it. Any one of these is enough for not supported. The degree matters, and the record states it: the misses were narrow, between 0.006 and 0.036 under the line, and the other conditions were largely met. The ranking was positive at every size, ahead of generality j at every size, and ahead of the best flag score at sizes five and six (not on area at size four). But every value was far from the 0.6 needed for support. In plain terms, the frozen weights ordered the sets somewhat better than chance and well short of usefully. What failed is a specific claim: that weights learned in one model predict another model unchanged. It is not a finding that the description carries no information about cost. That was the next question.
What failed to carry over were the weights, not the description. The weights are prices: how much a technology charges for a wide numeric format, relative to irregular access, to bandwidth, to forwarding. Argon’s 45 nm model and Grok’s 28 nm model price these differently. They agree on direction, since the signs of the weights fitted on each model match for every area term and for 85% of the energy terms, but not on size, and a frozen weighted sum with the wrong sizes puts sets in the wrong order. Refitting the same features on half of Grok’s sets and scoring the other half gave 0.86 to 0.99. That was an exploratory check, not a result, because it was run after the verdict was known.
The fix follows how chips are actually designed. Every design flow calibrates its cost figures for each manufacturing process before it is trusted, and nobody carries one foundry’s prices to another unchanged. So the description stays fixed and the weights are calibrated from a small sample in each technology. Because the size of that sample (60 sets) and the thresholds were chosen after looking at Grok’s model, Grok’s model could not be used to judge the fix. It needed a third model, built after the test was locked. T-6 keeps its verdict.
T-7 was written and hashed before the third model existed. For each set size, 60 randomly drawn sets calibrate the weights: 3.3% of the 1,820 sets of four, 1.4% of the 4,368 sets of five and 0.75% of the 8,008 sets of six. Every other set is held out and ranked. This is repeated over 20 splits with fixed seeds, and the median counts. Supported needed at least 0.6 and a lead over a flag score calibrated on the same sets, at every size and for both measures. Not supported was any value under 0.3 or no lead over the flags. Perplexity’s model was then built from the brief alone. Its code matched its stated hashes, its four required checks passed on 3,000 random cases here, and its cited figures were checked against the sources.
The result was supported: a median of 0.88 to 0.97 at every size and for both measures, at least 0.71 even on the worst of the 20 splits, against 0.07 to 0.26 for the flags. Amendment A-3.1 is confirmed by T-7: describing a workload by its orientation, including the orientation tensor and calibrated for each technology, ranks the cost of sharing hardware in an independently built model. The scope is stated with the result. Graded orientation (A-3 proper) was not part of T-7 and has its own test to come. The tensor’s own share is largest at size four (0.93 against 0.73 for the mean orientation alone) and small by size six (0.97 against 0.95). The cost models are analytical, not silicon. Argon’s and Perplexity’s models draw some figures from the same public paper (Horowitz, ISSCC 2014), although neither builder saw the other’s model.
Comparisons are against strong conventional CPU and GPU baselines, conventional execution with geometric screening added, the full Generatica runtime and its ablations, at matched solution quality and matched tuning budgets, with every overhead in Principle 1.1 included. Workload classes: covariance-aware anomaly detection, context-transfer optimisation, history-sensitive inference, multi-constraint scheduling, and typed graph and hypergraph search. Metrics: time to solution, latency at the 50th, 95th and 99th percentiles, memory and inter-chiplet traffic, energy per completed task, solution quality, false-rejection and false-admission rates, abstention rate and recovery from faults.
Screening N candidates at cost s each removes a fraction p before full evaluation at cost e. Every overhead of Principle 1.1 is charged. The gain is the ratio of conventional to Generatica cost.
Next result in viewA pre-registered test of graded orientation (amendment A-3), with orientations varied continuously instead of the four signs, scored on independently built cost models under per-technology calibration as in T-7.
| Constraint | Design response | Test |
|---|---|---|
| Descriptor construction cost | Incremental, cached descriptors | Construction cost against avoided work on representative workloads |
| Inter-chiplet traffic | Locality-aware placement; orchestration chiplet C7 | Measured traffic traces under concurrent load |
| Unsound screening | Conservative thresholds; verification at level 6 | False-rejection rate on known admissible instances |
| Transfer to an unlike context | Abstention and the conventional path | Accuracy on held-out contexts |
| Numerical stability | Precision tracking; TSAM capacity ρ per format | Residual checks and condition monitoring |
| Stale history | Versioned entries, explicit invalidation | Provenance audits |
| Over-specialisation | Reconfigurable chiplet C6 always available | Coverage across the full benchmark set |
| Synchronisation between chiplets | Asynchronous protocols where TSAM permits | Contention under high concurrency |
| Power and heat | Power-aware scheduling | Thermal models from utilisation traces |
| Compiler complexity | A structured intermediate representation carrying z | Compile time and generated-code quality |
| Stage | Exit gate | Where it stands |
|---|---|---|
| 1 · Formal semantics | A consistent specification with reviewable proofs | Complete OCL frame and interpretation, TSAM values and propagation, CAA and ACX, set out with proofs in the Frameworks companion |
| 2 · Reference implementation | Deterministic software, fixtures, property tests, provenance | Complete Quester GX-1 demonstrator 0.9.2, with its reproduction guide and hashed manifest |
| 2b · Amendment A-3 and A-3.1 | Graded orientation and the orientation tensor confirmed on held-out contexts | A-3.1 confirmed by T-7 calibrated transfer supported on an independent model (0.88 to 0.97); frozen transfer (T-6) not supported; A-3 graded orientation test next; then built into levels 1 to 5 and the next demonstrator |
| 3 · Controlled benchmark validation | Pre-registered comparisons on held-out workloads | Under way three independently built cost models; T-6 scored (not supported), T-7 scored (supported) |
| 4 · Architecture simulation | Bottleneck analysis from measured traces | Next |
| 5 · RTL and silicon exploration | Synthesis within the area, power and thermal envelopes | After stage 4 |