Operating system for physical computers · v0.9.3 preview
Equilibrium is one regime, not the whole story. VonNeuro runs programs that minimise an objective, draw from a distribution, or evolve far from equilibrium — on p-bits, annealers, memristive networks, neuromorphic chips, a plain CPU, or a dish of living neurons. You state the intent and the contracts. The compiler finds the physics and shows its work.
curl -fsSL get.vonneuro.com | sh
Three commitments the whole system is built on.
A program states what it means mathematically, not which chip you own. Each backend lowers that meaning to a native physical process — a coupling matrix, an anneal schedule, a driven circuit — instead of pretending the device is a CPU.
Plenty of useful computation has no energy function to descend. Driven, dissipative and self-organising dynamics are first-class here — which is also what makes the same abstraction reach living systems, judged on declared observables rather than on whether they settle.
Joules per task alone say nothing about what was avoidable. Every run reports measured
dissipation and the thermodynamic lower bound it should be read against —
or refuses the comparison. vnstat shows both.
The semantic core is small on purpose. Everything reduces to these three.
Most stacks assume the second and third are approximations of the first. They aren't. A sampler is not a failed optimiser, and a driven network held away from equilibrium is not a relaxation that hasn't finished yet.
Objectives, ground states, fixed points. The program declares the energy and the tolerated gap; the backend picks the schedule and reports where it landed.
p-bits · annealers · Ising machines · crossbars
Inference, marginals, low-energy ensembles. The contract is distributional — total variation, effective sample size — so devices that make randomness differently can still be compared.
p-bits · annealers as samplers · stochastic devices
Continuous-time dynamics under external drive: reservoirs, memristive self-organisation, analog circuits, limit cycles and hysteresis. No energy function is required, and none is invented.
memristive networks · neuromorphic · analog · photonic · living tissue
The driver contract asks three questions. Living systems can answer them.
A cell was running a driven, noisy, dissipative computation long before anyone built a chip to imitate one. Nothing in the semantic core mentions silicon. A backend qualifies if it can report its state, accept a drive, and characterise its own noise — and tissue can do all three. What changes is the timescale, the drift, and how honestly the energy can be measured.
Non-stationary over hours. The device contract is re-fit continuously, not assumed.
Seconds to hours per run. Latency contracts are the binding constraint, not accuracy.
Intrinsically stochastic, so it lowers naturally to a sampling contract.
Living backends are held to the same contracts and the same honesty. Dissipation is metabolic and only estimated, so the ledger marks it modelled rather than measured, and refuses comparisons across boundaries it cannot justify. Protocol, provenance and approval constraints are part of the device contract, not an afterthought.
L5 → L0. Meaning at the top, matter at the bottom.
Compilation here is not translation into machine instructions. It is a model-conditioned transformation: program meaning plus contracts plus the current device model, producing an executable physical process and the record of what that cost in assumptions.
Declare state spaces, intent, and three contracts: what counts as correct, what thermodynamic description holds, and what the device must support.
A serialisable representation of maps, dynamics, distributions, objectives, measurements and composition — the portable object, and the thing that outlives any one front end.
Contract checking, the thermodynamic analysis pass, algorithm selection, and splitting a program across two modalities without hiding conversion and communication costs.
Event-driven scheduler with a 3.7 µs median dispatch, capability-based device isolation, the device registry, and the ledger that meters every run.
A versioned, machine-readable statement of native operations, connectivity, parameter ranges, noise, timing, calibration state and available energy measurements. Compilation targets a device instance at a time; when calibration drifts, the runtime recompiles and your source doesn't move.
Stochastic bits, annealing hardware, adaptive networks, spiking silicon, analog and photonic operators, cultured neurons and reaction networks — or a digital reference that simulates any of them for when you need a baseline you can trust.
volt 0.9 · files end in .volt · Python front end in pyvolt
Every program carries four things: mathematical intent, a computational contract, a thermodynamic contract, and the device requirements. The last two are what let a run on a p-bit fabric and a run on a crossbar be compared honestly — or declared incomparable.
// minimise — one source, three very different machines problem max_cut(G) { state s: spin[G.vertices]; minimise H(s) = sum((i,j) in G.edges, G.w[i,j] * s[i] * s[j]); return best(s), samples(s); } execution { stochastic = allowed; objective_gap <= 0.02; confidence >= 0.99; samples = 2000; } thermodynamics { input_distribution = workload.max_cut; process_boundary = encode_to_readout; coarse_graining = logical_spin; lower_bound = mismatch_cost; }
// sample — the target is a distribution, not a single answer model infer(y, W, b) { latent z: binary[W.rows]; energy E(z; y) = -0.5 * z' W z - b(y)' z; sample z ~ boltzmann(E, beta); return marginal(z), samples(z); } execution { total_variation <= 0.05; effective_samples >= 1000; stochastic = required; } // the compiler will not assume annealer output is Boltzmann. // that claim has to come from the backend, with calibration evidence. thermodynamics { input_distribution = data.y_distribution; process_boundary = load_to_sample; lower_bound = mismatch_cost; }
// evolve — driven dynamics, never asked to settle system classify_stream(u, target) { state x: real[n] @node; parameters theta: device_controls; evolve dx/dt = F(x, u, theta) for T @drive(periodic, f=2.4kHz); observe y(t) = C x(t); train readout C to minimise loss(y, target); } execution { latency <= 5ms; accuracy >= 0.95; device_noise = allowed; // hysteresis and memory stay in the model } thermodynamics { process_boundary = initialise_to_readout; time_partition = measurement_grid; // finer grid, tighter bound coarse_graining = declared_observables; steady_state = nonequilibrium; // no detailed balance claimed lower_bound = mismatch_cost; }
# the ledger: what it cost, and what it could not have cost less $ vnstat --run 4417 --watch program max_cut substrate pbit0 (FPGA, 4096 p-bits) regime minimise + sample boundary encode→readout ────────────────────────────────────────────────────────────────────── samples 2,000 objective gap 0.014 contract met wall 184 ms latency ok ────────────────────────────────────────────────────────────────────── measured dissipation 41.2 mJ (board rail, ±3%) mismatch-cost bound 9.7 mJ (T = 300 K, prior = anneal_family) ratio to bound 4.2× entropy production 0.043 k_B / update bound status preserved through embedding ────────────────────────────────────────────────────────────────────── vs run 118 (xbar0) not comparable — different process boundary (readout coarse-graining differs; narrow or re-declare)
minimise · sample · evolve
The three intents of the semantic core. A program says which one it means, and the conformance test follows from that — an objective gap, a distributional distance, or a tolerance on declared observables.
execution { … }
What counts as a correct result. Stochasticity, admissible approximation, precision, confidence, latency. A backend that cannot meet it is rejected at compile time, with the failing clause named.
thermodynamics { … }
The process model, input distribution, prior, boundary, time decomposition and coarse-graining. Without these, a joule figure is not a claim about anything.
steady_state = nonequilibrium
Says the run is held away from equilibrium by an external drive. Detailed balance is not assumed, so the analysis uses the driven forms and the runtime tracks entropy production rather than energy descent.
Stated where each result holds — and where it stops.
Backpropagation asks matter for an exact reverse pass over stored activations. These rules ask only for what physical systems already do: settling, fluctuating, being driven, and dissipating.
Settle twice, subtract the correlations. Every term is available at the coupling itself, so the update runs inside the array with no activation tape.
Applies to relaxation programs only
When the system is held out of equilibrium there is no free phase to contrast against. Updates come from correlations along the driven trajectory, and the cost is a steady entropy production rate rather than a descent that ends.
Reservoirs · memristive self-organisation · neural cultures
For a fixed stochastic map, actual input distribution and process-dependent prior, the drop in KL divergence lower-bounds entropy production. It is the first analysis the compiler implements, and it is why the prior has to be declared.
Reported in kB, and in joules under stated T
Memristive elements have internal state, drift and loop area. VonNeuro models them explicitly and plans pulse trains against the device's own dynamics instead of assuming a write lands where you asked.
Calibrated at boot · re-fit on drift
Fluctuation identities of Jarzynski–Crooks type turn device noise into free-energy estimates, so the runtime samples with the hardware's randomness instead of spending energy suppressing it.
Anneal schedules · free-energy readout
For programs that declare an energy, the compiler checks the update against it and emits runtime assertions where it can't decide statically. Programs that declare no energy get observable tolerances instead — not a fake Lyapunov function.
Static check · runtime assertion · stall escalation
A real sequence: each step either keeps the bound or it doesn't.
A thermodynamic provenance graph travels with the program. At each transformation the compiler must state whether the bound survives — and a run that ends in an invalid comparison is a useful scientific result, not a failure to be papered over.
Input distribution, prior family, process start and end, coarse-graining.
bound statedLogical spins become chains of physical qubits; the state space changes shape.
recomputedEvaluating the process at higher temporal resolution tightens the bound.
strengthenedVariables removed at readout need backend justification before bounds compare.
weakenedDifferent boundaries or priors means the two energy figures are not the same claim.
not comparableWhat runs where, in which regime, and how good the energy evidence is.
The same semantic graph runs on all of these. What changes is the native regime, how much the compiler has to approximate, and whether dissipation is measured on a rail or only modelled.
| Substrate | Driver | Native regime | Energy evidence | Status |
|---|---|---|---|---|
| CPU — x86-64, arm64, riscv64 | vn-hal/cpu | minimise sample evolve | Counters, modelled | stable |
| GPU — CUDA, Metal, Vulkan | vn-hal/gpu | minimise sample | Board telemetry | stable |
| p-bit fabric on FPGA | vn-hal/pbit | sample minimise | Rail measurement | stable |
| Quantum annealer / Ising machine | vn-hal/anneal | minimise sample | Service-reported | preview |
| Event-driven neuromorphic ASIC | vn-hal/spike | evolve sample | On-chip counters | preview |
| 1T1R memristive crossbar | vn-hal/xbar | minimise evolve | Rail measurement | preview |
| Self-organising nanowire mesh | vn-hal/mesh | evolve | Probe-limited | research |
| Photonic / analog linear operator | vn-hal/optic | evolve | Modelled only | research |
| Neuronal culture on MEA | vn-hal/culture | evolve sample | Metabolic, modelled | research |
| Molecular / DNA reaction network | vn-hal/molec | sample evolve | Modelled only | research |
| Engineered gene circuit | vn-hal/genet | sample | Modelled only | research |
Host systems: Linux 6.1+ · macOS 14+ · Windows 11 via WSL2 · bare metal on arm64
and riscv64.
Bindings: C ABI, Python, Rust. Neuromorphic backends can lower through
existing intermediate layers rather than around them.
Install the toolchain, run the digital reference on your laptop, then point the same semantic graph at a p-bit fabric, an annealer, or a crossbar. The source doesn't change — only the evidence record does.
curl -fsSL get.vonneuro.com | sh