Arduino changed who gets to build hardware. Before it, shipping anything on a microcontroller meant datasheets, vendor toolchains, register-level C, and a programmer you had to buy. Arduino collapsed all of it into three steps: plug in, write a few lines, upload. It didn't make microcontrollers more powerful. It made them accessible, and a whole generation of hardware exists because that one barrier dropped.
Embedded Linux never got that moment.
The silicon kept getting more capable. Jetson-class compute. Multi-core i.MX. Robots, edge AI, and infrastructure running real workloads in the field. But the way you build for that hardware stayed stuck in the before times. You stand up a build system before you write a line of application code. You hand-assemble a board support package per target, then maintain it forever. You solve reproducibility, updates, and security yourself, from scratch, on every project. And you watch the unit in the field drift from the one on your bench.
The hardware leapt a decade. The developer experience barely moved.
Every embedded team pays the same tax. Rebuild the build system, the OTA pipeline, fleet management, remote access, and the security toolchain from scratch, on every new product. Months of work, and none of it portable.
The trap is that both roads are dead ends. The familiar path of Ubuntu, containers, and a mutable rootfs is fast to prototype and reckless to ship: no reproducibility, no signed updates, configuration drift on every device. The rigorous path of Yocto can ship, but only by becoming your own OS vendor. That means a dedicated build team, twelve to eighteen months of integration, seven-figure budgets, and every application developer blocked behind a slow BSP build. Containers don't rescue you either. They abstract the app and leave the whole operating system underneath still yours to own.
So the operating system, the part nobody set out to build, becomes the critical path to ship. The layer underneath everything becomes the thing everything waits on.
This was always a hard problem. What makes it urgent is what's happening above it.
Physical AI has arrived, and not gradually. The silicon is ready and the models are shipping. Humanoids from Figure and Tesla are entering mass production, and Hyundai alone is targeting tens of thousands of units by 2028. Robotics drew a record $14 billion in venture funding last year. The category is real, it's funded, and it's moving fast.
RELEASE NOTESDive deeper into everything included in 1.0 in the complete release changelog. Read here →
And here is the pattern that should concern anyone building in it: every platform shift creates an infrastructure winner. The cloud had one. Mobile had one. Physical AI does not have one yet. The intelligence is racing ahead while the foundation it runs on is still assembled by hand, one board and one build server at a time.
The compliance floor is rising underneath all of it. The EU Cyber Resilience Act puts direct obligations on the OS layer in 2027, and with thousands of Linux CVEs surfacing every year, freezing your fleet isn't caution. It's a countdown.
These aren't blinking LEDs anymore. They're robots, medical devices, and infrastructure that doesn't get to fail. The tools we use to build these systems have to be as capable as the systems themselves. Today, they finally are.
Avocado OS is an immutable, composable embedded Linux runtime. You describe your entire system in one declarative file, and three commands, install, build, and provision, take you from that config to a signed, immutable image running on real hardware. You ship the exact image you tested, bit for bit, without ever standing up an OS team.
Open like Linux. Production-grade like a custom Yocto build. Managed like neither.
Avocado 1.0 is where that becomes real for any team, on any laptop. Three announcements anchor the release, and each one gets its own deep dive.
Compose your OS, program real hardware from your Mac, and let a coding agent do the heavy lifting. In the time it takes a cold Yocto build to get a third of the way done, Avocado Desktop takes you from an empty project to a secure, immutable image running on the board in front of you. And because we ship an MCP server, an agent drives the platform in plain language, editing your config rather than your device, so what you ship stays reproducible and version-controlled. This is developer velocity, and it's the piece you feel first.
Available now on Mac OS X, Windows and Linux support coming soon.
Read the Avocado Desktop and MCP deep dive →
A board change should be a config change, not a re-platform. Avocado carries one application across 20+ silicon targets, from Raspberry Pi to i.MX to the full Jetson line, because we pre-build the world of packages per architecture. Move from a dev kit to production silicon, or from one vendor to the next when supply shifts, by changing a line in your config. And you never trade portability for control: bring your own kernel, device trees, and bootloader when you need them.
Learn how hardware portability works with Avocado OS →
Secure boot, dm-verity, LUKS2, signed atomic updates with rollback, and an SBOM straight out of the build. Not a hardening phase bolted on before ship, but properties of the runtime from the first image. Security is a property, not a phase. And the support half of that sentence matters just as much. We carry the OS layer with you, with patched feeds, a real CVE cadence, and long-term support, so a kernel CVE at 2 a.m. is not solely your team's emergency.
Check out our security and support deep dive →
The features are real, and I'm proud of them. But the release is the smaller story.
The larger one is this: the future of embedded systems cannot depend on tribal knowledge, bespoke infrastructure teams, and multi-day build cycles. The products that teams are building right now are too sophisticated, and moving too fast, to be held back by the layer beneath them. The software foundation either evolves with them, or it becomes the ceiling on everything built on top.
When that layer becomes solved infrastructure instead of a mountain you climb on every project, the whole shape of a company changes. Your engineers go back to the work you hired them for, the application, the thing that actually differentiates you. The OS stops being the critical path. The hardware decision stops being a one-way door. The security review stops being where deals go to stall.
You didn't start your company to maintain Linux infrastructure. You started it to build something that works in the physical world. We exist so you can get back to that.
Embedded Linux has been waiting a long time for its Arduino moment. With Avocado 1.0, it's here.
Read the full press release or start building today with a free developer account.
-Bill