One source, one logic

The same unmodified protocol stack from simulation through lab emulation to real hardware, in one causally ordered run. Campaigns at scale, replay, evidence.

Simulate, test, ship

The same unmodified stack runs from simulation through emulation to real hardware, inside one causally ordered run. What you simulate is what you test and ship.

Varpnir is in its trial programme. Trial access opens soon, by invitation, for a small number of teams. Until then we show it live on request.

Join the trial programme

Patent pending.

Simulate, verify in the lab, deploy: the same unmodified stack in all three

Who it is for

Research groups

Modelling or modifying protocols, with link-level and system-level simulation in one tool and no rewrite between simulation and the lab.

Teaching

Course labs on the same stack from simulation to the bench, going in depth with observation of and changes to specific algorithms, with easy benchmarking of whole-system performance or deployment quality of service.

Stack and equipment vendors

Qualifying a stack once and debugging it in virtual time: pause a run, then replay it deterministically.

Standards delegates

Prototyping a feature as it is being specified and bringing measured behaviour to the meeting instead of an idea and an argument.

Private network builders and integrators

Rehearsing a deployment before site access: stack, traffic and radio conditions scripted, then the same configuration on the real equipment.

Owners of systems that are expensive to test on

Keeping a digital twin of a satellite link, a ground segment or a test range: the same stack, traffic and channel conditions, run and rerun on the desk, with time on the real system reserved for what only the real system can show.

Test and certification labs

Running campaigns at scale with deterministic replay, so a failure found on Friday reproduces on Monday with its evidence attached.

Silicon and modem makers

Bringing a stack up on new silicon: the same stack runs in simulation before the board arrives, then on the evaluation board, with every run replayable.

IoT device makers

Qualifying a device's connectivity stack across the conditions it will meet in the field, without a field trip per case.

Fully composable devices

Source components become layers, and layers become devices. Build once, reuse everywhere. Node-graph editors in the desktop application, a Lua scenario language in the command line tool.

Composable building blocks: components become layers, layers become devices

Fully composable systems

A system is composed of devices and channels, both logical. A channel is composed of plugins, as a device is composed of components: a channel model, a hardware IO driver, or both. Any number of devices can write to a channel or listen to it, and a device can work on several channels. In the figure, device A reaches device B through two real radios over the air, and B answers over a purely virtual channel. Channels, impairments, mobility and constellations are scripted in Lua, from a point-to-point link to a LEO constellation.

Three channels: channels 1 and 2 each hold a channel model and a hardware IO driver and are attached to two radios that talk over the air, channel 3 is purely virtual. Device A writes on channel 1 and listens on channel 3, device B listens on channel 2 and writes on channel 3, device C writes and listens on channel 3

Where Varpnir sits

Devices run on nodes: a laptop, a server, a lab machine or an embedded target. Varpnir is the layer between them. It holds the channels with their models and drivers, orders and distributes execution across the nodes, and loads on each node the compute plugins its devices need, so a device is offered the hardware-optimised compute its node has. Drivers, split interfaces and hardware in the loop live in this layer too.

Varpnir is the layer between devices and nodes: it holds channel models, hardware IO drivers and compute plugins, orders and distributes execution, and runs devices on laptops, servers and embedded targets

Why it is different

One run spans pure virtual time, paced real time and hardware on an embedded target, in a single causally ordered run. Nothing else spans all three.

One run across virtual time, paced real time and hardware, every event in causal order

Virtual and real time mix

Simulated nodes run next to lab hardware or a deployed target, in the lab and in the field.

The stack does not order time

Varpnir keeps every event in causal order, so one artifact runs unmodified in every mode.

Debug across modes in one place

Pause a run and replay it deterministically, including a failure caught on hardware.

Change one part, rerun the whole

Edit one component or algorithm in a large system and run it again, with the rest untouched.

The digital twin is the default

The system you simulate is the system you deploy, so the twin needs no separate model, workflow or environment.

What you get

One source

One codebase for the stack, from the first simulation to the target. No port to a simulator and no rewrite for the hardware, so a fix lands everywhere at once.

One logic

The stack behaves the same in every mode, because Varpnir orders time for it. The logic verified in simulation is the logic that runs on hardware.

Evidence and replay

Tracing, KPI dashboards, and deterministic replay of a hardware failure under virtual time. Results exported as CSV, JSON, Protobuf and Perfetto traces. Results an auditor accepts.

Campaigns at scale

Parameter sweeps, Monte Carlo repeats, and distributed runs across machines with automatic cross-node event transport, so a whole campaign runs overnight on the machines you have.

Agent-friendly by construction

A run is data: components, instructions and execution mode. Deterministic replay gives an agent ground truth, and typed component endpoints give it bounded tasks. Your scripts and your agents use the same command line tool.

Roadmap

What has shipped, year by year, and what comes next.

Shipped 2025

  • Execution core: events, IO and processing chains
  • Execution modes in virtual and paced real time
  • Service access points between layers

Shipped 2026

  • One stack from simulation to hardware
  • Composable layers and devices
  • Scripted wireless world
  • Campaigns and distributed runs
  • Tracing, replay and evidence export

Next

  • Licence dashboard with floating seats and group quotas
  • Documentation at docs.gna-tech.com
  • Published pricing

Later

  • More hardware drivers and split interfaces
  • Import paths from other simulators

Pay only while it runs

Authoring is free, in the desktop application and on the command line. A seat is consumed only while something runs, whoever started it: a person, a script or an agent. A run seat is held while a run executes, one per concurrent run, and covers the run’s first node. A distributed run over N nodes adds a worker seat for each of the other N−1 nodes, so a run across four machines takes one run seat and three worker seats. Groups get their own quotas. Academic institutions are licensed on their own terms. All of it is visible in the licence dashboard.

Seats: a local run takes one run seat, K parallel runs take K, a distributed run over N nodes takes one run seat plus N minus 1 worker seats

Join the trial programme

Varpnir

Trial access opens soon, by invitation. Tell us what you want to run and we will put you on the list and show you Varpnir live. Recorded demos will appear here as they are made.

Join the trial programme
See it live

Varpnir runs on Linux x86_64. The desktop application needs OpenGL 3.3 or later, the command line tool needs no display.