Software Engineer

We are seeking Software Engineers to contribute at several different layers of our system software stack, which consists of:

• Our own control plane (Omicron) with an HTTP API served by Dropshot

• Our own hypervisor (Propolis)

• Our own host operating system (Helios)

• Our own block storage service (Crucible)

• Our own switch control software and routing protocol (Maghemite)

• Our own embedded microcontroller operating system (Hubris)

• Our own web console, CLI, and SDK consumers (e.g., oxide.rs, oxide.go)

While working in domains of relatively greater expertise, Software Engineers at Oxide regularly contribute across this stack, developing features, tests, and debugging tools that cross these boundaries. Recent examples of such projects include:

• Debugging and instrumenting our hypervisor and host systems, tracking storage and network latency, to improve our storage system empirically.

• Building a recovery system which converges our host OS, service processors, and control plane, validated via property-based testing.

• Building a routing stack which can be configured by the control plane, then validating it with by creating a Rust crate which can construct VMs to test arbitrary network topologies.

You can learn more about what we’re building and the approach that we’re taking by listening to the team in its own voice via our podcast, Oxide and Friends. Some germane episodes:

• "Crucible: The Oxide Storage Service" on our block storage service

• "Helios" on our host operating system and hypervisor

• "What’s taking so long?!" on our explorations into Rust compile times

• "Rack-scale networking" on our switch software

• "The Network Behind the Network" on the implementation of our management network

• "Holistic Boot" on our BIOS-free approach to booting

• "The Frontend of the Computer" about our web UI — and our API-first approach

• "Virtualizing Time" on the challenges of implementing time in a hypervisor

• "Across the Chasm with Rust" on our use of and experience with Rust

• "The Pragmatism of Hubris" on our embedded microcontroller operating system

• Collaborate with other engaged, friendly, systems-oriented engineers to understand customer use cases and implement or improve aspects of the Oxide platform that correspond to those use cases.

• Focus on one or more layers of the stack — but likely interact with several more

• Write code in Rust (or, if in the guts of Helios, in C); read code primarily written in Rust and C. The code you write will be open source.

• Apply a customer-centric view to the development of new end-to-end features.

• Code without fear, working with the team to create and maintain continuous builds, tests, memory-safe code, debugging tools, a constructive code-review process, and a supportive culture of identifying and fixing bugs.

These responsibilities are just a starting place! We’re a small company, we don’t have rigid roles, and we have a lot to do – we can help you grow wherever your interests take you.

• Have demonstrated expertise and/or deep interest in one or more of our technology areas — and are energized by working across them.

• Have previously worked with Rust or (if interested in working on Helios) have worked with C in the context of operating system internals

• Enjoy work that has a direct connection to its use, be it by a customer or a colleague.

• Appreciate the hard-won thrill of debugging a knotty problem to root cause.

• Believe in fully documenting your ideas.

• Get excited about things and dig really deep into them.

• Enjoy reading the documentation produced by others.

• Are very comfortable at a Unix terminal.

• Don’t mind coworkers getting really excited about decades-old computers.

• Learn enough about our technologies to know where your interests lie.

• Learn enough about our engineering approach to know that it fits your working style.

• Listen to "Hiring Processes with Gergely Orosz" to familiarize yourself with the Oxide hiring process.