Operating systems

I love using macOS as my personal OS.

And I like NixOS and it's nix package manager.

MIT OS Engineering (with code) & Making a RISC-V Operating System using Rust courses are great. Many more nice resources can be found here.

Interesting OSes

• MirageOS - Library operating system that constructs unikernels. (Docs) (Docs code) (mirage-solo5) (The road ahead for MirageOS in 2021) (MirageOS 4.0) (HN) (Examples of simple MirageOS apps)
• QubesOS - Reasonably secure operating system. (Lobsters)
• Plan 9 (Plan 9 C Compiler for RISC-V) (Talk)
• Fuchsia
• DahliaOS - Modern, secure, lightweight and responsive operating system, combining the best of GNU/Linux and Fuchsia OS. (GitHub) (HN) (Pangolin Desktop UI) (ISO releases)
• Redox - Unix-like Operating System written in Rust. (Web) (Kernel Code)
• Toddler - Well-designed usable and portable microkernel OS.
• OS67 - Unix-like toy kernel.
• SerenityOS - Graphical Unix-like operating system for x86 computers. (Web) (Year 3 in review) (HN) (HN) (Interview with Creator) (HN)
• Resea - Microkernel-based hackable operating system. (Implementing Resea GUI)
• Rux - Hobbyist microkernel written in Rust, featuring a capability-based system similar to seL4.
• redshirt - Experiment to build some kind of operating-system-like environment where executables are all in WASM and are loaded from an IPFS-like decentralized network.
• Spectrum OS - Declarative, reproducible, compartmentalized Linux. (Developer manual) (Discussions) (HN)
• mikado - RISC-V Experimental OS.
• mkernel - Minimalist kernel which prints "my first kernel" on the screen and then hangs. (HN)
• Barebones - Barebones multiboot kernel for beginners.
• xv6 - Re-implementation of Dennis Ritchie's and Ken Thompson's simple, Unix-like teaching operating system. (PDF) (HN) (HN) (Lobsters) (xv6 explained) (Course) (HN)
• xv6 for RISC-V
• Orange Slice - Research kernel and hypervisor attempting to get fully deterministic emulation with minimum performance cost.
• Cloud Hypervisor - Open source Virtual Machine Monitor (VMM) that runs on top of KVM.
• RancherOS - Tiny Linux distro that runs the entire OS as Docker containers.
• Bottlerocket OS - Free and open-source Linux-based operating system meant for hosting containers.
• XNU kernel - Part of the Darwin operating system for use in macOS and iOS operating systems.
• Haiku - Open-source operating system that specifically targets personal computing. (HN) (Haiku Community)
• Pebble - Microkernel and userspace written in Rust, with first-class message passing.
• seL4 microkernel (Article) (HN) (Web)
• Barebones amd64 kernel built using 9front
• RustyHermit - Rust-based, lightweight unikernel.
• Distaff - Zero-knowledge virtual machine written in Rust.
• zCore - Reimplement Zircon microkernel in Rust.
• 9front (Lobsters)
• lilith - POSIX-like x86-64 kernel and userspace written in Crystal.
• Genode - Operating System Framework.
• Shrine - TempleOS distro for heretics.
• Subgraph OS - Desktop computing and communications platform that is designed to be resistant to network-borne exploit and malware attacks. (Handbook)
• Mezzano - Operating system written in Common Lisp. (HN)
• Collapse OS - Bootstrap post-collapse technology. (HN) (Web)
• LegoOS - Disseminated, Distributed OS for Hardware Resource Disaggregation.
• CuBitOS - General-purpose, formally-verified, 64-bit operating system in SPARK/Ada for x86-64.
• Demikernel - Library operating system architecture designed for use with kernel-bypass I/O devices.
• Drone - Embedded Operating System for writing real-time applications in Rust. (drone-core) (CLI)
• Manticore - Research operating system, written in Rust. (Web)
• CyanOS - x86 monolithic kernel operating system, coded in C++ 17 and few lines of x86 Assembly.
• ChaiOS - Modular multi-platform hobby OS. Hybrid kernel, largely monolithic. Kernel C library is dynamically linked.
• Tails - Portable operating system that protects against surveillance and censorship. (Intro)
• EmuTOS - Free operating system for Atari ST computers, and more. (Web)
• HalideOS - Experimental operating system written entirely from scratch. It supports a basic shell with some commands including a command line calculator.
• Biscuit - Monolithic, POSIX-subset operating system kernel in Go. (HN) (Code)
• illumos - Unix operating system which provides next-generation features for downstream distributions, including advanced system debugging, next generation filesystem, networking, and virtualization options. (Rise and Development of illumos) (Full disk space on an illumos VM)
• Managarm - Pragmatic microkernel-based OS with fully asynchronous I/O. (Fully Asynchronous OS Based on Modern C++ - Alexander Grinten (2020))
• EggOS - Go unikernel running on x86 bare metal. (HN)
• KnightOS - Third-party operating system for TI calculators.
• eduOS-rs - Teaching operating system written in Rust. (Web)
• Stupid Operating System - Simple, tiny toy OS implemented in Rust.
• Theseus OS - New OS written from scratch in Rust to experiment with novel OS structure, better state management, and how to shift OS responsibilities like resource management into the compiler. (HN)
• TempleOS - Talk to God on up to 64 cores. (Web) (TempleOS on real hardware)
• CactusOS - Simple operating system that is aimed to not be anything like linux.
• Zephyr - New generation, scalable, optimized, secure RTOS for multiple hardware architectures. (Docs)
• Cosmos - Operating system "construction kit". Build your own OS using managed languages such as C#, VB.NET, and more. (Web)
• MollenOS - Modern operating system that is built with focus on abstraction and a modular design.
• Azure RTOS ThreadX - Advanced real-time operating system (RTOS) is designed specifically for deeply embedded applications.
• HelenOS - Portable microkernel-based multiserver operating system written from scratch. (Web)
• Pure Rust x86_64 bootloader and kernel
• bootloader - Experimental x86 bootloader written in Rust and inline assembly.
• Cyjon - Simple, clean, multi-tasking operating system written in pure assembly language for 64-bit processors from the AMD64 family.
• Contiki - Open source operating system that runs on tiny low-power microcontrollers.
• OSv - Modular unikernel designed to run applications securely on micro-VMs . (Code) (HN) (HN 2)
• Rumprun - Uses rump kernels to provide the Rumprun unikernel. Rumprun works on not only on hypervisors such as KVM and Xen, but also on bare metal.
• Rump Kernels - Enable you to build the software stack you need without forcing you to reinvent the wheels.
• mOS - Unix-like operating system developed from scratch and aims to POSIX compliant.
• pdp7-unix - Project to resurrect Unix on the PDP-7 from a scan of the original assembly code.
• core-os-riscv - xv6-like operating system on RISC-V with multi-core support.
• rCore - Rust version of THU uCore OS. Linux compatible.
• dgOS
• Eltanin - Free, simple, and complete general-purpose operating system.
• skiftOS - Simple, handmade, operating system with a graphical user interface. (Web)
• ChrysaLisp - Parallel OS, with GUI, Terminal, OO Assembler, Class libraries, C-Script compiler, Lisp interpreter and more. (HN)
• Pluto - x86 kernel written in Zig.
• LeOS Kernel - Kernel project for operating system for ARM 64bit (AArch64) written in Rust. (Web)
• RustyHermit - Rust-based, lightweight unikernel. (Article)
• Jehanne - Simple operating system. (Web)
• Mimosa - Operating system consists of a minimal kernel built on C++ and Scheme.
• daintree - ARMv8-A operating system, plus a UEFI bootloader, all written in Zig.
• AROS - Lightweight, efficient, and flexible desktop operating system. (HN)
• M3 - Microkernel-based system for heterogeneous manycores.
• vanadinite - RISC-V OS written in Rust.
• Tetris-OS - Operating system that only plays Tetris. (HN) (Video)
• Helium - BSD-based OS project that aims to provide an experience like and some compatibility with macOS.
• Harvey - Distributed operating system. (Web)
• TypOS - Operating system for typechecking processes.
• KolibriOS - Tiny yet incredibly powerful and fast operating system. (HN)
• Kerla - Monolithic kernel in Rust, aiming for Linux ABI compatibility. (HN) (Writing a Linux-compatible kernel in Rust) (HN) (Lobsters)
• rustboot - Tiny 32 bit kernel written in Rust.
• mycelium - Hobby OS in Rust.
• WINIX OS - UNIX-style Operating System for the Waikato RISC Architecture Microprocessor. (HN)
• Aquila OS - Complete Operating System (kernel + system) that is designed to be POSIX compliant and mostly ISA transparent. (Web)
• FuzixOS - Because Small Is Beautiful.
• Mongoose - Small toy OS with no memory protection. (Lobsters)
• Node Replicated Kernel - Research OS kernel for x86-64 (amd64) machines written in rust. (Web) (Book)
• Multics - Pioneering operating system, commonly considered the "progenitor" of the UNIX operating system. (Code)
• Tilck - Tiny Linux-Compatible Kernel.
• Airyx OS - BSD-based OS project that aims to provide an experience like and some compatibility with macOS. (Code) (HN) (Lobsters) (HN)
• Lemon OS - UNIX-like 64-bit operating system written in C++. (Code)
• Pumpkin OS - x64 port/re-implementation of PalmOS. (Lobsters)
• SteinsOS - Operating system featuring non-preemptive single-threaded kernel targeting on armv8.
• EmbassyOS - Graphical operating system for running self-hosted software. (Web)
• Singularity - Microsoft’s Experimental OS. (HN)
• Tupai Kernel
• Deus - Portable kernel written in Rust.
• Funk - Functional kernel written in OCaml.
• liumOS - Toy operating system which supports NVDIMM natively.
• Tofita - All-new kernel for the Greentea OS.
• RISC-V OS in Rust
• RedLeaf - Research operating system developed from scratch in Rust to explore the impact of language safety on operating system organization.
• Kwast - Rust operating system running WebAssembly as userspace in ring 0.
• seL4 Core Platform - Simple operating system for the seL4 microkernel.
• opuntiaOS - Operating system targeting x86 and ARMv7.
• Genesis - Minimal OS written in Jack.
• Nanos - Kernel designed to run only one application in virtualized environment. (HN) (Code)
• ZealOS - Modernized, professional fork of the 64-bit Temple Operating System.
• GrapheneOS - Private and secure mobile OS. (GitHub)
• Florence OS - Renaissance of Operating Systems in Zig.
• BRUTAL - Operating system inspired by brutalist design that combines the ideals of UNIX from the 1970s with modern technology and engineering. (Code)
• Embox - Modular and configurable OS for embedded applications.
• TinyOS - Open source, BSD-licensed operating system designed for low-power wireless devices.
• ZygOS - Achieving Low Tail Latency for Microsecond-scale Networked Tasks.
• IX - Protected dataplane operating system project. (Web)
• Minimal bare metal kernel in Swift
• Cleese - Functioning operating system written almost entirely in Python.
• Tifflin - OS kernel written in rust. Non POSIX.
• Vinix - Modern, fast, and useful operating system in the V programming language.
• Aero - Experimental, Unix-like OS written in Rust.
• MuditaOS - Mobile operating system optimized for E Ink displays.
• Essence - Desktop operating system built from scratch. (HN) (Code)
• Twizzler - Research operating system designed to explore novel programming models for new memory hierarchy designs.
• Phantom - Persistent Operating System. (HN)
• xv7 - Operating System in 100% Pure Rust.
• gokvm - KVM based tiny x86 hypervisor written in pure Go, which can boot Linux.
• rkernel - Minimal x86_64 Rust OS kernel.
• ValkyrieOS - UNIX-like hobby kernel built from scratch in C++20.
• etheryal Kernel - Open Source Rust kernel; Runs WASM and WASI as lightweight containers.
• Stardust Oxide - Rust-based Unikernel. (Reddit)
• Lua RTOS - Real-time operating system designed to run on embedded systems, with minimal requirements of FLASH and RAM memory.
• Inferno - Small operating system for building cross platform distributed systems. (HN)
• Makatea - Qubes-like OS on seL4.
• MOROS - Obscure Rust Operating System.
• House - Haskell Operating System. (Video)
• Zen - Experimental operating system written in Zig.
• My first OS built from scratch
• owlOS - Free UNIX-like operating system written in Rust.
• ScratchOS - Basic operating system written in Scratch3.
• CrabOS - Hobby operating system written in Rust.
• WasabiOS - Web browser + OS in Rust.
• MnemOS - Small operating system in Rust.
• zigux - Attempt to write a (semi) functional OS in Zig.
• Lyre - Effort to write a modern, fast, and useful operating system.

