The world's first digital twin marketplace

The marketplace for digital twins of real hardware.

Manufacturer-validated component models. Drop them into NeXosim and run mission-critical simulations in minutes — not months waiting for hardware.

Browse the marketplace →

Trusted by teams across the space industry

01 The catalog

Featured models

SARA (Solar Array Rotary Actuator)

Revolv Space

€24,000

View Buy

Aquila NFSS-411 Digital Sun Sensor

NewSpace Systems

€6,000

View Buy

See all models

02 The engine

The open-source simulation engine powering the marketplace.

NeXosim is a discrete-event simulation framework written in Rust. Models run in parallel — save and restore state, inject events at runtime, and drive simulations remotely over gRPC, or script the whole bench from Python with NeXosim-py.

284★

on GitHub

v1.0

released Feb 2026

Rust

auto-parallelized

3–5×

vs legacy tools

Explore NeXosim on GitHub →

use nexosim::{ports::EventBuffer, registry::EndpointRegistry, server};

use nexosim::simulation::{Mailbox, SimInit, Simulation, SimulationError};

use nexosim::time::MonotonicTime;

use twins::{Battery, SolarArray};

fn bench(_: ()) -> Result<(Simulation, EndpointRegistry), SimulationError> {

// Drop in certified twins — no model code to write

let mut array = SolarArray::default();

let mut battery = Battery::default();

let battery_mbox = Mailbox::new();

array.power.connect(Battery::charge, &battery_mbox);

// Telemetry endpoint for mission.py

let mut registry = EndpointRegistry::new();

let telemetry = EventBuffer::new();

battery.telemetry.connect_sink(&telemetry);

registry.add_event_sink(telemetry, "telemetry").unwrap();

let sim = SimInit::new()

.add_model(array, Mailbox::new(), "solar_array")

.add_model(battery, battery_mbox, "battery")

.init(MonotonicTime::EPOCH)?.0;

Ok((sim, registry))

}

fn main() { server::run(bench, "0.0.0.0:41633".parse().unwrap()).unwrap(); }

03 Who it's for

Built for both sides of the industry.

Whether you build with off-the-shelf components or build the components themselves, NeXosim.io is one open ecosystem that works for you.

For integrators

Stop reverse-engineering every subsystem.

Purchase per-mission licenses to certified twins. Cut non-recurring engineering, eliminate the idle wait, and de-risk integration before the systems arrive.

Manufacturer-validated behavior, no guesswork.
Per-mission licensing, instant download.
Fully virtual and hardware-in-the-loop bench support.

Browse the marketplace →

For OEMs & model developers

Turn hardware into a recurring revenue stream.

Monetize digital replicas of your hardware. Reach every integrator already building on NeXosim — the emerging standard in space V&V.

New high-margin, recurring revenue stream.
Co-developed or self-published twins, shared revenue.
Ship a behavioral twin, not your firmware.

Know it works before you build it.

Validate your whole system against certified digital twins — in minutes, not months.

Browse the marketplace →