Faciens Technologies · Technical exposition · Arcades Cinza

Generatica™ 1.0

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.

GENERATICA MACHINE
◇

The machine

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.

BAY 01

Break the computer

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.

BAY 02

Give it an impossible workload

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.

Changing conditions

BAY 03

Make the machine explain itself

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.

BAY 04

Send a computation through time

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.

New orientation

BAY 05

The parallel-universe experiment

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.

BAY 06

Rotate reality

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.

Turn A
Turn B

BAY 07

Create a ninth chiplet

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.

BAY 08

Teach it a new strategy

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.

BAY 09

The architecture escape room

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.

BAY 10

Challenge the conventional computer

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.

BAY 11

Discover an architecture nobody designed

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.

BAY 12

Enter the machine

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.

ANOMALY

The Generatica anomaly

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.

Workspace

Your explanation

RECORD

Your architecture

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.

SECRETS

What the machine is hiding

Twelve behaviours are found only by exploring. None is a decoration: each one, when you find it, explains something true about the model.

▸

Start here: let the geometry design a die

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.

Your workload mix

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.

1

The architectural thesis

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.

2

The mathematical substrate

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.

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.

3

The six-level hierarchy

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.

LevelResponsibilityDefined byInput → outputStatus
1Geometric and symbolic stateWorkload orientation, moments (Defs 2.2, 2.3)stages → characters, j, M₁, M₂Implemented
2Relational organisationOCL: frames, the four-coordinate interpretation, P, R, G, C, Servicecharacters, elements → which element serves which stageSpecified Implemented
3Transition governanceTSAM: values 1, 0, κ, ε∞, boundary; horizon; propagationschedule, faults, horizon → status of every stage at every moment264 cases agree with reference
4Co-admissibilityCAA: sets of requirements met by one design within a budgetstages, budget → admissible designs, conflict setsImplemented
5Contextual transferACX: guided search with transfer strength ρpast contexts, new context → order of evaluationImplemented
6Execution, verification, feedbackGate G (Principle 1.2); algorithm-based checks on resultspermitted tasks → verified results, provenanceImplemented

All six levels run in the Quester GX-1 executable demonstrator, build 0.9.2 (quester.facienstechnologies.com).

4

First realisation: Quester GX-1, eight chiplets selected by the geometry

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.

Route a workload through the levels

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.

5

Memory architecture

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.

6

Execution semantics

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.

Watch work move through the six levels

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.

The governance gate

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.

7

The evidence so far

ResultStatusWhere

The independent cost model, recomputed here

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.

Transfer tests T-6 and T-7: does the description carry from one cost model to another?

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: why it was not supported, and by how much

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.

The carry-over problem, and its fix

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: the calibrated test, and the confirmation

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.

8

The benchmark programme

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.

Full-path break-even

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.

9

Engineering constraints and how each is tested

ConstraintDesign responseTest
Descriptor construction costIncremental, cached descriptorsConstruction cost against avoided work on representative workloads
Inter-chiplet trafficLocality-aware placement; orchestration chiplet C7Measured traffic traces under concurrent load
Unsound screeningConservative thresholds; verification at level 6False-rejection rate on known admissible instances
Transfer to an unlike contextAbstention and the conventional pathAccuracy on held-out contexts
Numerical stabilityPrecision tracking; TSAM capacity ρ per formatResidual checks and condition monitoring
Stale historyVersioned entries, explicit invalidationProvenance audits
Over-specialisationReconfigurable chiplet C6 always availableCoverage across the full benchmark set
Synchronisation between chipletsAsynchronous protocols where TSAM permitsContention under high concurrency
Power and heatPower-aware schedulingThermal models from utilisation traces
Compiler complexityA structured intermediate representation carrying zCompile time and generated-code quality
10

Roadmap

StageExit gateWhere it stands
1 · Formal semanticsA consistent specification with reviewable proofsComplete OCL frame and interpretation, TSAM values and propagation, CAA and ACX, set out with proofs in the Frameworks companion
2 · Reference implementationDeterministic software, fixtures, property tests, provenanceComplete Quester GX-1 demonstrator 0.9.2, with its reproduction guide and hashed manifest
2b · Amendment A-3 and A-3.1Graded orientation and the orientation tensor confirmed on held-out contextsA-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 validationPre-registered comparisons on held-out workloadsUnder way three independently built cost models; T-6 scored (not supported), T-7 scored (supported)
4 · Architecture simulationBottleneck analysis from measured tracesNext
5 · RTL and silicon explorationSynthesis within the area, power and thermal envelopesAfter stage 4