Notes

• Kernels are virtual machines and we write far better systems when we’re aware of what the VM underneath our programs is going to do to translate our use of memory, files, sockets and threads into things that happen in hardware
• We have moved away from a world of shared libraries, filesystems, and UNIX users and permissions into a world of shared-nothing (no shared memory, no shared filesystem), capabilities, new and extremely aggressive attack vectors, and a need to compartmentalize and virtualize at more fundamental layers even if it comes at a performance penalty. You can't retrofit a microkernel-like abstraction on top of Linux. At the same time, a lot of the features you need for a shared multi-user system are basically cruft for modern mobile, single-user systems with little use for shared resources (not saying they're not shared; it's just that you can no longer trust apps installed in the user system so expecting apps to behave nicely is out of the window). The new wave of OSes embraces formal correctness when possible, JIT, garbage-collected application programming languages, tightly-enforced resource boundaries, deny-by-default security models, provably-safe system programming languages (Rust and whatever else will come), immutability and copy-on-write at the cost of filesystem space, and secure memory abstractions for more RAM.
• The modern operating system only implemented 2 metaphors for builders to extend: the file and the application. What if they also implemented “event”, “place”, “person”, “feed” abstractly: letting tools that the user invites into their life collaboratively extend those core connected metaphors as well?

Links

