How It Works
One program, compiled once, runs the same way in software and in hardware — and the same way every time.
This page walks the whole Layer1Labs stack end to end — what you write, what it compiles to, and where it runs — and then lets you operate an illustration of it.
The Stack
One program. One specification. Only the effector binding changes.
1 · You write reactors A program in Lingua Franca, made of reactors: independent pieces of the program that react to events on a defined schedule.
2 · chronoc compiles it Our compiler turns the program into a single constraint specification (.cspec): one self-contained file that carries the whole program.
3 · One constraint specification The same artifact runs everywhere. Nothing is recompiled per target.
4 · Two runtimes run it ChronoHive, the software engine, and ChronoFabric, the hardware tier. ChronoFabric is delivered as soft IP — a licensable hardware IP block — targeting Kria FPGA platforms. Embedded chiplets and merchant silicon are the future step on the hardware roadmap.
5 · Effectors reach the outside world An effector is a connection point where the program acts: a storage write, a data read, a network send, a hardware action. Effectors are customer-owned: they do the real work, in your infrastructure.
One idea, two scales
Two interactive illustrations of the same idea — coordination — at two scales: a city traffic grid, and a compute workload.
Coordination, at City Scale
The same idea, somewhere anyone can see it. Below are two copies of the same small city grid — three avenues crossing three streets, nine signaled intersections, two lanes each way — running side by side on exactly the same stream of cars. The traffic lights are effectors: the points where a program acts on the world. A coordinator watches the real state of the whole grid — how many cars are waiting on every approach, and which way each of them means to turn — and sets the lights against it; when a street is nearly full it also holds new cars briefly at the grid’s edge, where they block nobody, instead of letting them spill in and jam the intersections behind them.
That is the same discipline ChronoHive applies to compute in software and ChronoFabric applies in hardware, pointed at a street grid: sense the whole system, decide once, enforce it the same way every time. The left grid’s lights run on fixed timers; the right grid’s signal timings are managed against the whole grid — its queues, its turning traffic, and what is coming. Cars turn at the intersections here: left turners wait at the stop line for a gap in the oncoming stream, the way they do on a real street, and, as the page opens, both grids face the same steady stream of cars at the Typical peak; switch the simulated day on and they live through a full day instead, with a morning and an evening rush that builds and clears. Under each grid, readouts track how full the grid is, the fuel it burns, the CO₂ that comes with it, and the stops it makes. Same streets, same cars, same demand — watch the queues.
target Chrono
reactor PlanDriver(rounds=1) {
output go
state c = 0
timer tick(0, 1 ms)
reaction(tick) -> go {=
sense_snapshot(cycle_min=36, cycle_max=72, clearance_ticks=2, queue_clamp=999, eta_clamp=9999)
c = c + 1
go.set({"round": c})
if c >= rounds:
request_stop()
=}
}
reactor Intersection(row=0, col=0) {
input sense
output timed
reaction(sense) -> timed {=
time_intersection(row=row, col=col, units=1, left_pressure_min=3, left_cross=24, travel_ticks=116)
timed.set({"row": row, "col": col})
=}
}
reactor Metering {
input timed_in
output metered
reaction(timed_in) -> metered {=
meter_entries(entry_segment_cap=20)
metered.set({"metered": 1})
=}
}
reactor Emit {
input metered_in
reaction(metered_in) {=
emit_plan()
=}
}
main reactor TrafficGrid(rounds=1) {
d = new PlanDriver(rounds=rounds)
i00 = new Intersection(row=0, col=0)
i01 = new Intersection(row=0, col=1)
i02 = new Intersection(row=0, col=2)
i10 = new Intersection(row=1, col=0)
i11 = new Intersection(row=1, col=1)
i12 = new Intersection(row=1, col=2)
i20 = new Intersection(row=2, col=0)
i21 = new Intersection(row=2, col=1)
i22 = new Intersection(row=2, col=2)
m = new Metering()
e = new Emit()
d.go -> i00.sense
i00.timed -> i01.sense
i01.timed -> i02.sense
i02.timed -> i10.sense
i10.timed -> i11.sense
i11.timed -> i12.sense
i12.timed -> i20.sense
i20.timed -> i21.sense
i21.timed -> i22.sense
i22.timed -> m.timed_in
m.metered -> e.metered_in
}Compiled from exactly this source (SHA-256 8c4ef47b82da0b91… — the hash bound into the compiled specification) with chronoc 0.1.0 · target Chrono · lfc 0.14.0-SNAPSHOT. The engine executes the compiled specification for every coordinated plan. The source is extracted at build time and checked against the bound hash — if they ever disagree, this page does not ship.
One reactor per crossing: the PlanDriver starts each round, nine Intersection reactors — one for each crossing of the 3×3 grid — time their own intersection, and a Metering reactor applies the rule for cars entering the grid. The program states what happens and in what order; the engine produces each plan by executing the compiled constraint model. The demo’s cars and lights are simulated in your browser.
Go deeper: The Traffic Demo, In Depth
How the program above works, how it becomes the running plan, and every measurement behind this demo — including where coordination barely helps.
Time-of-day jumps work when the simulated day is on — with it off, demand holds steady at the peak and the chips wait.
Disruptions — you run the world. The managed grid has to answer.
Colors each road segment by the traffic density measured on it, green to red.
No events right now. Arm one above and drop it on either grid — it lands on both.
Two grids, identical demand. Fixed timers: 0 cars in the grid, 0 waiting. Coordinated: 0 cars in the grid, 0 waiting. Waiting for the coordinator’s first plans — all lights are red.
Same streets, same cars, same demand — the only difference is coordination.
Fuel and CO₂ are modeled, not measured — each simulated car’s energy use follows published U.S. EPA and Department of Energy factors for its type (gasoline car, hybrid car, diesel truck, electric), applied to the time it spends idling, cruising, and stopping-and-starting. When the simulated day is on, demand follows a measured weekday curve from a U.S. urban arterial (Idaho Department of Transportation counts). Electric cars count zero tailpipe CO₂; their electricity is reported in kWh.
How the coordinated side works: every few seconds at the default 4× speed — and once per signal cycle at the slower speeds — this page’s server sends the grid’s state — queues by turning movement, and what is approaching — to the production ChronoHive engine, which returns the next signal timings. Only the timings come back; the vehicles are simulated in your browser, and the engine never sees your device. If the engine can’t be reached, the demo holds the last engine plan, then switches to a built-in fallback planner — and says so, in the coordinated grid’s status line, for as long as the fallback is running.
The events are demonstrations with labeled settings, not measurements: a crash holds one approach to single file for about 90 simulated minutes; roadworks close an approach for about 4½ simulated hours; an event surge sends an extra, fixed set of trips to one corner over about 3 simulated hours — the same set on both grids, counted separately from the day’s own trips. Events you place land on the same approach on both grids — placing one is choosing where the world breaks, never an advantage handed to one side. On a closure, the coordinated side diverts traffic at the intersection before the closure from the moment it starts; the fixed timers make no diversion — their drivers wait at the barrier and find their own way. Neither side is told about an event in advance: both learn about a crash only from the queues it causes, and the engine computes the coordinated side’s timings from those queues.
The fuel and CO₂ figures under each grid are the running totals for the block of trips being served — a day’s trips when the simulated day is on. Every trip in the block counts from the moment it is taken in: a trip still on the road counts in the totals, and in the per-trip averages, at what it has burned so far — so the two grids’ per-trip figures always cover the same trips at the same moment, while totals are only ever compared once both grids have brought the same block of trips home. At 4× the coordinator re-times every few seconds of real time rather than every signal cycle; on slower screens the fastest playback may run slower than its label — the clock always shows the time actually simulated.
One honest boundary: this demo gives both grids the same fixed set of trips — that is what makes the comparison fair. A real corridor that gets faster also attracts drivers from other routes, and can draw out trips that would not otherwise be made. Those extra trips would raise the faster grid’s totals while lowering the wider network’s cost per trip. The table below bounds that effect with arithmetic on the figures above; the simulation itself never changes either grid’s trips.
Try it: the same work, twice
Run both lanes. It is the same program, the same inputs, and the same storage speed on both sides — the coordinated lane schedules its storage work, the uncoordinated lane does not. Watch the stall counters and the finish ticks, then run it again and compare the fingerprints: the coordinated lane repeats its trace exactly, while the uncoordinated lane’s order — and its fingerprint — changes.
Same program. Same specification. Only the effector binding changed — in both lanes.
Coordinated
Fingerprint: — trace fingerprint (illustrative)
Uncoordinated
Fingerprint: — trace fingerprint (illustrative)
Same program. Same inputs. The coordinated lane lands on the same trace, every time — the uncoordinated lane wanders, and pays for the wandering in stalls. That is what “deterministic” buys you.
How This Maps to Reality — and the Savings
The demo above runs on tick counts — simulation state, an illustration of the mechanism, not a measurement. But the waiting it shows is real, and in a training cluster it has a price. Three translations:
The ticks are waiting
In a real training run, the stalls in the uncoordinated lane are GPU idle time — accelerators paid for by the hour, sitting still while storage sorts itself out.
Coordination removes the wait, not the work
Same program, same outputs, less wall-clock. The computation is identical; only the waiting is scheduled away.
GPU-hours are the bill
Training time is bought by the GPU-hour. Recovered wall-clock is more tokens per GPU-hour — a lower cost per token — from the clusters you already run.
Preregistered A/B trial (ResNet-18 on CIFAR-10): six interleaved trials of 200 steps, run on RTX 5060 Ti and RTX 4070 SUPER graphics processors. 9.8% faster end-to-end on both GPUs — just under our own 10% confirmation bar, and reported exactly as measured. In the regime where storage contention bites hardest, the same system measured more: +24.1% / +21.7% — measured wall-clock improvement for GPU-bound training over slow, shared storage (about 100 MB/s), on RTX 4070 SUPER and RTX 5060 Ti respectively. Every figure carries its label, and gains are never stacked across regimes.
The same admission control, in the same preregistered test on three platforms, was positive on each: +9.85% on an Amazon EC2 g5.xlarge instance (NVIDIA A10G), +7.95% on an RTX 4070 SUPER, and +5.54% on an RTX 5060 Ti — under our 10% confirmation bar on each, a positive observation, not a proof. In the determinism campaign, 92 of 92 runs reproduced exactly, and 400 of 400 checkpoints were read back and verified. On hardware, ChronoFabric delivered more than 21,000 scheduled packets between two Kria boards with zero missed departures — timing jitter as low as 61 nanoseconds, and its real-time stack held worst-case scheduling latency to 22 microseconds over a full 24-hour run.
The Program
This is the whole program the demo runs. It is a real program, shown sanitized — the reference workload our customer materials describe: a training loop whose checkpointing and prefetch are separate, coordinated reactors. It is shown at demo scale — 12 steps, a checkpoint every 4 — so a full run fits on this page. The reactors, the connections, and the logic are the program itself.
// IoCoordinator.lf — a training-loop program in Lingua Franca.//
// A timed training loop (Trainer) drives storage I/O through two
// single-purpose reactors: CheckpointIO admits periodic checkpoints
// and PrefetchIO issues read-ahead. chronoc compiles this program
// into a single constraint specification; the same specification runs in ChronoHive
// (software) and on ChronoFabric (hardware).
target Chrono
1reactor Trainer(steps=12, ckpt_every=4) {
output step_done
output ckpt_request
state step = 0
timer tick(0, 1 ms)
reaction(tick) -> step_done, ckpt_request {=
train_step()
step = step + 1
step_done.set({"step": step})
if step % ckpt_every == 0:
ckpt_request.set({"step": step})
if step >= steps:
request_stop()
=}
}
2reactor CheckpointIO(mb=64) {
input ckpt
reaction(ckpt) {=
3 admit_checkpoint(mb=mb)
=}
}
4reactor PrefetchIO(depth=4) {
input tick
reaction(tick) {=
prefetch(depth=depth)
=}
}
5main reactor IoCoordinator(steps=12, ckpt_every=4, ckpt_mb=64, prefetch_depth=4) {
t = new Trainer(steps=steps, ckpt_every=ckpt_every)
c = new CheckpointIO(mb=ckpt_mb)
p = new PrefetchIO(depth=prefetch_depth)
t.ckpt_request -> c.ckpt
t.step_done -> p.tick
}The Trainer loop. A timer fires once per step. Each firing trains one step, reports step_done, and — every fourth step — asks for a checkpoint. When the step count is reached, the program stops.
CheckpointIO is a separate reactor. Its only job is checkpoint writes. When a request arrives, it admits the write — admission is the programmed policy deciding which storage work may run, and when. The policy is stated once, in the program, and enforced the same way on every run.
Capacity, in plain words. Capacity is how much storage work may be in flight at once. The demo gives its storage a capacity of 100 units: a checkpoint occupies 64 (its size in the program), a prefetch 40 — so a checkpoint and a prefetch can never overlap, and something has to go first. That ordering decision, made the same way every time, is the whole game.
PrefetchIO is a separate reactor. Its only job is reading data ahead — depth 4, up to four batches in flight — so the next batch is already on its way before the Trainer needs it.
The wiring. The main reactor connects the pieces: checkpoint requests flow from the Trainer to CheckpointIO, and every finished step signals PrefetchIO. The same wiring runs on both runtimes — only the effectors, the functions that actually touch storage, bind differently.
One Specification, Two Runtimes
Everything above runs twice — once in software, once in hardware — from the same artifact. The table is the whole difference:
| Aspect | ChronoHive (software) | ChronoFabric (hardware) |
|---|---|---|
| Program | Identical — the same Lingua Franca source | Identical — the same Lingua Franca source |
| Constraint specification | Identical — the same file | Identical — the same file |
| Guarantees | Admission, sequencing, and determinism — the same | The same guarantees, carried over unchanged |
| Effectors bind to | Software callables — ordinary program functions: storage, network, services | FPGA and hardware endpoints — the physical interfaces of the device |
| Runs on | The clusters you already own | The hardware tier, staged from FPGA evaluation platforms to production hardware |
| Status | Offered for commercial licensing now | Complete and ready for beta customers |
ChronoFabric is available now as soft IP — a licensable hardware IP block — targeting Kria FPGA platforms; embedded chiplets and merchant silicon are future offerings on the staged hardware roadmap.
Why Determinism Matters
Replayable runs
The same program with the same inputs produces the same decisions, bit-for-bit. When a run can be replayed exactly, debugging, compliance, and regression testing get straightforward — there is no “it only fails sometimes.”
Accelerators stay fed
Coordinated prefetch and checkpointing keep GPUs working instead of waiting on storage. The expensive hardware does the job it was bought for.
One policy, enforced
Checkpoint and prefetch admission is tuned to real storage capacity under one programmed policy: fewer stalls, zero duplicate writes, and no contention deciding your performance for you.
Measured Results
The demo above is an illustration. These are measurements — each labeled with how it was obtained, and never stacked across regimes.
Preregistered A/B trial (ResNet-18 on CIFAR-10): six interleaved trials of 200 steps, run on RTX 5060 Ti and RTX 4070 SUPER graphics processors. 9.8% faster end-to-end on both GPUs — just under our own 10% confirmation bar, and reported exactly as measured.
Measurement envelope: all results above are single-node, on at most 2 GPUs. No multi-node or cluster measurement exists yet — any cluster figure in our materials is a labeled scenario or model, never a measurement.
Work With Us
Partnerships & Beta
License ChronoHive into the clusters you already run — pilots are isolated, software-first, and validated against criteria fixed in writing before any run. Methodology and trial data are available on request. Or join the ChronoFabric beta and evaluate hardware enforcement with our team.
Investors
Layer1Labs is raising a $1–1.5M seed round on a SAFE and is seeking a lead investor. The technology is protected before it is public — and every result we publish carries its measurement label.
10 patents pending.
