Relax it. Sample it.
Or keep it driven.

What VonNeuro does today

Computing is becoming heterogeneous. CPUs already share the work with GPUs and accelerators; next to them sits a growing family of physical processors — analog circuits, memristive networks, stochastic samplers — that compute by letting matter relax, fluctuate or respond, rather than by stepping through instructions. VonNeuro is developing a pancomputing approach for that world: a common language in which a task states what it needs, so it can be decided which processor should run it, why, and how — and a record of what each run cost and how far its answer can be trusted.

Bringing analog and stochastic computing back is a resource for the future, not a nostalgia. Physics can sample, relax to a minimum or filter a signal in time with far less energy than a digital machine simulating the same process. That saving is a promise we measure, not a result we claim yet, and the answers such hardware gives are statistical: certifying that they meet what a program declared is the part we are building now.

The bench is a proof of concept, not a product: a first prototype that multiplexes 16 RC coprocessors and 16 memristors behind one laboratory instrument, next to a hardware p-bit sampler, all online through vonNeuro Messenger. You write a program in an early version of VOLT, pick any of the 32 devices, and get back the measurement — raw samples, settings and provenance included. It exists to show that the whole loop works on real, imperfect devices.

From here we are moving toward a bit of everything: photonic and spintronic devices, annealers, neuromorphic chips, larger memristive arrays and living neural cultures, alongside conventional processors. For physicists, each is a natural process put to work, with its own noise and its own energy budget. For computer scientists, it is one more target behind a single language, chosen by a compiler that knows what each device can and cannot do. For anyone weighing where computing goes next, it is a way to keep adding capacity as the energy cost of conventional computing keeps rising — without rewriting software for every new kind of hardware.

running now Messenger, VOLT 0.1 on the bench, VOLT processing, the instrument presets and the devices above. roadmap The full OS described below — compiler, kernel, thermodynamic ledger and the wider substrate list.

vonNeuro Messenger: chips you can reach

Messenger is the VonNeuro device server, built on vonNeuro Messenger. It connects laboratory hardware — including one-off and experimental chips — to accounts on the web, without asking the laboratory to redesign the device around a new computer architecture. You send a job; the computer wired to the instrument runs it; the results come back to you.

# git clone github.com/vonneuro/messenger (access on request), then: pip install -e messenger
from vonneuro_messenger import MessengerClient

c = MessengerClient("https://series-marina-gigantic.ngrok-free.dev")
c.login("you", "your-password")

# a VOLT 0.1 program, run on memristor 15 of the bench
program = """
system memristor_evolve(u: real) {
  state material: adaptive;
  evolve material for 10 ms using drive.interval(u);
  observe response: real from material.terminal_current;
  return response;
  execution { intent = evolve; output = response; }
  device { dialects = [dynamical, adaptive];
           required_capabilities = [drive.interval, observe.terminals]; }
  thermodynamics { process_boundary = "drive_to_observation"; }
}"""
reply = c.volt_run(program, {"u": 0.5}, "memristor:15")
print(reply["result"]["value"])       # +5.6e-08 A, measured
print(reply["measured_energy_j"])        # 8.3e-11 J at the terminals

# the same program on an RC is refused before anything is driven
c.volt_run(program, {"u": 0.5}, "rc:2")["error"]
# 'device.dialects: adaptive not a dialect of rc (dynamical)'

Three ways matter can be useful

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.

Physical includes biological

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.

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.

The stack, meaning to matter

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.

State the intent. Declare the contracts.

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.

// target syntax (planned) · 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;
}

// target syntax (planned) · 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;
}

// target syntax (planned) · 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;
}

# illustrative output — the ledger and vnstat are not built yet; figures are examples
# 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)

// runs today · VOLT 0.1 · compiled to .vng, run on a memristor or RC of the bench via volt_run
system memristor_evolve(player_offset: real) {
  state material: adaptive;

  evolve material for 10 ms using drive.interval(player_offset);
  observe response: real from material.terminal_current;
  return response;

  execution {
    intent    = evolve;
    output    = response;
    tolerance = 0.05;
  }

  device {
    dialects              = [dynamical, adaptive];
    required_capabilities = [drive.interval, observe.terminals];
    calibration           = current_epoch;
  }

  thermodynamics {
    process_boundary = "drive_to_observation";
    energy_class     = uncharacterized;   // declared honestly: not measured yet
  }
}

Learning and accounting, without pretending

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.

Every lowering says what it cost you

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.

Cross-platform, stated plainly

The first five rows run today. The rest are the backends the same semantic graph is designed to reach: what changes is the native regime, how much the compiler has to approximate, and whether dissipation is measured on a rail or only modelled.

Today: Python (Windows-tested) for the bench, VOLT tools and the Messenger client; the Messenger server runs anywhere Python and FastAPI do.
Planned: Linux, macOS and WSL2 hosts, bare metal on arm64 and riscv64, and C, Python and Rust bindings. Neuromorphic backends are meant to lower through existing intermediate layers rather than around them.