One application model across Linux-based edge systems and supported microcontrollers – with portable WebAssembly Cells for application logic and native Rust for hardware-facing processing
Peeriot today launched the Developer Preview of Myrmic at RustConf 2026, an open, Rust-based runtime for building stateful software for machines, devices, and distributed physical systems. By bringing Linux-based edge systems and supported microcontrollers under one application model, Myrmic is designed to help teams build and evolve software-defined products across hardware generations without rebuilding the underlying software infrastructure for each target.
With this public launch, Peeriot is making the Myrmic runtime, the Rust Cell SDK, the command-line tool, and the documentation freely available. Developers can try out the Cell model, build their own applications, test the architecture in code, and participate in further development through issues, discussions, and contributions.
The Application Concept Becomes a Runtime Primitive
Today, cloud and edge ecosystems offer powerful building blocks for computing, messaging, data storage, deployment, and device integration. In many edge projects, however, teams must still redesign the relationships between these building blocks: Who owns the state of a machine? How does a workflow remain addressable when its current execution changes? Where is a computation allowed to run? And how can portable application logic and hardware-specific processing be cleanly separated?
Myrmic starts with the long-lived application concept itself. A machine, a room, a workflow, or an agent is modeled as a Cell, with a stable identity, state, behavior, commands, events, lifecycle, and requirements for the execution environment.
Other parts of the system address the Cell, not the current process or host. The runtime handles the recurring tasks surrounding it: messaging, state management, lifecycle, and capability-based placement.
A Cell thus does not specify on which computer it should run. It describes what it needs. Hosts specify which Capabilities they provide; Myrmic matches requirements with available capabilities.
An Application Model with Deliberately Different Implementations
Myrmic uses Rust as its primary development language. Portable Cell logic is compiled to WebAssembly. Hardware-specific processing, by contrast, remains in native Rust so that interrupts, timers, DMA, buses, and device-specific data paths can take advantage of the specific features of the respective target.
A semantic capability lies between these two levels. For example, a Cell should work with a semantic signal such as VibrationAnomaly, not with sensor registers, bus addresses, or DMA channels. On supported microcontroller targets, the native Signal Layer uses Embassy, among other tools, for asynchronous embedded execution.
This creates a common application model without treating Linux systems and microcontrollers as identical machines.
Designed for an Edge Where More Decisions Are Made Locally
Local inference, robotics, and sensor fusion are shifting more application logic to devices and distributed systems. At the same time, typical edge conditions persist: intermittent connections, heterogeneous hardware, scarce resources, unattended locations, and decisions that cannot wait for a remote control plane.
Peeriot positions Myrmic as an open runtime proposal for precisely this environment. The goal is a shared contract between the application model and the infrastructure, so that teams don’t have to reassemble state, messaging, local execution, hardware capabilities, and placement from scratch for every product.
“The edge has powerful individual building blocks. What teams keep rebuilding over and over again is the contract between the application, the runtime, and the hardware. With Myrmic, machine/8 becomes not just a key or endpoint, but a cell with its own identity, state, and behavior. The Developer Preview is our invitation to the Rust, embedded, and distributed systems communities: Take a look at the code, test the model, port Myrmic to new hardware, and join us in shaping an open runtime for the software-defined physical world.”
Ralf Hüskes, Co-Founder and CEO of Peeriot
Developer Preview: Open to Feedback and Contributions
The Developer Preview focuses on the cell model, messaging, state, lifecycle, capabilities, placement, and execution on Linux-based hosts and supported MCU targets. APIs, capability contracts, and target coverage may evolve during the preview. Stronger Continuity mechanisms for replicated State and mailboxes, and for resuming from committed State, are part of the roadmap.
Peeriot invites developers, maintainers, and researchers to explore the repository, build an initial cell, test failure scenarios, port to additional hardware, and provide feedback on the architecture. Contributions from the fields of Rust, WebAssembly, embedded systems, distributed systems, networking, state management, observability, and security are particularly welcome.
Myrmic Website: www.myrmic.dev
Myrmic Developer Preview: book.myrmic.dev
Open Platform, Separate Enterprise Tier
With Myrmic, Peeriot follows an open-platform model: the runtime, the cell model, the Rust SDK, the CLI, and the documentation are all open-source. The commercial enterprise tier, EdgeVance, complements Myrmic with services for governed production operations, including governance, lifecycle management, long-term support, SLAs, certification, and fleet operations.
Peeriot is a deep-tech company founded in 2022 and headquartered in Leipzig, Germany. The company develops open infrastructure for the software-defined physical world. With Myrmic, Peeriot is building an open application runtime for stateful applications across heterogeneous edge and embedded environments; EdgeVance provides a separate enterprise governance layer for governed production operations.
Peeriot has completed two funding rounds and is backed by TGFS, bm|t, and Companisto, among others. In 2026, the company was recognized with a Startup Award at embedded world.