cloudparts

Oxide Computer Company

The company behind the Oxide Cloud Computer, a rack whose boards, firmware, operating system, hypervisor, storage, network and control plane it designed together and publishes as open source.

7 products in this catalogWebsite

What it is

Oxide sells one product: a whole rack that behaves like a private public cloud. A typical on-premises cloud is assembled from servers, switches, storage and a hypervisor bought from different vendors. Oxide, founded in 2019 and based in Emeryville, California, instead designed every layer of the rack itself so the pieces are built for each other: the compute sleds, the Sidecar switches and power shelves, the firmware on each board’s service processor (Hubris), the host operating system (Helios), the hypervisor (bhyve with Oxide’s Propolis), block storage (Crucible), virtual networking (OPTE) and the control plane (Omicron).

Seen from the bottom up, every board has a service processor and a hardware root of trust in place of a traditional BMC, reachable only over a separate management network inside the rack. Each sled’s host CPU boots Helios straight from flash, with no UEFI BIOS. On every sled a sled agent starts VMs, each one a Propolis process in its own illumos zone, while the sled’s SSDs serve Crucible storage and OPTE implements the VPC network in the kernel. The control plane’s services (Nexus, CockroachDB, ClickHouse, Oximeter and DNS) run as zones spread over the sleds, and the two sleds wired to the switches also run the switch software, Dendrite, and the gateway to the service processors.

One API ties it together. Nexus serves the public API for users and operators, and the web console, the oxide CLI, the SDKs and the Terraform provider are all clients of it. Inside the rack the same rule holds: Oxide’s services are written in Rust and talk HTTP through APIs built with Dropshot, which generates an OpenAPI description from the code. Almost all of it is open source, mostly under the Mozilla Public License 2.0; Oxide does not sell a closed edition.

Its products in this catalog

In depth

How the pieces meet in one rack#

One API request and one running VM. The top band is the control plane, which can run on any sled; the middle box is the sled hosting the VM; the disk’s three copies live on three other sleds, and its packets leave through a rack switch.

Live model
What you’re watchingAPI calls reach Nexus, which records each change in CockroachDB before answering, then hands work to the sled agent that starts the VM’s Propolis. The VM’s disk writes go through Crucible’s Upstairs, which encrypts each block and sends it to three Downstairs on three other sleds, all of which acknowledge. Its network packets go through OPTE’s firewall and NAT, then the Sidecar switch, to your network.

Which part does which job#

Every layer of the rack, from the board firmware up, with the generic idea it implements. Gimlet and Cosmo are the first and second generations of compute sled; Sidecar is the switch.

JobOxide partGeneric ideaWhere it runs
ComputeCompute sled (Gimlet, Cosmo)A server: one AMD EPYC CPU, up to 1.5 TiB of memory, 10 NVMe bays, 2 × 100 GbEUp to 32 first-generation or 24 second-generation sleds per rack
Board managementService processor running HubrisReplaces the BMC: thermal control, host power, serial console, some firmware updatesA microcontroller on every sled, switch and power shelf controller
Firmware trustRoot of trust running HubrisHardware root of trust that checks its own firmware and anchors encryption at restBeside every service processor
Host bootphbl (Pico Host Boot Loader)A boot loader instead of a UEFI BIOSThe host CPU, loaded from flash by AMD’s platform security processor
Host OSHeliosAn illumos distribution with zones, ZFS and DTraceThe host CPU of every sled
Hypervisorbhyve and PropolisKernel hypervisor plus a Rust virtual machine monitorOne Propolis zone per VM
Control plane APINexus (part of Omicron)Stateless API and orchestration servers, with sagas and background reconcilersZones on any sled, as many as needed
Per-sled agentSled agent (part of Omicron)Node agent that creates VMs, disks and network portsEvery sled
Control plane databaseCockroachDBDistributed SQL, the single source of truth for configurationZones on several sleds
MetricsOximeter and ClickHouseMetrics collector and columnar time series storeZones on several sleds
Block storageCrucibleNetwork block storage, encrypted and mirrored 3 waysUpstairs inside Propolis; Downstairs on each sled’s SSDs
Virtual networkOPTEVPC data plane: firewall, routing, NAT, Geneve encapsulationillumos kernel module on every sled
Rack switchSidecar, driven by DendriteProgrammable switch (Intel Tofino 2, P4) and its control softwareTwo per rack; Dendrite runs on the sled attached to each over PCIe
RoutingMaghemiteDelay-driven multipath inside the rack; BGP, static or OSPF to your networkSleds and switches
Board gatewayManagement Gateway Service (MGS)Bridge from the control plane to every service processorThe two switch-attached sleds
Service APIsDropshotRust REST framework that generates OpenAPI from codeInside Nexus, sled agents, Propolis and other services
User toolsWeb console, oxide CLI, SDKs (Rust, Go, TypeScript), Terraform providerClients of the public APIYour browser and machines
Setup and supportWicketText UI over the technician ports, used before networking is configuredThe two switch-attached sleds