• Introduction to Operating Systems
• Operating Systems: Three Easy Pieces (HN)
• mirageOS - A programming framework for building type-safe, modular systems. (Web Code)
• OS Dev (Tutorials) (Beginner Mistakes)
• Raspberry Pi OS - Learning operating system development using Linux kernel and Raspberry Pi.
• Create OS from scratch
• How to Make a Computer Operating System (Code)
• Plan 9 from User Space - Port of many Plan 9 libraries and programs to Unix.
• Plan 9 from Bell Labs (1995)
• Unik - Unikernel & MicroVM Compilation and Deployment Platform.
• SPDK - Storage Performance Development Kit Provides a set of tools and libraries for writing high performance, scalable, user-mode storage applications.
• Writing an OS in Rust (Code) (Code) (SnakeOS)
• intermezzOS kernel - Hobby operating system, in Rust.
• The intermezzOS book (Code)
• Write your own Operating System (2017)
• Operating Systems: From 0 to 1 - Bootstrap yourself to write an OS from scratch. A book for self-learner. (Code)
• Introducing Mercury OS (2019)
• BootOS - Monolithic operating system in 512 bytes of x86 machine code. (HN)
• Ask HN: Recommended resources to learn the Linux kernel and OS theory? (2019)
• Soso - Simple unix-like operating system written in Nasm assembly and mostly in C.
• swieros - Tiny and fast Unix-ish kernel (based on xv6), compiler, and userland for fun, education, and research.
• A dream of an ultimate OS (1995) (HN)
• Input/Output Subsystem in Singularity Operating System (2011)
• Commute talk: How to start building an OS? (2019)
• Making a RISC-V Operating System using Rust (HN)
• Mu: Sketching out a minimal system programming language (2019) (Lobsters)
• ioping - Simple disk I/0 latency measuring tool.
• Awesome eBPF - BPF, as in Berkeley Packet Filter, is an in-kernel virtual machine running programs passed from user space.
• What are required knowledge in order to build an OS? (2020)
• Krabs - x86 bootloader written in Rust.
• oreboot - Fork of coreboot, with C removed, written in Rust.
• MIT Operating Systems Engineering course using RISC-V (2020)
• fectl - Client/server system that allows its users to monitor and control a number of processes on UNIX-like operating systems.
• 1001 Ways of Implementing a System Call (2019)
• How I Switched To Plan 9 (2019)
• Operating Systems course notes (2013)
• Computer Simulation and History (Code)
• HiddenVM - Use any desktop OS without leaving a trace.
• Programmer's critique of missing structure of operating systems (2020)
• LeetCode OS Questions
• DLS: Functional Foundations for Operating Systems course (2018)
• System Programming course - High-quality, open-source introductory systems programming textbook. (Code)
• Green Threads Explained in Rust (Code) (Reddit)
• Solo5 - Sandboxed execution environment for unikernels.
• Mbox - Lightweight sandboxing mechanism that any user can use without special privileges in commodity operating systems. (Code)
• Awesome Plan9
• Albatross - Orchestrate and manage MirageOS unikernels with Solo5.
• Design of Operating Systems Course (2020) - Using RustOS. (Lab) (Code)
• Little book about OS development (Code)
• Green Threads Explained (HN)
• Fibers under the magnifying glass (2018)
• Notes on the Plan 9 3rd Edition Kernel Source (Lobsters)
• Tutorial - Write a System Call (2016)
• Zub VM - Super-fast, stack-based virtual machine for dynamic languages.
• Genode Operating System Framework Foundations
• The Benefits and Costs of Writing a POSIX Kernel in a High-Level Language (2019)
• Sol — a sunny little virtual machine (2012) (HN)
• OS Development Tutorials
• Bran's Kernel Development Tutorial
• Modern Operating Systems 3rd edition book - 4th edition available too.
• Learning operating system development using Linux kernel and Raspberry Pi (HN)
• The OS Classics (2020)
• Operating System Design: The Xinu Approach
• Operating Systems Design & Implementation MINIX Book
• The Evolution and Future of Hypervisors (2017)
• A Text-Based Desktop Environment (HN) (Code)
• Tales of the Tail: Hardware, OS, and Application-level Sources of Tail Latency
• Beginner resource for OSdev
• SBTCVM (Simple Balanced Ternary Computer Virtual Machine) - Project focused on providing virtual machines based around balanced ternary computers.
• The Cost of Software-Based Memory Management Without Virtual Memory (2020) (Tweet) (HN)
• Writing an x86 bootloader in Rust that can launch vmlinux (HN)
• From Zero to main(): How to Write a Bootloader from Scratch (2020) (HN)
• SerenityOS: The second year (2020) (Lobsters)
• OSDI '21 Call for Papers
• Tibru - Alternative to the nonsense that is the Urbit project. (Lobsters)
• Re-Thinking the Desktop OS (2020) (HN)
• Why mmap is faster than system calls (2019)
• Brief Retrospective on the Sprite Network Operating System
• CS 140: Operating Systems course (2020)
• Tarides - Building functional systems. Commercial support on MirageOS and Irmin.
• Return to Plan 9 (2020)
• Programs are a prison: Rethinking the building blocks of computing interfaces (HN)
• POSIX write() is not atomic in the way that you might like (2020)
• Guided linking: dynamic linking without the costs (2020)
• Awesome Operating System Stuff
• Awesome Operating Systems
• Lobsters: What should a new OS have? (2020)
• 16-Bit Virtual Machine in JavaScript (2020) (Code)
• Jonathan Blow on how an operating system should work (2020)
• Systems with JT - YouTube - YouTube channel doing first impression reviews of amateur operating systems.
• Vulnerable Kext - WIP "Vulnerable by Design" kext for iOS/macOS to play & learn OS kernel exploitation. (Web)
• RVM 1.5 - Type-1.5 hypervisor written in Rust.
• OpenRC - Dependency-based init system that works with the system-provided init program, normally /sbin/init.
• Examples of OS / system limits
• Think OS - Brief Introduction to Operating Systems. (Code)
• Rust OSDev - Operating System Development in Rust. (GitHub)
• Martian Computing Course - Explain and navigate the technical layout of Urbit OS. (Code) (Lobsters)
• Roll your own toy UNIX-clone OS (Known Bugs)
• Awesome Virtualization - Curated list of awesome resources about virtualization.
• pyvmidbg - LibVMI-based GDB server, implemented in Python.
• libmicrovmi - Cross-platform unified interface on top of hypervisor's VMI APIs.
• crosvm - Chrome OS Virtual Machine Monitor.
• DTB parser implementing notes (2021)
• SerenityOS - Writing a full chain exploit (2021)
• I quit my job to focus on SerenityOS full time (2021) (HN) (Lobsters)
• Write Your Own 64-bit Operating System Kernel From Scratch
• Rust VM - Virtual Machine written in Rust to emulate the LC3 computer (Little Computer 3).
• What are Ring 0 and Ring 3 in the context of operating systems?
• User mode VS Kernel mode (2017)
• Domain/OS Design Principles (1989)
• Build your own: linker in Rust (Reddit)
• The Distributed Operating System Void with Kubernetes (2021) (Reddit)
• Microkernel.info - List of active free, open source microkernel projects.
• Fish in a Barrel: an insider’s retrospective of the SOSP’09 multikernel paper (2021)
• QEMU internals (Code) (HN)
• Unikraft: Fast, Specialized Unikernels the Easy Way (2021) (HN)
• Torvalds: Shared libraries are not a good thing in general (2021) (HN)
• Sigil OS post-mortem report (Lobsters)
• Loose ideas for operating systems (2021)
• An Incremental Path Towards a Safer OS Kernel (2021)
• Urbit: The good, the bad, and the insane (2021) (HN) (Lobsters)
• Overview: Capability Computation
• Ask HN: How are you using unikernels? (2021)
• Sudo - Program designed to allow a sysadmin to give limited root privileges to users and log root activity.
• I wrote a linker everyone can understand (2021) (HN)
• The Wrong Way to Switch Operating Systems on Your Server (2021) (Lobsters)
• Programming thought experiment: stuck in a room with a PC without an OS
• x86 Bare Metal Examples - Minimal operating systems, learn x86 system programming. (HN)
• iceoryx - Inter-process-communication middleware that enables virtually limitless data transmissions at constant time. (Web)
• Operating Systems Notes (2010)
• uhyve - Minimal hypervisor for RustyHermit.
• Guix: A most advanced operating system (HN)
• Let's build an LC-3 Virtual Machine (2021)
• The operating system: should there be one? (HN)
• MIT CSAIL Parallel and Distributed Operating Systems Group (GitHub)
• NOVA Microhypervisor - Microhypervisor combines microkernel and hypervisor functionality and provides an extremely small trusted computing base for user applications and virtual machines running on top of it. (Code)
• We need to reinvent our OSes (2021)
• "Static Linking Considered Harmful" Considered Harmful (Lobsters) (HN)
• Synthesis: An efficient implementation of fundamental operating system services (1992) (Review)
• Urbit - Personal server stack built from scratch. It has an identity layer (Azimuth), virtual machine (Vere), and operating system (Arvo). (Web) (HN)
• Plan 9 Desktop Guide (Lobsters) (HN)
• Writing a “bare metal” operating system for Raspberry Pi 4 (Code) (HN)
• OSv Unikernel — Optimizing Guest OS to Run Stateless and Serverless Apps in the Cloud (2021) (HN)
• Bootstrapping a kernel with UEFI using Zig
• xsys - Well-defined system API for abstracting the OS platform.
• pylddwrap - Python 3 wrapper around ldd *nix utility to determine shared libraries of a program.
• Pilot: An Operating System for a Personal Computer (1980) (HN)
• Rust OS comparison - Comparison of operating systems written in Rust.
• OS synchronization techniques resources (2021)
• Signals and Threads | What is an Operating System? (2021)
• A fork() in the road (2019)
• Make It Go Faster! How We Sped Up OS Provisioning On Bare Metal at Scale (2021)
• Why not to whitelist operating system user agents (2021) (HN)
• The Demikernel Datapath OS Architecture for Microsecond-scale Datacenter Systems (2021)
• TinyLFU: A Highly Efficient Cache Admission Policy (2015)
• Comparison of Operating System Complexity (2020) (HN)
• Virtual Machine Showdown: Stack Versus Registers (2005)
• OPS - Build and run nanos unikernels.
• The big idea around unikernels (2021) (HN)
• MicroV - Micro hypervisor for running micro VMs.
• Bootloader exploration
• boxen - Put your network operating systems in a box.
• awesome OS
• The World of Vintage Operating Systems (HN)
• MiniVM - Zero-dependency cross-language runtime on par with LuaJIT and C. (HN)
• What goes into making an OS to be Unix compliant certified? (Lobsters)
• MIT 6.S081 – Operating System Engineering (HN) (Code)
• FlexSC: Flexible System Call Scheduling with Exception-Less System Calls (Summary) (Lobsters)
• What is a Process? (Operating Systems)
• dyld - Dynamic link editor. (Tweet)
• Unikraft - Automated system for building specialized OSes known as unikernels. Unikraft can be configured to be POSIX-compliant. (Code) (kraft - Define, configure, build, and run Unikraft unikernel applications)
• systemfd - Development helper utility for helping with auto reloading for projects supporting systemd socket activation.
• Let's write an OS which can run on RISC-V in Rust from scratch
• MilvusVisor - Thin-hypervisor that runs on aarch64 CPUs.
• State of art for unikernels (HN)
• RSM - Rsms's smol machine — a virtual computer hobby project.
• Osdev Notes
• Bootloader Basics (2022)
• Ask HN: What is the oldest, still supported OS? (2022)
• CS Course: Design and Implementation of Operating Systems (2021)
• Qemantra - Tool for creating and running QEMU Virtual Machines.
• x86-64 VMM for seL4: Security Analysis and Requirements
• OSBuild - Build-Pipelines for Operating System Artifacts. (Web)
• Writing a Simple Operating System – From Scratch (HN)
• PCLSRing: Keeping Process State Modular (HN)
• IPC-Bench - Benchmarks for Inter-Process-Communication Techniques.
• libtree - ldd as a tree.
• Hivemind - Process manager for Procfile-based applications. Procfile is a simple format to specify types of processes your application provides.
• Resources to learn OS concepts (2022)
• Dynamic Tracing Guide
• dryad - Almost-parallel, semi-functioning, dynamic linker experiment, written in Rust.
• A Policy-Free System-Call Layer For The Hedron Microhypervisor - Runtime system in Rust for a microkernel that enables unmodified Linux applications. (Reddit)
• System paper reading notes
• sbctl - Secure Boot Manager.
• bootimage - Tool to create bootable disk images from a Rust OS kernel.
• Cannoli - High-performance QEMU memory and instruction tracing.
• netboot.xyz - Your favorite operating systems in one place. A network-based bootable operating system installer based on iPXE. (Code) (HN) (Lobsters) (Reddit)
• State of the Squeak Phone (2022)
• Formalizing a Simple Virtual Machine (2022)
• Little VM Helper - Tool for building and running VMs for development and testing.
• Hello UEFI in Zig - Small amount of code to get started writing an OS or a bare-metal UEFI application in Zig.
• Procursus - New, powerful, cross-compilation OS bootstrap.
• libostree - Operating system and container binary deployment and upgrades.