My Journey to Atym

Earlier this year, while contemplating my next career move, two serendipitous events occurred: a blog post on Hacker News titled “Wasm Will Replace Containers”  caught my attention, and an old colleague reached out about an open role at Atym, which utilizes WebAssembly (Wasm).

Inspired, I took the plunge into Wasm and was struck by the richness of the ecosystem and how far beyond the browser it extended. I had admittedly brushed off Wasm-related content in the past — I’m a hardware guy, and it has “Web” in the title! How relevant to me could it actually be?

I went deeper and challenged my assumptions, reading about the WebAssembly Micro Runtime (WAMR), WebAssembly System Interface (WASI), and more. What started as curiosity began to turn into conviction that this stack had the opportunity to form a foundation for doing embedded development differently — in a way that felt modern, flexible, and scalable.

Embedded Development: From Frustration to Empathy

I’ve felt the pain of embedded development from two sides.

Early in my career, I worked as an electrical engineer on industrial and medical products — long dev cycles, mountains of firmware, incredibly complex or insufficient test routines, vendor-locked toolchains (don’t even get me started on FPGAs), and awful documentation. Every new project felt like reinventing the wheel, which began to burn me out after six years and three companies.

I later joined Particle as a Solutions Architect, shifting to work directly with customers launching connected products. This experience widened my perspective: the challenges I had faced as a developer were more pervasive than I’d realized. Particle inspired me because their platform aimed to provide a foundation to make embedded development easier and enable teams to focus on what mattered to their business. At first, selling an IoT platform felt like a huge opportunity to do just that.  But over time, I came to see that Particle’s simplicity could lead to inflexibility and scaling challenges — especially for OEMs with complex product portfolios or sensitive data who couldn’t afford to put a third party in their data path. As that reality set in, it became clear I had overcorrected — trading one set of pains for another.

Throughout these experiences, I lived and heard the same stories:

• Tooling was fragmented and hard to use.

• Firmware was complicated, slow, and inflexible.

• Hiring embedded talent was expensive and a bottleneck for development.

• Testing and security were always important — but often under-resourced or delayed.

• Firmware updates were a pain and a source of fear.

• Moving to a new hardware platform meant rewriting an incredible amount from scratch.

Sadly, the longer one spends in the space, the more these challenges become ingrained and simply accepted as part of doing business. However, Wasm and Atym inspired me to consider a world in which things really could be different. What if we really could apply modern software practices and rethink the embedded stack? Not just with a better IDE, another SDK, or a new language — but with a real shift in how we develop, deploy, and maintain applications at the edge?

WebAssembly to the Rescue: Atym’s Vision for Embedded

WebAssembly (Wasm) began as a portable, binary instruction format for web browsers — but today it’s much more than that. By combining WASI, WAMR, and an RTOS like Zephyr , we finally have the underpinning to run portable Wasm binaries on embedded devices.

Atym's open source runtime, Ocre, is built on these technologies and delivers a Wasm-based container engine designed for embedded devices. Developers have access to hardware-specific APIs exposed through Wasm’s Foreign Function Interface, and with a footprint of only 128KB, Ocre can run on any device including microcontrollers with as little as 256KB of RAM. It provides secure, portable, modular containers with an extremely small on-device footprint.

This combination brings us to exciting territory. Now embedded devices can have the benefits of containerized development:

• Language Flexibility: WebAssembly allows developers to write embedded applications in a language of their choice — whether it’s C/C++, Rust, or even higher-level languages like Python or Go — and compile to a binary. This enables a much larger pool of developers to be able to contribute to projects, not just those with specific embedded expertise.

• Hardware Portability: Rather than building against one target and porting firmware across each new chipset, developers can compile their application to a WebAssembly module and run it anywhere. It breaks the dependency on vendor-specific SDKs and enables cross-platform reuse.

• Security: WebAssembly’s sandboxed security model means each module runs isolated from others and from the host system. Each container must be given specific permissions to access the hardware and other containers, with all access disabled by default. If a module becomes compromised, the effects are limited to only what it has access to.

• Reliability: Unlike a monolithic firmware application, if one Wasm container crashes or misbehaves, it won’t take down the entire device — the runtime can trap faults and keep other containers running. This isolation means better fault tolerance and easier debugging.

