What does HackerNews think of hubris?

A lightweight, memory-protected, message-passing kernel for deeply embedded systems.

Language: Rust

Is that the same extremely high-quality open-source code that currently has a failing build?

https://github.com/oxidecomputer/hubris

And, that one underscore-delimited folder name in this repo just catches the eye, huh?

https://github.com/oxidecomputer/humility

A lot of questions in there! Taking these in order:

1. We aren't making standalone servers: the Oxide compute sled comes in the Oxide rack. So are not (and do not intend to be) a drop in replacement for extant rack mounted servers.

2. We have taken a fundamentally different approach to firmware, with a true root of trust that can attest to the service processor -- which can turn attest to the system software. This prompts a lot of questions (e.g., who attests to the root of trust?), and there is a LOT to say about this; look for us to talk a lot more about this

3. In stark contrast (sadly) to nearly everyone else in the server space, the firmware we are developing is entirely open source. More details on that can be found in Cliff Biffle's 2021 OSFC talk and the Hubris and Humility repos.[0][1][2]

4. Definitely not vaporware! We are in the process of shipping to our first customers; you can follow our progress in our Oxide and Friends podcast.[3]

[0] https://www.osfc.io/2021/talks/on-hubris-and-humility-develo...

[1] https://github.com/oxidecomputer/hubris

[2] https://github.com/oxidecomputer/humility

[3] https://oxide-and-friends.transistor.fm/

Way out of my depth! However, the stuff I saw the folks from Oxide [1] talk about comes to mind. Hardware stuff with Rust. If you want to look at a specific project, Hubris [2] is a kernel for "deeply-embedded" systems.

[1] https://oxide.computer/blog/building-big-systems-with-remote...

[2] https://github.com/oxidecomputer/hubris

For someone doing related work in the open (and least remarkably in the open), Oxide Computer told some storied about the difficulty of bring up of a new motherboard, and mentioned a lot of gotcha details and hack solutions for managing their AMD chip.

They talked about their bring up sequence, boot chain verification on their motherboard, and designing / creating / verifying their hardware root of trust.

I heard mention of this on a podcast recently, trying to find the reference. I'm pretty sure it was [S3]

- "Tales from the Bringup Lab" https://lnns.co/FBf5oLpyHK3

- or "More Tales from the Bringup Lab" https://lnns.co/LQur_ToJX9m

But I found again these interesting things worth sharing on that search.

- https://oxide.computer/blog/hubris-and-humility, see https://github.com/oxidecomputer/hubris as some of their key enabling software/firmware, custom written—-tradeoffs discussed in podcast.

- Search 1 [S1], Trammell Hudson ep mentioning firmware (chromebook related iirc) https://lnns.co/pystdPm0QvG.

- Search 2 [S2], Security, Cryptography, Whatever podcast episode mentioning Oxide and roots of trust or similar. https://lnns.co/VnyTvdhBiGC

Search links:

[S1]: https://www.listennotes.com/search/?q=oxide+tpm

[S2]: https://www.listennotes.com/search/?q=oxide%20and%20friends%...

[S3]: https://www.listennotes.com/search/?q=oxide%20and%20friends%...

> New C/C++/asm based hobby kernels are started (and abandoned) everyday on /r/osdev. Nowhere near as many in Rust by a wide margin. Instead the Rust community seems to have placed all their bets on an "outside in" rewrite of the Linux kernel in Rust. While I think this may well be great for Linux in the long term, its a little dissapointing that there is not more momentum for "from scratch" projects yet. Even Linux started as "as hobby, not big and professional like GNU". Which leads to my next point ...

I think you may just be not looking where the rust people are posting. All you're really saying is that they aren't on /r/osdev, and frankly I don't find that surprising. Here are some of the more flagship projects

The biggest rust kernel/os project I'm aware of is https://www.redox-os.org/

It's a bit out of date by now, but this is an excellent guide written in rust: https://os.phil-opp.com/minimal-rust-kernel/

On the embedded side, this is a commercial project that actually "matters": https://github.com/oxidecomputer/hubris

This is a uni-kernel that I've heard about quite a few times: https://github.com/hermitcore/rusty-hermit

Naturally there's a bunch more smaller projects, and maybe larger ones that I haven't heard of.

Oh, sorry: "VR" is a "voltage regulator" in this context. You can see our drivers for these parts in Hubris, our all-Rust system that runs on our service processor.[0] All of our drivers are open, but the parts themselves do contain (small) proprietary firmware blobs.

[0] https://github.com/oxidecomputer/hubris

Hubris is a microkernel-ish OS for embedded systems, and has a bunch of documentation about its design:

https://hubris.oxide.computer/reference/

It's all open-source on Github:

https://github.com/oxidecomputer/hubris

(I work at Oxide, mostly using Hubris)

Every (popular) modern operating system sits on decades old foundations written in C that can't just be replaced, so that's not a particularly strong argument.

It's noteworthy that Google is financing the effort to bring Rust to the Linux kernel, that Microsoft is also investing in the language and that there are newer, production usage focused operating systems written in Rust. (eg Hubris [1])

[1] https://github.com/oxidecomputer/hubris

TIL about Hubris, very cool! One could probably also mention the bunch of hypervisors, as they run on the bare metal as well, and maybe Tock, and I'm probably unaware of a bunch. Rust is definitely a hot language when it comes to OS development, which is really great.

I've cloned hybris [0], it seems to have 48k lines of Rust source code. Maybe there are other components that I'm missing. Fuchsia [1] on the other hand had 2.1 million lines of Rust in Dec 2020 [2], and according to tokei has 3.3 million as of now (8b51db9e2b809, March 28 2022), more than it has C++ (2.2 million) and C (366k) combined.

For comparison, a full check out of the rust-lang/rust repo with all the submodules which contains rustc as well as tools like cargo, rustfmt or clippy, and their test suites, contains 2.1 million lines.

But yeah you can come up with several definitions of "serious". Is an OS that an entire company bases its revenues on more serious than a research project that some call as a way to maintain senior developer retention, but may one day replace components of one of the most deployed end user operating systems in the world?

[0]: https://github.com/oxidecomputer/hubris

[1]: https://fuchsia.googlesource.com/fuchsia/

[2]: https://www.reddit.com/r/rust/comments/k9djda/expanding_fuch...

You better go tell https://github.com/oxidecomputer/hubris to pack it up because they can't realistically continue to write their kernel in Rust and that Rust is for web developers now.
In addition to Cliff's talk/blog -- which are absolutely outstanding -- I would recommend listening to the Twitter Space we did on Hubris and Humility last week.[0] It was a really fun conversation, and it also serves as a bit of a B-side for the talk in that it goes into some of the subtler details that we feel are important, but didn't quite rise to the level of the presentation. And of course, be sure to check out the source itself![1][2]

[0] https://www.youtube.com/watch?v=cypmufnPfLw

[1] https://github.com/oxidecomputer/hubris

[2] https://github.com/oxidecomputer/humility

Note: This is not a philosophical article, but rather a transcript of a conference talk concerning a kernel written in rust (https://github.com/oxidecomputer/hubris) and an associated debugger.