Below the host: service processors, roots of trust and Hubris#

A conventional server has a baseboard management controller (BMC), a small second computer for remote power control and monitoring. Oxide left it out. Every sled, Sidecar switch and power shelf controller carries a service processor (SP), always paired with a hardware root of trust (RoT). On a sled the SP runs thermal control, powers the host on and off, exposes the host’s serial console and updates some device software. The SPs sit on a physically separate management network in the backplane, wired to a dedicated management switch in each Sidecar. The Management Gateway Service, on the sled attached to each switch, carries requests from Nexus and from the Wicket technician UI onto that network, and its traffic never crosses the data network or leaves the rack.

SPs and RoTs run Hubris, an operating system for microcontrollers that Oxide wrote in Rust after existing embedded systems kept being pushed out of their design centers. Cliff Biffle sketched it in early 2020. It is a memory-protected microkernel with a synchronous task model, and every task a board will ever run is fixed at build time, so the build produces a single image that can be attested, and a faulted task can always be restarted because its resources are reserved. Hubris and its debugger, Humility, were open-sourced in November 2021, and the repository has an application for each board: the Gimlet and Cosmo sleds, Sidecar, the power shelf controller and the root of trust.

The RoT checks that its own firmware is genuine and unmodified, and keys for encryption at rest are built on it. When a rack powers on, the sled agents must first form a trust quorum, which verifies the rack secret, before any sled can decrypt its local storage; only then do time sync, internal DNS, CockroachDB and Nexus start, in that order. On the host side Oxide also dropped the UEFI firmware stack: AMD’s platform security processor loads Oxide’s phbl loader from flash, which unpacks Helios and jumps straight into its kernel.

One API, from Nexus to your terminal#

Each silo, the rack’s unit of tenancy, gets its own console and API endpoint under a DNS name delegated to the rack, such as engineering.sys.example.com. Behind every endpoint is Nexus, and the public API reference is generated from the OpenAPI document that is itself generated from Nexus’s code. Oxide’s CLI and Rust SDK are generated from that document with its Progenitor tool, the Terraform provider is built on the Go SDK, and there is a TypeScript SDK as well. The console uses the same public API, so anything a user can click is also scriptable. The docs warn that the SDKs are still under development and may break between releases.

The same discipline applies inside. Nexus, the sled agents, Propolis and most other services expose Dropshot APIs with generated OpenAPI documents, which Oxide uses to catch breaking changes between components. That matters because a rack is never updated atomically: during an update, sleds run different software versions side by side, so only compatible combinations may be deployed. The exceptions are a few services with custom TCP protocols, such as Crucible’s data path and the trust quorum, which handle compatibility themselves.

Where it strains#