The list above already brings a potentially huge impact to embedded projects. However, one of the biggest selling points for me is that Ocre is fully open source and hosted by the Linux Foundation with vendor-neutral governance. I saw firsthand the impact of open core technology during my time at Particle, where the RTOS was open source as well. Watching the community engage with platform development — and feeling the trust it created in customer conversations — really validated the approach for me.

Atym has taken this even further by hosting Ocre through the Linux Foundation, with the goal of making it a standard for lightweight containerization and orchestration for resource-constrained devices. As our CEO Jason shared with me during onboarding:

“We believe in investing in standards, and standards drive scale.”

Beyond the Runtime: Container Management and Orchestration with the Atym Hub

With Ocre at the core, Atym is focused on making this technology accessible to embedded developers at scale. We understand that a new piece of technology doesn’t solve our challenges on its own, so our commercial orchestration Hub is designed to provide critical, centralized infrastructure to scale production deployments.  Our Hub is available as SaaS or on-prem and brings containerization and standard DevOps best practices to devices that would otherwise run firmware or embedded Linux.

On top of the benefits of Ocre, here are some of the benefits the Atym Hub adds that I’m most excited about:

• Ahead-of-Time (AoT) Compilation: During deployment, the Atym Hub automatically compiles Wasm container binaries into native code for the target device(s). Developers write once, and Atym handles the rest. This ensures apps run with as near native performance as possible and enables chipset-specific acceleration for advanced applications such as edge inference and ML.

• Fractional OTA Updates: In contrast to monolithic firmware, Atym enables individual container updates — meaning smaller update sizes, faster delivery, shorter startup time, and lower risk. No reboot is required to replace a running container, reducing risk and downtime in critical applications.

• Centralized Logging and Monitoring: Live container logs are available through Atym the Atym Hub, or can be streamed directly to your own logging infrastructure. No need to write custom loggers, fly blind, or need to drive out to a site for physical access — observability is built in.

• Embedded DevOps: Ocre’s containers are OCI-compliant, and Atym supports modern workflows with CLI tools, APIs, and CI/CD integrations. You can use our container registry or bring your own. Developers can deploy directly through the Atym Hub or integrate and automate with their existing pipelines. Code releases can become more easily repeatable, testable, and scalable.

The Atym Solution

These capabilities are built to meet challenges I’ve seen and felt firsthand — and more importantly, to address a hard reality: even when teams prioritize solving them, they often get bogged down building critical infrastructure from scratch, under tight deadlines, or without the specialized skills needed to get it right. I’ve watched — and been part of — efforts that fizzle, get sidelined, or are ultimately cut in order to get a product shipped on time.

To avoid reinventing the wheel, many teams understandably turn to integrated IoT platforms that promise to handle everything — connectivity, firmware updates, security, cloud integration. These can work well for simple use cases. But in organizations with diverse product portfolios, evolving stakeholder requirements, and strict regulatory or security constraints, that “all-in-one” model often starts to break down. Teams find themselves constrained by platform assumptions, unable to scale flexibly, and back to stitching together their own solutions.

We’re taking a different approach. The WebAssembly ecosystem has matured significantly over the last decade. Containers are a proven standard in cloud environments. And now, with the right abstractions, these technologies can bring modularity, portability, and reliability to the embedded world — without placing a third party in your data path or forcing you into an all-or-nothing platform.

It’s refreshing to see Atym’s approach grounded in open source and shaped by the lived experience of a team that’s wrestled with these problems before — and is committed to solving them the right way.

Embracing the Future of Embedded Software

Looking back at my journey, it’s probably easy to see why joining Atym was the right next step for me. I’ve lived the problems we are solving, and spent time helping others through them. With that as a backdrop, I’m very much looking forward to showing others the opportunity for the future that Atym offers and help customers redefine their embedded development practices by injecting the best of DevOps and modern runtime technology into them.

Broader industry trends reinforce this direction as well. The IoT and edge computing landscape is growing more sophisticated every day, with devices needing frequent updates, running more complex applications like ML at the edge, and adhering to increasingly stringent security regulations. Atym offers a new approach with containers to an embedded development path that hasn’t evolved significantly in decades.

Atym is at the forefront of applying that vision to the edge. By combining the open-source Ocre runtime with our comprehensive set of DevOps-focused infrastructure, Atym provides a step change for the embedded industry: development that is hardware-agnostic, secure, and as easy and modern as deploying containers to the cloud. I couldn’t be more excited to be a part of the journey!