Layer1Labs is raising seed funding — $1–1.5M on a SAFE, seeking a lead investor. Talk to us →
The Stack

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

The Layer1Labs full stack — circular overviewSOFTWARE · CHRONOHIVELingua Francaprogramswhat you writechronoccompilerat build timeConstraintspecificationone compiled artifactChronoHiveengineruns the specificationin softwareDeterministicschedulingprefetch, checkpoint,dispatchChronoFabrictierthe same specification,soft IP, in hardwareEffectorbindingFPGA & hardwareendpointsKria FPGAboardsbeta evaluationplatformZero misseddeparturesin validation runs100% deliveredLAYER1LABSDeterministicOrchestrationone program · two tiersHARDWARE · CHRONOFABRICThe Layer1Labs full stack — circular overviewSOFTWARE · CHRONOHIVELingua Francaprogramswhat you writechronoccompilerat build timeConstraintspecificationone compiled artifactChronoHiveengineruns the specificationin softwareDeterministicschedulingprefetch, checkpoint,dispatchChronoFabrictierthe same specification,soft IP, in hardwareEffectorbindingFPGA & hardwareendpointsKria FPGAboardsbeta evaluationplatformZero misseddeparturesin validation runs100% deliveredLAYER1LABSDeterministicOrchestrationone program · two tiersHARDWARE · CHRONOFABRIC
One program — Lingua Franca — compiled once, run in software by ChronoHive or bound to hardware by ChronoFabric.
The Layer1Labs stack1You write reactorsLingua Franca,made of reactors2chronoc compiles itThe compiler,at build time3One specificationthe program, its capacities,and its schedule — as data4ChronoHivesoftware engineChronoFabrichardware tier5Effectors— customer-ownedstorage writes · data reads ·network sends · actionsRUNS IN YOUR INFRASTRUCTUREyour clusters · your storage · your devicesThe Layer1Labs stack1You write reactorsa program in Lingua Franca2chronoc compiles itthe compiler, at build time3One specificationits capacities and schedule, as data4Two runtimes run itChronoHivesoftware engineChronoFabrichardware tier5Effectors— customer-ownedstorage writes · data reads · network sends · actionsRUNS IN YOUR INFRASTRUCTUREyour clusters · your storage · your devices

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.

Interactive illustration. A simplified coordinator built for this demo runs on our server — its code isn’t shipped to your browser. On the coordinated side, the signal timings are computed live by the production ChronoHive engine. The fuel and CO₂ figures are modeled from published U.S. EPA and Department of Energy factors — see the note under the demo.
The program that times these lights
The Lingua Franca program that describes how the coordinated side is timed — compiled ahead of time into a constraint model that the ChronoHive engine executes on our server, not in your browser.
Simulated day off — steady peak demand

Time-of-day jumps work when the simulated day is on — with it off, demand holds steady at the peak and the chips wait.

Run
Peak demand
Typical peak
Simulated day
Turning traffic
Vehicles on the road
Events

Disruptions — you run the world. The managed grid has to answer.

Auto events
Speed
Overlay

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.

Fixed timersdumb cycle, blind to demand
Fixed timers
Coordinatedphases set from the whole grid
Coordinated
Signal timings: local fallback planner — the ChronoHive engine is unreachable

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.

↑ Back to the reactor demo · This analogy, in the FAQ →

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.

Interactive illustration — simulated valuesThe production engine and compiler don’t run in your browser; this page simulates the public architecture so you can feel how it behaves. See what the real system measured →
Run
Speed
Target
Storage speed
75 simulated ms

Same program. Same specification. Only the effector binding changed — in both lanes.

Coordinated

Stall ticks: 0 · Finish: —
Fingerprint: — trace fingerprint (illustrative)
Trainer — compute
CheckpointIO — writes
PrefetchIO — read-ahead
Storage capacity — In flight: 0 of 100 units
Effectors — where the program touches the outside world
storage write — software callabledata read — software callablenetwork send — software callable

Uncoordinated

Stall ticks: 0 · Finish: —
Fingerprint: — trace fingerprint (illustrative)
Trainer — compute
CheckpointIO — writes
PrefetchIO — read-ahead
Storage capacity — In flight: 0 of 100 units
Effectors — where the program touches the outside world
storage write — software callabledata read — software callablenetwork send — software callable
Run both lanes — the difference readout lands here once a paired run finishes.

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.

See what ChronoHive measured →

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.

+9.8%End-to-end training speedup — measured on real data

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.

See the full measured results →

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
}
1

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.

2

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.

3

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.

4

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.

5

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:

AspectChronoHive (software)ChronoFabric (hardware)
ProgramIdentical — the same Lingua Franca sourceIdentical — the same Lingua Franca source
Constraint specificationIdentical — the same fileIdentical — the same file
GuaranteesAdmission, sequencing, and determinism — the sameThe same guarantees, carried over unchanged
Effectors bind toSoftware callables — ordinary program functions: storage, network, servicesFPGA and hardware endpoints — the physical interfaces of the device
Runs onThe clusters you already ownThe hardware tier, staged from FPGA evaluation platforms to production hardware
StatusOffered for commercial licensing nowComplete 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.

+9.8%End-to-end training speedup — measured on real data

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.

+24.1% / +21.7%
MeasuredWall-clock improvement for GPU-bound training over slow, shared storage (about 100 MB/s), on RTX 4070 SUPER and RTX 5060 Ti respectively.
+12.1% / +9.8%
MeasuredWall-clock improvement for a CPU-bound workload in the same slow, shared-storage regime.
+5.9% / +4.9%
MeasuredWall-clock improvement for GPU-bound training on fast local NVMe storage with 94 MB checkpoints, on RTX 4070 SUPER and RTX 5060 Ti respectively.
+7.3% / +6.5%
MeasuredWall-clock improvement for GPU-bound training on fast local NVMe storage with ~1 GB checkpoints, on RTX 4070 SUPER and RTX 5060 Ti respectively.
+1.7%
MeasuredEnd-to-end job-time improvement for two-rank distributed training (DDP, the standard PyTorch multi-process training mode).
≤3× checkpoint size
MeasuredThe asynchronous checkpoint writer's memory footprint is bounded at 3× the checkpoint size — measured at every capture across 40 preregistered isolated trials. The previous transport reached ~7× at ~4 GB checkpoints.

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.

Full measured results →

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.