It is all or nothing. You buy a whole rack with fixed hardware (one AMD CPU per sled, Oxide’s switches and power shelves), and as of release v23 it must be installed and configured under the guidance of Oxide technicians. You can’t slot your own servers or switches into it. Each rack is its own pool: the docs list combining several racks into a single pool of infrastructure as a roadmap priority that is not yet available.

The software is young, and each release lists known issues. Release v23’s include a limit of 1,024 NAT entries in the system before new instances can’t be created, and instances that can become unreachable on a sled that loses contact with the switches until a reboot. Updates restart sleds, and running instances on a restarted sled go to the failed state, so sensitive guests should be shut down first.

Open source here means open to read, not a community project. Omicron’s README says Oxide is focused on its own goals and can’t help outside contributors, many of the design documents it cites are internal RFDs, and some of the Helios build, such as AMD CPU firmware and Chelsio NIC firmware, is not yet public. And supply has been the limit lately: in October 2026 Oxide said it had scaled manufacturing capacity 20 times over twelve months and demand still exceeded it.

Where it came from2019–2026

Bryan Cantrill, Steve Tuck and Jess Frazelle announced Oxide Computer Company in December 2019, with seed funding from Eclipse Ventures. Cantrill’s announcement traced the idea to years of running a cloud on PC-era servers, where the worst problems came from “the deepest bowels of the stack”, hardware and firmware working against the system software, while the hyperscalers kept their better rack-level designs to themselves. The name nodded to the earth’s crust, to silicon, which occurs in nature as an oxide, and to Rust, the language they expected to use heavily; it can also be written in hex as 0x1de.

The next years went into building every layer. In early 2020 Cliff Biffle began Hubris for the service processors; by mid-2021 Oxide had settled on illumos and bhyve for the host and CockroachDB for the control plane database, and was writing its own storage and networking. Investors were skeptical: more than one venture capitalist told the founders they believed the team could build it but doubted there was a market. The first system software release, v1.0.0, is dated July 2023, and Oxide announced general availability of its “cloud computer” on 26 October 2023, with all of its software open source.

Having raised $89M in its first six years, Oxide raised a $100M Series B led by USIT in July 2025, a $200M Series C from existing investors in February 2026, and a $445M Series D led by Eclipse in October 2026, joined by new investors including AMD Ventures. By then it had become profitable, paying income tax on ordinary operations in the spring of 2026, and it said the money was mainly to buy components and expand manufacturing to work through a large order backlog.

Why it’s built this way

Co-design hardware and software, rack-scale
Cantrill’s founding belief was that hardware and software should each be built with the other in mind; at rack scale that let Oxide remove the BMC and UEFI BIOS, build its own switch and cable everything through a backplane.
Rust from firmware to control plane
The founders expected Rust to play a substantial role from the start; Hubris, Propolis, Crucible, OPTE, Dropshot and Omicron are all written in it, and RFD 26 weighed how well each OS candidate would accept Rust code.
All software open, no open core
Oxide sees open source as core to its commercial thesis and says customers need not worry about “hinky open core models or relicensing surprises”; that transparency also sped up sales, as new customers often came already knowing its podcast or documentation.
Raise for independence
Buyers of infrastructure have seen many startups acquired by the incumbents they set out to disrupt. Oxide says its 2026 Series C was raised without needing the money, to remove capital risk and assure customers of its survival and independence.

Timeline

  1. 2019

    Founded by Bryan Cantrill, Steve Tuck and Jess Frazelle; seed round led by Eclipse (announced December)

  2. 2021

    Hubris and Humility open-sourced (November 30)

  3. 2023

    First system release v1.0.0 (July); general availability announced (October 26)

  4. 2024

    Helios, the host OS, open-sourced (January)

  5. 2025

    $100M Series B led by USIT (July)

  6. 2026

    $200M Series C (February); profitable; $445M Series D led by Eclipse with AMD Ventures (October 9)

Sources · facts checked 2026-10-13

Improve this page on GitHub