Product
A Complete Software Ecosystem for All Machines
The smartphone revolution wasn’t just about better hardware: iOS and Android were a step change in how developers create software. The OS, tools, libraries, and app store—all designed to work together—created an entirely new software economy.
osdyne brings this same approach to the embedded world. Instead of stitching together an RTOS from one vendor, some middleware stack from another, tools from a third, and spending time and energy on making it all work together, you get a unified ecosystem designed as one coherent whole.
Key integrated components—Operating System, Drivers & Libraries, Developer Tools, Cloud Services, and Component Store: each powerful on its own, all transformative together.
osdyne Core OS
Most embedded operating systems are written in C, and often, a constrained subset of it. The use of C in embedded software leads to a significant number of safety and security vulnerabilities. We built the osdyne Core OS from scratch in Rust, bringing modern safety guarantees to real-time systems without sacrificing performance.
The architecture is microkernel-inspired: drivers, protocol stacks, and applications run in isolated compartments. If something crashes, it restarts in bounded time without taking down the system. You get the safety of process isolation even on tiny MCUs without an MMU.
Comprehensive hardware abstraction is a fundamental design feature of osdyne, because of which you can switch microcontrollers: swapping out an ARM-based MCU from vendor A with a RISC-V-based MCU from vendor B is a simple recompile.
Currently Supported Platforms: ARM Cortex-A, Cortex-R, Cortex-M, Intel, and RISC-V. Scales from tiny MCUs to PC-class workloads.
The following video gives an overview of the design principles and architecture behind the osdyne Core OS.
Drivers & Libraries
In conventional embedded software methodology, when you need a feature, it is common to call vendors, sign NDAs, wait a while, receive C tarballs, and spend precious time and effort integrating. With osdyne, you add a dependency and it just works. And in case there is no existing osdyne library or driver suitable for your needs, creating what you need on top of osdyne is significantly easier.
All libraries share consistent APIs, follow the same patterns, and are tested together. Write your application logic once, and the same code runs whether you’re targeting a sensor node or a gateway.
The following are examples of reusable software building blocks in osdyne.
Connectivity Wi-Fi • Bluetooth • Ethernet • TCP/IP • Matter • OTA
Storage File systems • Flash management • Encryption
Security TLS • Secure boot • Cryptography
UI UI library • Graphics • Display drivers • Touch input • Audio
Buses CAN • I2C • SPI • UART • USB • MIPI
Peripherals Sensors • Actuators • Motor control • GPS
Automotive CAN-FD • ISO-TP • UDS • DBC/ODX parsers
Composition & Isolation
Complex machines often have components with different criticality levels. Consider a treadmill with a software-controlled motor and a media player. The motor controller is safety-critical and must never fail. The media player is not. Traditional embedded systems either lack isolation entirely, or force you to choose: run everything together (fast but risky) or fully isolate everything (safe but slow).
osdyne lets you do both. The system is composed of independent services that communicate through a capability-based model. You decide which services share a domain (fast direct calls) and which are isolated (secure IPC). Group your UI and media player together for performance. Isolate the motor controller so a bug in the music app can never affect safety.
Thanks to Rust’s compile-time safety guarantees, this works even without an MMU or MPU. You get real isolation on the tiniest microcontrollers, where traditional approaches offer no isolation at all.
Services & Capabilities System composed of modular services connected through a compile-time dependency graph. Each service exposes its API through capability objects: if you don’t have the capability, you can’t call the service.
Flexible Domains Group related services into domains for direct function calls. Separate critical services into isolated domains with secure IPC. The build system generates all marshalling code automatically.
Fault Containment/Recovery When a service crashes, only its domain is affected. Other domains continue running, and the failed domain can restart in bounded time. The system will even help you preserve state across restarts if needed.
osdyne SDK
Being lifelong developers who have been on the bleeding edge of not just operating systems, but also developer tools, we built the osdyne SDK as a truly integrated, modern toolset that aims to minimize unnecessary cognitive load.
The osdyne SDK provides a suite of powerful command-line tools that developers can harness through an intuitive Visual Studio Code extension. Underneath, everything is purpose-built for developing machine software: a high-performance emulator written in Rust, one-click deployment to hardware, and visual editors for things that shouldn’t require code.
Emulator Develop, test, and debug without physical hardware. No more waiting for the device to flash. Both ARM Cortex-M and RISC-V are supported.
Hardware Plug in a board and it’s recognized automatically. One-click flash. Full JTAG/SWD debugging with breakpoints, variable inspection, and execution tracing.
Visual Editors Configure pins, clocks, fault isolation boundaries, and UI layouts visually: no manual register programming.
The osdyne SDK runs on Windows, macOS, and Linux.
osdyne Cloud
Modern connected machines need cloud infrastructure. Rather than reinventing things like OTA updates, fleet management, telemetry collection, and security for every product, we would want you to use your resources on things that are specific to your application logic. osdyne Cloud provides such services out of the box and integrated with the OS.The same cloud backend works across industries. A company building both industrial sensors and consumer devices uses one platform, one set of APIs, and one operations team.
Management Fleet management, device registry, over-the-air updates, geolocation…
Intelligence Analytics, diagnostics, predictive maintenance…
Security End-to-end encryption, secure boot integration, privacy by design…
Component Store
The mobile App Store concept transformed software distribution: developers could reach millions of users without building sales teams, and users could find and install software in seconds. The osdyne Component Store brings the relevant benefits of this model to the embedded world.
Browse components, try them instantly, integrate with a single command. Both open source and commercial packages live in the same registry. Need certification? Purchase certification documents, support contracts, and compliance guarantees as needed.
For Users Discover and integrate software without calling vendors, signing NDAs, or spending days on integration. Trial commercial components before buying.
For Suppliers Reach customers and monetize libraries, certification, and support services without building sales infrastructure.
Enterprise Features Vulnerability monitoring for Cyber Resilience Act compliance, SBOM management, and on-site mirroring for air-gapped environments.