nomicon VS Theseus

If you are interested in learning more about unsafe rust, read the nomicon.

Have you read the nomicon? I'm not sure it fits "in between," but it's definitely not on the "BNF and little explanation" spectrum of things. But if you're coming from years of C or C++ and are totally cool with raw pointers and just want to do stuff with them, then I'd probably point you to the nomicon.

The Nomicon for learning the dark arts of unsafe rust 😳

Also rust book https://doc.rust-lang.org/book/ and Rustonomicon https://doc.rust-lang.org/nomicon/ should be enough

Because of this you should really read the Rustonomicon before you go anywhere near unsafe Rust: a lot of things can go very wrong very quickly.

You should read The Rustonomicon before you use unsafe since it's essentially the unsafe guidelines and covers much more than I can here

Rust doesn't have similar obscure details? May I interest you with the Rustonomicon?

For more details on this kind of thing, you might be interested in the Rustonomicon, which is the goto guide for the details of writing unsafe Rust code.

The "Rustonomicon" is a book about unsafe code in Rust: https://doc.rust-lang.org/nomicon/

Getting into unsafe Rust is generally more for intermediate to advanced users, but the Rustonomicon has good information on how to do it safely: https://doc.rust-lang.org/nomicon/

Not to rain on your parade, but you've essentially just described Theseus OS.

Operating System: Theseus, Redox

Erlang is a bytecode VM, so "compiled" for sure, and is pretty much the pioneer of hot reloading.

Plenty of Lisps and Schemes are compiled (though often to bytecode) and can typically dynamically replace parts of the program.

I think ability to hot upgrade seamlessly more a statement of "how much of the data structure shape is carried at runtime" / "how likely it is old and new API data structures happen to interoperate", and how likely it is that one can convert old runtime state to new runtime state. And that one can be seen as a trade-off; close to the metal control over memory layout is a performance gain, but in practice trades off this kind of flexibility (in theory you could make it work, but it's probably a lot of work).

https://www.theseus-os.com/ is an experimental kernel that can restart/reload/upgrade Rust components at ELF library boundaries. (State internal to a component has to be discarded unless you program a converter. Then again most JS web development hot reload discards internal state of a component.)

DESCRIPTION: As an OS developer, you will independently lead a major open-source development project within Theseus OS.Theseus OS is a novel operating system written from scratch entirely in Rust, with the objective of realizing next-generation safety and efficiency guarantees for workloads in a variety of execution environments. Theseus's goals span the gamut from supporting cutting-edge exploratory research topics to more practical concerns of achieving legacy compatibility and usability.Lately, our focus is on deep support for WebAssembly (WASM) interfaces and runtimes, universal cross-platform device drivers, and porting Theseus to additional architectures (e.g., ARM, RISC-V).

One of the best tutorials i've come across is https://os.phil-opp.com/. I myself used it years ago to get a fast start on our system, Theseus OS.

Hi, author of Theseus OS here. Great post, and really close to my heart.

There are OS like Redox, Theseus.

How about no syscalls, and loading ELF blobs? https://github.com/theseus-os/Theseus does language based security with Rust.

Check it out here: https://github.com/theseus-os/Theseus