This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Please submit interesting posts and projects for the next issue on Zulip or via a PR on GitHub.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Announcing Asterinas 0.18.0
• This Month in Redox - May 2026
  • The latest Redox update covers an EEVDF scheduler, page flipping and plane support in the Intel graphics driver, a COSMIC monitor and XFCE port, and large I/O and RedoxFS performance improvements.
• Zinnia
  • A Unix-like kernel written almost entirely in Rust that boots on real x86_64 hardware and can run Wayland/X11 desktop sessions (Weston, XFCE). Drivers are loaded as modular Rust ELF libraries at boot.
• LearnixOS
  • A book that teaches OS development from scratch in Rust, covering memory allocators, paging, filesystems, and kernel logic.
• Hardware Is Asynchronous. Most of Our Operating Systems Still Aren't.
  • An article arguing that operating systems should treat asynchrony as the default rather than layering it on top of blocking abstractions, drawing on work from CharlotteOS, an experimental modern OS written in Rust.
• Building an AsyncIO executor for the 3DS (pt 1!)
  • Building a from-scratch async I/O executor for the Nintendo 3DS.

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Move std::io::Error into core
  • Makes I/O error handling available in no_std
  • Now the rest of std::io can be moved to core/alloc too, including the Read and Write traits. See the open PR and the tracking issue for details.
• Stabilize int_format_into feature
  • Formats integers into fixed-size buffers with no allocation.
• Stabilize #![feature(box_as_ptr)]
  • Stabilizes Box::as_ptr and Box::as_mut_ptr
  • These methods can be used to create multiple pointers to the same Box that don't invalidate each other.
• staticlib: hide internal symbols
  • A new -Zstaticlib-hide-internal-symbols flag hides non-exported Rust symbols in static libraries, shrinking binaries by 5–12% in non-LTO builds.
• asm! support for the Xtensa architecture
  • Inline assembly for Xtensa (ESP32 and related chips) lands in-tree after years in the esp-rs fork.

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• Feat: IoMmu protocol
• uefi: Add PciRootBridgeIo memory and I/O space access
• uefi: Add PciRootBridgeIo attribute manipulation
• uefi-raw: Add PciRootBridgeIoProtocolAttributes
• uefi: Add integration with time crate
• uefi: Add integration with jiff crate
• uefi: remove deprecated APIs
• uefi-raw: enhance Boolean type and make it more type safe
• uefi-raw: various spec fixes
• uefi: Fix boot::exit signature
• uefi: reject undersized device path nodes
• uefi: various smaller memory map related fixes and improvements
• uefi-raw: format negative time zones correctly
• release: uefi-raw-0.15.0, uefi-0.38.0

Thanks to @JarlEvanson, @mysteriouslyseeing, and @PelleKrab for their contributions!

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

We merged the following PRs this month:

• Rewrite: Add elf library for elf_sections.rs
• various safety and correctness improvements
• Various improvements and fixes
• modernize misc stuff
• elf: remove From impl
• chore: prepare new workspace releases

Thanks to @an-owl for their contribution!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. The following changes landed in early July, but we want to mention them already because they affect users building against recent Rust nightlies:

• Recent Rust nightlies renamed the x86-softfloat target ABI to softfloat. This update adjusts the bootloader's custom targets accordingly, on both the latest release and the v0.9 branch.
  • Change rustc-abi in custom targets from x86-softfloat to softfloat
  • (v0.9) Change rustc-abi in custom targets from x86-softfloat to softfloat
• uefi: bump from 0.20 to 0.38

Thanks to @phip1611 for their contribution!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following changes this month:

• Fix build errors for edk2-stable202605
• Update to sha2-0.11
• release: 0.2.9 with edk2-stable202605-r1

uart_16550

Maintained by @phip1611

Simple yet highly configurable low-level driver for 16550 UART devices, typically known and used as serial ports or COM ports.

We merged the following change this month:

• lib: change signature of Uart16550::config() to be more flexible

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

mkroening/elf-symbols

(Section written by @mkroening)

When developing an OS, you often need some information about the loaded kernel image:

• Where has the loader loaded the kernel to?
• How large is the loaded kernel?
• Where do the text segment and the data segment end?
• How do I get the kernel TLS image?

These questions can be answered by building non-relocatable images, by writing custom linker scripts, or by having a custom loader that provides this information somehow.

But there is another way! In fact, the main ELF linkers that I am aware of (BFD, gold, LLD, mold, and Wild) all have built-in ELF symbols that answer these questions when not using custom linker scripts. Unfortunately, many are poorly documented, so I created the elf-symbols crate that exposes and documents them. All symbols are tested on the aforementioned linkers. The documentation shows when each linker gained support for the respective symbol.

The following symbols are straightforward:

• __executable_start (executable_start()) is the start of the executable.
• _etext (text_end()) is the end of the text segment.
• _edata (data_end()) is the end of the data segment.
• _end (executable_end()) is the end of the executable.

__ehdr_start (elf_header()) is especially interesting. It allows programs to examine themselves by reading their ELF headers (file headers and program headers). This can be used to get TLS image information, for example.

Note that these symbols are ELF specific, though, so they cannot be used when linking to something else, such as a PE32+ UEFI executable.

Examples

println!("Executable start: {:p}", elf_symbols::executable_start());
println!("ELF header:       {:p}", elf_symbols::elf_header());
println!("Text segment end: {:p}", elf_symbols::text_end());
println!("Data segment end: {:p}", elf_symbols::data_end());
println!("Executable end:   {:p}", elf_symbols::executable_end());

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog. These landed in early July, but we mention them here since they keep the code building on the latest Rust nightly:

• Fix target spec: use softfloat instead of x86-softfloat
• Fix blog: the x86-softfloat feature was renamed to softfloat
• Update for new Rust error messages
• Update blog to zola 0.22.1

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way to get in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Please submit interesting posts and projects for the next issue on Zulip or via a PR on GitHub.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Rust for Linux Live with Alice Ryhl and Greg Kroah-Hartman
  • A live Rust Week recording about Rust in the Linux kernel, C/Rust interoperability, kernel driver work, and the day-to-day realities of writing kernel code in Rust.
• Finding the Time Part 2 - Rust Async and the Arm Generic Timer
  • Explores implementing async timers for Armv8-R systems using the Arm Generic Timer, interrupts, and Embassy's embassy-time driver model.
• Building an AsyncIO executor for the 3DS
  • Starts a series on cooperative multitasking for Nintendo 3DS homebrew by building a small Rust executor and connecting async wakeups to platform scheduling constraints.
• Rust x GBA: Setup and Pixels
  • Walks through setting up a nightly Rust project for Game Boy Advance ROM development, including arm-none-eabi tooling, Cargo configuration, core-only code, and pixel output.
• uFerris: A Versatile Learner Board for Rust Embedded Beginners
  • A new open source learner board and board support crate for embedded Rust exercises across Seeed XIAO-compatible MCUs.

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Rust 1.96.0
  • Stabilizes new core::range types and core::assert_matches!/core::debug_assert_matches!.
  • WebAssembly targets now fail on undefined linker symbols by default instead of implicitly treating them as "env" imports.
  • Includes Cargo fixes for CVE-2026-5223 and CVE-2026-5222 for users of third-party registries.
• More std::io pieces move toward core::io
  • Cursor and std::io::util were moved into core::io, continuing the effort to make I/O building blocks available in no_std contexts.
• Proposal to stabilize the Allocator trait
  • A draft PR that proposes stabilizing the Allocator trait together with Global, System, and the *_in constructors (e.g. Box::new_in, Vec::new_in). This would let kernel and no_std code use custom allocators with the standard collections on stable Rust. The design still needs to go through FCP and bake further before it can land.
• Cargo clean -p now respects build.target
  • Makes cargo clean -p behave more predictably for projects that set a default cross-compilation target in Cargo configuration.
• Promote five Thumb-mode bare-metal Arm targets to Tier 2
  • A compiler-team proposal entered final comment period to promote additional thumb*-none-eabi* bare-metal targets.
• Add -Zdead-fn-elimination
  • A compiler-team proposal entered final comment period for a nightly codegen option that skips functions unreachable from exported symbols, which could improve compile time. Improvements on binary size are not expected though since the linker should already eliminate dead functions today.

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers uses to relay information about the hardware to the OS.

We merged the following changes this month:

• Use contribute_arg to handle NoCurrentOp at the top-level
• Logical not only requires one arg
• Move method context to do_execute_method
• Get referenced-package size - unwrap reference in do_size_of
• Allow BufferField -> Integer conversion
• Compare strings and buffers like uACPI
• Update uACPI example tests since some now work
• Directly test a stream of opcodes
• Fix regression in implicit casting from integer -> string

Thanks to @martin-hughes for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• Fix connect_controller to take a list for driver_image.
• AtaPassThru: Make AtaStatusBlock and AtaCommandBlock derive Clone
• various updates (nothing major or critical) + bump MSRV from 1.88 to 1.91
• uefi: move runtime module to directory

Thanks to @seijikun for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• implement DoubleEndedIterator for ranges + implement more iterator methods

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• fix: lazy_static is not needed, keyboard methods are const,
• [Translation] Translated post 8 and 9 into Russian
• Adding Turkish translations of blog posts
• Adjust blog for PR #1477

Thanks to @harsh-98, @TakiMoysha, and @rhotav for their contributions!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way to get in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Please submit interesting posts and projects for the next issue on Zulip or via a PR on GitHub.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• octopos: xv6-based operating system for RISC-V in Rust
  • A Rust port of xv6 that targets RISC-V and runs without the standard library, including process management, Sv39 page tables, VirtIO disk support, and a POSIX-style syscall interface.
• A minimal VMM in Rust with Apple Hypervisor
  • Walks through building a small virtual machine monitor on Apple Silicon macOS using Rust bindings to Apple's Hypervisor framework.
• Rust: Memory safety in kernel space
  • An OS-focused introduction to how Rust's ownership and unsafe boundaries change kernel development.
• Bringing Rust to the Pixel Baseband
  • Google describes adding Rust to Pixel modem firmware, including no_std support for Hickory DNS dependencies, core/alloc integration, allocator and panic handler hooks, and firmware linking details.
• tinyboot v0.4.0 Released -- The API is Stable
  • A minimal Rust bootloader for resource-constrained MCUs. This release adds CH32V00x support, collapses the CH32 crates, stabilizes the wire protocol, and fixes half-duplex UART bugs.
• Using Rust to Build a $1 Handheld Gaming Console
  • A small embedded Rust project on the CH32V003 RISC-V microcontroller, with notes on RAM-constrained rendering and fixed-point math.
• Zero-copy pages in Rust
  • Explores an approach for working with database pages in Rust while avoiding unnecessary copies.
• This Month in Redox - April 2026
  • The Redox project reports updates across the kernel, system libraries, drivers, and userspace.

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Rust 1.95.0
  • Stabilizes cfg_select!, atomic update/try_update methods, and allocator layout helpers such as Layout::{dangling_ptr, repeat, repeat_packed, extend_packed}.
  • Important for custom-target users: stable rustc no longer accepts JSON target specifications. Building core for custom targets still requires nightly-only features.
• Move std::io pieces toward core::io
  • ErrorKind and RawOsError were moved into core::io, continuing the groundwork for more I/O abstractions in no_std contexts.
• Add -Zsanitize=kernel-hwaddress
  • Adds nightly support for the kernel hardware address sanitizer mode used by Linux's CONFIG_KASAN_SW_TAGS.
• Mitigation enforcement RFC
  • An approved RFC for tracking and enforcing target-wide exploit mitigation options such as stack protector settings.
• build-std: always RFC
  • Proposed Cargo configuration for rebuilding standard library crates, part of the ongoing effort to make build-std usable on stable.

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

pvh

Maintained by @mkroening

The pvh crate contains definitions for Xen's x86/HVM direct boot ABI (PVH). PVH is commonly used for direct kernel boot in virtual machine managers (VMMs), such as QEMU, and in VMMs using the linux-loader crate, such as Firecracker and Cloud Hypervisor.

The crate allows kernels to be booted via PVH and helps read the data provided via physical addresses. Its structures can also be used in VMMs or bootloaders to create appropriate start info structures when loading a kernel.

The new repository was created this month and is also available on crates.io.

Thanks to @mkroening for creating the project!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers uses to relay information about the hardware to the OS.

We merged the following changes this month:

• Support multiple tables per test in aml_tester
• Implement Index and Bank fields
• Add support for running the tests from uACPI
• Remove some AML-triggerable panics from library
• Derive Clone, Debug on useful objects
• (minor) Trace the table ID better

Thanks to @martin-hughes for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• uefi: make TimerTrigger more pleasant to use
• uefi-raw: Add SimpleTextInputEx protocol
• uefi: Add InputEx protocol

Thanks to @JarlEvanson for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following change:

• Update to v0.11.15 and add missing x86_64-unknown-uefi target

Thanks to @peppergrayxyz for their contribution!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• insert NOP after STI

linked-list-allocator

Maintained by @phil-opp and @jamesmunns

The linked-list-allocator crate provides a basic no_std allocator that builds a linked list from freed memory blocks and thus needs no additional data structures. We merged the following PR this month:

• fix(alloc_ref): use renamed dangling

Thanks to @sermuns for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

willamhou/hypervisor

(Section written by @willamhou)

An ARM64 Type-1 bare-metal hypervisor written in Rust (no_std). It runs at EL2 and manages guest VMs at EL1, targeting the QEMU virt machine. The project boots Linux 6.12.12 to a BusyBox shell with 4 vCPUs, virtio-blk storage, and virtio-net inter-VM networking.

Key features:

• S-EL2 SPMC: Runs as BL32 in TF-A boot chain, replacing Hafnium. Manages multiple Secure Partitions (SPs) at S-EL1 with per-SP Secure Stage-2 page tables.
• FF-A v1.1: Full proxy implementation including DIRECT_REQ/RESP messaging, memory sharing (MEM_SHARE/LEND/DONATE/RETRIEVE/RELINQUISH/RECLAIM), descriptor fragmentation, PARTITION_INFO_GET, notifications, indirect messaging, and CONSOLE_LOG.
• pKVM integration: Coexists with Android pKVM at NS-EL2 — our SPMC at S-EL2, pKVM at NS-EL2. 35/35 ffa_test.ko tests pass, including SP-to-SP DIRECT_REQ relay and SP-to-SP memory sharing through the real SPMD chain.
• Multi-VM: 2 Linux VMs time-sliced with VMID-tagged TLBs and per-VM Stage-2 page tables.
• SMP: Both 4-vCPU-on-1-pCPU (round-robin scheduler) and 4-vCPU-on-4-pCPU (1:1 affinity) modes.
• SP-to-SP: CallStack cycle detection, recursive dispatch, chain preemption, secure virtual interrupt injection via HCR_EL2.VI.
• 34 test suites with ~457 assertions running on QEMU, plus 20/20 BL33 E2E integration tests.

MohammadMuzamil23/Qunix-Operating-System

(Section suggested by JustSmile)

Qunix is a Unix-like hobby operating system written in Rust. It includes a process model, virtual filesystem layer, memory management with COW fork and demand paging, an ELF loader, and a priority-based preemptive scheduler.

The project recently reached userspace and is making progress on POSIX compatibility. Its initial v0.2.0 release adds 70+ userland utilities, including a shell (qsh), along with blocking pipes, a TTY subsystem, and POSIX-style signal delivery.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way to get in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Please submit interesting posts and projects for the next issue on Zulip or via a PR on GitHub.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Redox OS: Capability-based Security — Namespace and CWD
• Ferrous Systems: "Accessing Hardware in Rust"
  • Compares four Rust hardware abstraction approaches (svd2rust, tock-registers, safe-mmio, derive-mmio) for bare-metal programming.
• How to use storytelling to fit inline assembly into Rust
  • Proposes a "storytelling" approach where inline assembly blocks must correspond to equivalent Rust code, ensuring soundness and allowing compiler optimizations.
• Video: Writing a Linux GPU Kernel Driver in Rust with Daniel Almeida
  • Interview about writing the Tyr GPU kernel driver for Arm Mali hardware in Rust.
• Ariel OS v0.4.0
  • New release of this embedded Rust RTOS adds BLE on ESP32, USB CDC-NCM Ethernet, GNSS sensor support, and stack usage measurement.
• Elfina: Multi-architecture ELF Loader in Rust
  • Educational ELF loader supporting x86 and x86-64 Linux binaries, with mmap and memfd execution modes.
• VectorWare: "Rust threads on the GPU"
  • Maps Rust's std::thread API to GPU warps, enabling familiar concurrent Rust code to compile and run on GPU hardware.

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• ACP: Introduce alloc::io
  • Approved proposal to move OS-independent parts of std::io to alloc, making IO traits available in no_std + alloc environments. The implementation PR is in progress.
• Make atomic primitives type aliases of Atomic<T>
  • Refactors all atomic types (AtomicI32, AtomicBool, etc.) into type aliases of a generic Atomic<T>.
  • Only types that implement the sealed AtomicPrimitive trait can be used with Atomic<T>
• Implement MaybeDangling compiler support
  • Adds compiler-level support for the MaybeDangling wrapper type, which relaxes aliasing assumptions on references. Important for unsafe code dealing with self-referential structures and raw memory.
• Constify Vec::{into, from}_raw_parts{_in|_alloc}
  • Makes Vec raw parts methods usable in const contexts.
• Target specs: stricter checks for LLVM ABI values, and correlate with cfg(target_abi)
  • Tightens ABI validation in target specs. Note: out-of-tree JSON custom targets may need updating.
• -Zbranch-protection is a target modifier
  • Makes -Zbranch-protection a target modifier, enforcing consistent application across the entire crate graph. Important for AArch64 kernel security (PAC/BTI).
• Defer codegen for the VaList Drop impl to actual uses
  • Allows compiling libcore with codegen backends that don't implement VaList (like Cranelift). Unblocks alternative backends for bare-metal work.

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uart_16550

Maintained by @phip1611

Simple yet highly configurable low-level driver for 16550 UART devices, typically known and used as serial ports or COM ports.

We've just released v0.5.0 - a complete rewrite and fresh start of the crate, implemented by @phip1611. The main motivation is to make the crate fit for working on real hardware, clean up technical debt, and streamline the code paths for x86 port I/O and MMIO. @phip1611 is also taking over maintenance of the crate, thanks a lot!

More info:

• https://github.com/rust-osdev/uart_16550/releases/tag/v0.5.0
• https://docs.rs/uart_16550/0.5.0/uart_16550/
• https://github.com/rust-osdev/uart_16550/pull/41

Special Thanks to Philipp Oppermann (@phil-opp) and Martin Kröning (@mkroening) for their very valuable review on the new crate!

After the rewrite, we merged the following changes this month:

• feat: implement embedded-io traits
• Rename byte transfer functions and update IO trait implementations
• Enhance MmioAddress safety and fix AArch64 instruction emission
• Improve documentation examples and streamline architecture support
• Add API test and improve memory safety in MMIO constructors

Thanks to @mkroening for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• add join on Path
• uefi: serial: add read_exact() and write_exact() + fix core::fmt::Write for Serial
• runtime: add CStr16::from_bytes_with_nul for UCS-2 strings in UEFI Variables
• Replace a couple as casts with ptr::from_ref
• release: uefi-raw-0.14.0, uefi-0.37

Thanks to @the-shank for their contributions!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS.

We merged the following changes this month:

• Improve handling of top-level names with new ResolveBehaviour system
• For discussion: A way of improving regression/integration testing for ASL snippets
• Use correct offset for PCI I/O
• Allow aml_tester to continue after an interpreter panic
• Apply search rules to lookups

Thanks to @martin-hughes for their contributions!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following changes this month:

• feat: IOMMU support via edk2-platforms and IntelVTdDxe
• Rename build-edk2 to xtask
• Add build-edk2 action to xtask CLI
• xtask: Add update-sources action
• release: 0.2.8
• Update to 2024 edition

Thanks to @PelleKrab for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following changes:

• don't use BPB_TotSec16 to determine FAT type
• speed up BIOS bootloader

Thanks to @ic3w1ne for their contribution!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• don't enable abi_x86_interrupt if not needed

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• [Translation] translated post 10 into russian

Thanks to @TakiMoysha for their contribution!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Linux 7.0 Officially Concluding The Rust Experiment
  • Rust is now formally accepted as a permanent part of the Linux kernel, shipping in production across multiple distributions and millions of Android devices.
• The future for Tyr
  • Progress on Tyr, a Rust GPU driver for Arm Mali hardware. The DRM subsystem is reportedly "about a year away" from requiring new drivers to be written in Rust.
• Microsoft LiteBox
  • A Rust library OS supporting kernel- and user-mode execution, with sandboxing for running unmodified Linux programs on Windows and SEV SNP.
• This Month in Redox - January 2026
  • Redox got Cargo and rustc compiling natively and made progress on capability-based security.
• CHERIoT Rust: Status update #0
  • Six months of progress porting Rust to the CHERIoT capability-based hardware architecture. Core and alloc now compile for the new riscv32cheriot-unknown-cheriotrtos target.
• Ariel OS v0.3.0: BLE, Sensors, UART, and More!
  • New release adds BLE support, hardware-agnostic UART drivers, sensor abstraction, and expanded MCU support (ESP32, STM32, Nordic, RP).
• Async/await on the GPU
  • Rust's Future trait and async/await running on GPU hardware, reusing the Embassy embedded executor.

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• RFC: Unsafe fields
  • Approved for implementation. Allows marking struct fields as unsafe when they maintain safety invariants.
• Add try_shrink_to and try_shrink_to_fit to Vec
  • Fallible shrinking methods that return TryReserveError instead of panicking on OOM.
• Stabilize ptr_as_ref_unchecked
  • Raw-pointer-to-reference conversion without null/alignment checks.
• Stabilize atomic_try_update and deprecate fetch_update
  • Cleaner API for lock-free atomic compare-and-swap loops. fetch_update will be deprecated starting in Rust 1.99.0.
• Add avr_target_feature
  • Unstable target features for AVR microcontrollers including tinyencoding, lowbytefirst, and various instruction features.
• Stabilize cfg_select!
  • Builtin macro for selecting code based on cfg predicates, simplifying conditional compilation.
• Stabilize core::hint::cold_path
  • Mark unlikely code paths to help the compiler optimize branch layout.

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• uefi: Add device path generation for discovered devices in a PciTree
• uefi: significantly improve ergonomics of Handle (device path and component2 protocols)
• uefi-raw & uefi: serial: add support for protocol revision 1.1
• Improve docs of OpenProtocolAttributes
• uefi: Add handle_protocol doc alias to open_protocol functions
• uefi: serial: improve documentation and correctness of read() and write()

Thanks to @seijikun for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following changes:

• Expose data for custom boot image creation
• build with -Zjson-target-spec
• Enable json-target-spec
• release 0.11.15
• fix typo in year
• update bootloader crates

Thanks to @Freax13 and @Wasabi375 for their contributions!

virtio-spec-rs

Maintained by @mkroening

The virtio-spec crate provides definitions from the Virtual I/O Device (VIRTIO) specification. This project aims to be unopinionated regarding actual VIRTIO drivers that are implemented on top of this crate.

We merged the following PRs this month:

• build(deps): upgrade bitfield-structs to 0.12
• build(deps): update allocator-api2 to 0.4
• fix(docsrs): migrate from doc_auto_cfg to doc_cfg
• fix: rust-2018-idioms
• fix: upgrade to Rust 2024

bootimage

Maintained by @phil-opp

The bootimage tool allows the creation of bootable disk images for bootloader-based kernels. It also provides a runner executable for cargo to make cargo run and cargo test work using QEMU.

We merged the following changes this month:

• Add an example kernel that uses the built-in x86_64-unknown-none target
• Fix bootloader build by passing -Zjson-target-spec
• Prepare release
• Fix QEMU test flakiness on ARM64 macOS

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS.

We merged the following changes this month:

• Add support for extracting NUMA information from SRAT and SLIT
• Suggestion: Use colored instead of termion

Thanks to @martin-hughes for their contributions!

endian-num

Maintained by @mkroening

The endian-num crate provides the Be (big-endian) and Le (little-endian) byte-order-aware numeric types.

We merged the following changes this month:

• feat: add MSRV of 1.71
• fix(docsrs): migrate from doc_auto_cfg to doc_cfg

fuse-abi

Maintained by @mkroening

The fuse-abi crate provides bindings to FUSE devices. In motivation similar to that of virtio-spec, this project aims to provide correct foundational definitions for the FUSE kernel ABI.

We merged the following changes this month:

• fix(docsrs): migrate from doc_auto_cfg to doc_cfg

spinning_top

Maintained by @phil-opp

The spinning_top crate provides a simple spinlock implementation based on the abstractions of the lock_api crate.

We merged the following changes this month:

• fix(docsrs): migrate from doc_auto_cfg to doc_cfg

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

metta-systems/ram-map-viewer

(Section written by @berkus)

Added a little GUI for visualizing memory maps. The application itself currently supports a map format that my initialisation code emits, but it has a MemorySource trait that you can implement to consume any format.

metta-systems/vesper

(Section written by @berkus)

Vesper has learned to put nucleus into higher-half memory and added a kernel syscall API with a single syscall - a capability invocation. I have a list of capabilities I want to implement, and first one implemented is Debug Console so you can output execution trace from your domains.

Init thread implementation in progress, now parsing DTB and preparing to launch a user-space "init" process. The video above shows memory map produced by the init thread after parsing a RasPi3 B+ 1Gb DTB.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Patina - Developing UEFI With Rust
  • Repo: https://github.com/OpenDevicePartnership/patina
  • Project Overview on Youtube
• Kernel bugs hide for 2 years on average. Some hide for 20.
• What does it take to ship Rust in safety-critical?
• The Embedded Rustacean Issue #62
• The Embedded Rustacean Issue #63

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Destabilise target-spec-json
  • Custom target JSON specs now require -Zunstable-options again. This affects OS developers using custom targets.
• Cargo: add -Z json-target-spec
  • can also be enabled by adding json-target-spec = true to the [unstable] table in .cargo/config.toml
• The Rust GCC backend can now be installed with rustup
  • Alternative backend useful for cross-compilation and platforms where LLVM support is limited.
• Vec::push in consts MVP
• add allocator parameter to HashMap
• add AtomicPtr::null

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following changes:

• Add llvm-tools to components
• Fix overflow error during address calculation
• add kernel stack address to BootInfo
• fix "cargo build --release"
• Release 0.11.14

Thanks to @Wasabi375 and @the-ssd for their contributions!

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

We merged the following PRs this month:

No notable changes this month.

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• ovmf-prebuilt: Add download retry
• release: 0.2.7

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• uefi: improve ergonomics of Events
• uefi: improve doc (add short glossary/important terms overview)
• workspace: switch to resolver v3
• flake: update (Nix shell: rust 1.86 -> 1.92)
• Replace remaining uses of addr_of/addr_of_mut with raw pointer syntax
• Bump MSRV to 1.88
• uefi-raw: serial: fix mutability
• uefi: serial: improve overall documentation
• uefi: boot: improve documentation for handles
• export all text::{input, output} types
• fix(deps): update rust crate nix to 0.31.0

Thanks to @yaroslav957 for their contribution!

virtio-spec-rs

Maintained by @mkroening

The virtio-spec crate provides definitions from the Virtual I/O Device (VIRTIO) specification. This project aims to be unopinionated regarding actual VIRTIO drivers that are implemented on top of this crate.

We merged the following PRs this month:

• feat(virtio-mmio): add MAGIC_VALUE constant
• fix(virtq): clippy::manual_is_multiple_of
• feat(virtio-net): add VIRTIO_NET_F_CTRL_RX_EXTRA
• feat(virtio-net): add VIRTIO_NET_F_GUEST_USO{4,6}
• feat(features): add recommendations and recommendations_satisfied

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• feat(mapper): add MappedPageTable::display
• fix(instructions): allow unused_unsafe for cpuid
• feat(mapper): make OffsetPageTable a type alias
• fix(mapper): inline internal map_to_* functions
• docs: fix typos
• feat(paging): make range types !Copy
• docs(page): fix typos
• feat: make page types repr(transparent) and range types repr(Rust)

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Fix mention of non-existent keyboard_task function in async/await post
• Update 'Minimal Rust Kernel' post to enable unstable json-target-spec feature
• Enable unstable json-target-spec feature
• Fix translations: no_mangle attribute is unstable now

Thanks to @ebkalderon for their contribution!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Xous: A Pure-Rust Rethink of the Embedded Operating System
  • Homepage: https://xous.dev/
  • Repo: https://github.com/betrusted-io/xous-core
• Announcing Asterinas 0.17.0
• The state of the kernel Rust experiment
• ratatui v0.30 released with no-std support

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

No content was submitted for this section this month.

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following changes:

• fix buffer overflow in DiskAccess::read_exact_into
• Code changes to update to 2024 edition
• fix: some typo
• Fix create-disk-image links

Thanks to @spencer3035, @Taxrosdev, and @oxyzenQ for their contributions!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• release: 0.2.5
• build-edk2: Install python3-dev
• Upgrade loongarch64 toolchain
• build-edk2: Drop IA32 support
• build-edk2: Update aarch64 install path
• Update readme to note ia32 is only available in older releases
• release: 0.2.6 with edk2-stable202511-r1
• ovmf-prebuilt: Add release availability info to Arch docstring

Thanks to @fogti for their contribution!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• Change SimpleNetwork::wait_for_packet to return Option<Event>
• Implement BlockIO2
• uefi: Refactor PciRootBridgeIo::enumerate() with tree-topology information
• uefi: http: fix integration test

Thanks to @seijikun and @Virv12 for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

valibali/cluu

(Section written by @valibali)

CLUU’s kernel has transitioned from a feature-oriented hobby kernel to a strict L4-style microkernel that provides mechanisms only.

• The kernel surface is now intentionally minimal, limited to scheduling, memory management, IPC, interrupts, token verification, and syscall dispatch.
• All system policy, including filesystems, drivers, and services, has been moved entirely to userspace.
• Implicit privilege has been eliminated and replaced with an explicit, cryptographically verified token-based authority system.
• Every privileged operation now requires visible, auditable authority, with no ambient permissions or global namespaces.
• IPC has become the only communication primitive, implemented as deterministic synchronous rendezvous.
• The scheduler has been redesigned as an O(1) priority bitmap scheduler with predictable behavior and clear separation of mechanism and policy.
• Memory management now enforces per-process address spaces, validated user pointers, and lazy allocation via page faults.
• The syscall interface has been reduced to seven syscalls, with all privileged actions funneled through a single token-guarded entry point.
• The kernel is now fully unit-tested, smaller, stricter, and architecturally stable, enabling future development to proceed almost entirely in userspace.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• moss: a Rust Linux-compatible kernel in about 26,000 lines of code
• Sprout: a programmable UEFI bootloader written in Rust
• This Month in Redox - November 2025
• Made a x86_32 bootloader in Rust
• I've improved the implementation behind all the string formatting macros in Rust
• Rust in Android: move fast and fix things
• Podcast: Canonical - Jon Seager, VP Engineering for Ubuntu
• Video: Keynote: Rust in the Linux Kernel, Why? - Greg Kroah-Hartman

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Switching to Rust's own mangling scheme on nightly
• Stabilize asm_cfg
• Stabilize -Zno-jump-tables into -Cjump-tables=bool
• Pass pointers to const in assembly
• Add Allocator proxy impls for Box, Rc, and Arc
• Stabilise as_array in [_] and *const [_]; stabilise as_mut_array in [_] and *mut [_]
• FCP: Destabilise target-spec-json

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

New Crate: mem_barrier

Maintained by @mkroening

This crate provides cross-architecture, no-std memory barriers.

When compiling with optimizations, the compiler may try to improve performance by reordering independent memory accesses and instructions. Modern CPUs use similar techniques for improving performance, such as out-of-order execution. Memory barriers affect both the compiler and the CPU by restricting reordering of certain memory operations across these barriers respective to other CPUs or devices, allowing proper communication with them.

See the docs for details!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following changes:

• Add basic example
• Use legacy symbol mangling for BIOS stage 2
• release v0.11.13

Thanks to @peppergrayxyz for their contribution!

pci_types

Maintained by @IsaacWoods

The pci_types library provides types for accessing and configuring PCI devices from Rust operating systems. We merged the following change this month:

• fix: write compliant bit pattern for BAR sizing

Thanks to @cagatay-y for their contribution!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• clippy: latest nightly fixes
• book: Rephrase target installation
• Fix documentation for allocate_pages function
• AtaPassThru: Add read_pio method for AtaRequestBuilder
• release: uefi-raw-0.13.0, uefi-0.36.1
• efi shell interface protocol: add var(), vars(), and set_var()
• uefi: Implement PciRootBridgeIo bus device enumeration logic
• uefi-raw: add Tcp4 protocol type definitions
• uefi-raw: add Storage Security Command protocol type definitions
• uefi: Fix broken bridge recursion in PCI enumeration
• uefi: Make AtaDevice::execute_command() return AtaResponse on error
• uefi-raw: Add bindings for FMP
• uefi-raw: Add bindings for most HII protocols
• uefi: Add special broadcast nvme namespace

Thanks to @seijikun, @jasonbking, @JayKickliter, @crawfxrd, @RenTrieu, @rymdbar, and @splaled for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• release 0.15.3
• add SMAP helpers
• mention #542 in Changelog for 0.15.3
• fix docs.rs build
• Add ability to add iomap to TSS (take 2)
• Bump actions/checkout from 5 to 6
• release 0.15.4

Thanks to @Restioson for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Add Portuguese (pt-BR) translation
  • for all 12 posts
  • thanks a lot to @richarddalves for this contribution!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• This Month in Redox - October 2025
• Patina: a Rust implementation of UEFI firmware
• Inside Rust's std and parking_lot mutexes - who wins?
• Motor OS is now a Tier-3 target in Rust

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• What's the status/blocker for allocator_api to be stabilized?

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• aarch64 fixes

Thanks to @jackpot51 for their contributions!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• Add loongarch support
• Update the riscv64 toolchain
• feat: add LoongArch64 architecture support and update to latest prebuilt version
• release: 0.2.4 with edk2-stable202508-r1

Thanks to @ZR233 for their contribution!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• ci: fix latest nightly issues
• style: apply/fix more clippy lints (from cargo::nursery)
• uefi-raw: net: add convenient into_* helpers
• uefi-raw: net: code improvements
• uefi-raw: net: add convenient From impls + integration with core::net
• uefi: Improve AlignedBuffer API with more accessors and copy_from_iter()
• uefi: Add bindings for the HII_CONFIG_ROUTING protocol
• uefi: document udp_read of PXE protocol + improve test
• uefi-raw: add unit test for typical high-level net API usage
• uefi: Wrap AtaPassThruProtocol in UnsafeCell
• uefi: Wrap ScsiPassThruProtocol in UnsafeCell
• uefi: Wrap NmvePassThruProtocol in UnsafeCell
• uefi: use core::net-types in public API + remove duplications
• uefi: remove inconsistent println!
• style: apply/fix more clippy lints (from cargo::nursery) (2/2)
• release: uefi-raw-0.12.0, uefi-macros-0.19.0, uefi-0.36.0
• uefi-raw/uefi: Replace doc_auto_cfg with doc_cfg
• uefi-raw: Replace remaining uses of bool with Boolean
• xtask: Check uefi-raw for uses of the primitive bool type
• uefi: improve doc for device path construction

Thanks to @seijikun for their contribution!

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

We merged the following PRs this month:

• ci: dependabot auto-merge
• misc updates & improvements
• workspace: unify
• clippy: lifetime warnings

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Redox OS: Development Priorities for 2025/26
• This Month in Redox - September 2025
• Upcoming Rust language features for kernel development
• Kernel hackers at Cauldron, 2025 edition
• Linting Rust code in the kernel
• Tracking trust with Rust in the kernel
• MOROS 0.12.0
• blazesym 0.2 stable release: batteries included address symbolization
• Building a tiling window manager for macOS in Rust
• Video: (Kernel) Task Switching in Rust — by Jayden Qi — Seattle Rust User Group

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• This Development-cycle in Cargo: 1.90
• Allow &raw [mut | const] for union field in safe code

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following fix:

• Fix: target-pointer-width field now expects an integer
• Release v0.11.12
• Fix(v0.9): target-pointer-width field now expects an integer

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• test-runner: Add example of using the Input protocol
• style: misc clippy fixes
• style: cargo doc fixes and improvements
• uefi: memory safety fixes (UB!)
• uefi: doc: Parameters -> Arguments
• Remove unnecessary unsafe block in example
• uefi: remove support for unstable allocator_api feature

Thanks to @BrokenC1oud for their contribution!

virtio-spec-rs

Maintained by @mkroening

The virtio-spec crate provides definitions from the Virtual I/O Device (VIRTIO) specification. This project aims to be unopinionated regarding actual VIRTIO drivers that are implemented on top of this crate.

We merged the following PRs this month:

• feat: add traditional mem balloon device
• chore: release version 0.3.2

Thanks to @hcsch for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Update post texts to Rust 2024 (thanks to @thaliaarchi!)
• Fix: target-pointer-width field now expects an integer
  • Update blog for target-pointer-width change
• Translate post 12 'Async/Await' into Russian (thanks to @TakiMoysha!)
• Fix(post-02) Korean translation and typo (thanks to reddevilmidzy!)

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• This Month in Redox - August 2025
• Announcing Asterinas 0.16.0
• minimal FAT32 file system driver written in #[no_std] rust
• Writing a Hypervisor in 1,000 Lines
• Proka Kernel - A kernel for ProkaOS
• Introducing Rusted Firmware-A (RF-A) - A Rust-Based reimagination of Trusted Firmware-A
• nanomp3: A pure Rust no_std MP3 decoding library
• Video: Intrusive Linked Lists for Fun and Profit (on embedded)

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Make target pointer width in target json an integer
• Implement support for become and explicit tail call codegen for the LLVM backend

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• Rewrite acpi crate and entire AML interpreter

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following fix:

• fix target-c-int-width for 0.9.x
• release v0.11.11

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• Use size_of/align_of from prelude
• Add (partial) safe protocol implementation for EFI_HII_DATABASE_PROTOCOL
• xtask: improved error output for "wrong" repr
• EFI Shell Interface: CurDir Functions
• uefi-raw: move types to net module
• uefi-raw: various small net improvements
• uefi-raw: changelog update

Thanks to @seijikun and @RenTrieu for their contributions!

virtio-spec-rs

Maintained by @mkroening

The virtio-spec crate provides definitions from the Virtual I/O Device (VIRTIO) specification. This project aims to be unopinionated regarding actual VIRTIO drivers that are implemented on top of this crate.

We merged the following PRs this month:

• fix(pci): capabilities are always little-endian
• fix(pci): actually convert MMIO access to little endian
• chore: release version 0.3.1

Thanks to @Gelbpunkt for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• Bump actions/checkout from 4 to 5
• add PageFaultErrorCode::HLAT

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Update post texts to Rust 2024 (thanks to thaliaarchi)
• fix edition2@post-11 Chinese translation error (thanks to ttttyy)
• Add post-12 simplified Chinese translation (thanks to ic3-w1ne)
• fix(post-01): typo (thanks to L3Sota)
• Set test=true to enable main.rs testing again
• Update testing post to set test = true in Cargo.to
• Fix: target-pointer-width field now expects an integer
• Update blog for target-pointer-width change

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• You Are The BIOS Now: Building A Hypervisor In Rust With KVM
• How to write Rust in the kernel: part 3
• Vivo BlueOS Kernel open-sourced
  • Vivo is a Chinese company selling smartphones and smartwatches
  • BlueOS appears to be their smartwatch OS, now its kernel is open source (Apache license)
  • POSIX-compatible, targets ARM and RISCV, supports Rust's std library
  • Chinese homepage: https://blueos.vivo.com/kernel
• This Month in Redox - July 2025
• Writing a Rust GPU kernel driver: a brief introduction on how GPU drivers work
• bitpiece: a crate for defining and manipulating bitfields with procedural macros
• A Clone of the Linux Kernel's Red-Black Tree in Rust
• Rex: Closing the language-verifier gap with safe and usable kernel extensions
• Dynamic Indirect Syscalls via JOP or ROP in Rust
• Practicing Linux Syscalls with Rust and x86_64 Assembly

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Allow volatile access to non-Rust memory, including address 0

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following fix:

• Fixes the type of target-c-int-width in target jsons.

Thanks to @OmegaMetor for their contribution!

uart_16550

Maintained by @phil-opp

The uart_16550 crate provides basic support for serial port I/O for 16550-compatible UARTs. We merged the following change this month:

• Update port.rs to do \r\n

Thanks to @rsahwe for their contribution!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• doc: fix broken links
• uefi: Add HiiKeywordHandler and HiiConfigAccess protocol
• protocols: Add ACPI Table protocol
• feat: uefi-raw IoMmu Protocol Impl

Thanks to @seijikun, @Jonathas-Conceicao and @PelleKrab for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• docs(offset_page_table): fix typo
• feat: add forwarding impl PageTableFrameMapping for &P

Thanks to @mkroening for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Fix: target-c-int-width field now expects an integer
  • Update blog for target-c-int-width change
• Add [[bin]] section with test=false to Cargo.toml (thanks to @tigeryant)
  • Update first post to set test=false for binary
• translate edition2@post-11 to Chinese (thanks to @ttttyy)

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Munal OS: a fully graphical experimental OS with WASM-based application sandboxing
• SafaOS now has USB support and a working aarch64 port
• R9: a reimplementation of the plan9 kernel in Rust
• This Month in Redox - June 2025
• Ratatui alpha with no-std support released
  • crate for creating terminal user interfaces
• flat_rbtree: A fast, index-based Red-Black Tree with no heap allocations

Linux-related

• Kernel Memory Safety: Mission Accomplished
• How to write Rust in the kernel: part 2
• A Newbie's First Contribution to (Rust for) Linux
• Writing a basic Linux device driver when you know nothing about Linux drivers or USB

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Stabilizing naked functions
• Add new Tier-3 targets: loongarch32-unknown-none*
• Allow storing format_args!() in a variable

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• Updating Uefi Raw for EFI Shell Protocol
• SNP Integration Test: Improve Clarity
• ci: Temporarily pin to older nightly
• fix typo ctr16! to cstr16!
• xtask: Allow clippy::collapsible_if lint
• uefi: Fix clippy::uninlined_format_args lint
• test-runner: Fix clippy::uninlined_format_args lint
• uefi: Fix clippy::unnecessary_unwrap lint
• Fix mismatched_lifetime_syntaxes lint
• uefi: Make PciIoAddress orderable and hashable
• uefi: Fix io-align == 0 edgecase handling for ata & nvme
• uefi-raw: Add HII_CONFIG_ACCESS and CONFIG_KEYWORD_HANDLER protocol bindings
• doc/uefi: improve Protocol documentation
• Fix lints/tests on nightly and unpin the CI nightly version
• uefi-services: prepare v0.26.0 release to accelerate migration/deprecation
• uefi-services: remove again
• uefi/test-runner: Remove crate:: and uefi:: prefix from Status

Thanks to @seijikun, @nicholasbishop, @phip1611, @renovate[bot], @RenTrieu, and @diamant3 for their contributions!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• Split Source constants into a new file

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

We merged the following PRs this month:

• update workspace, Rust edition 2024, fixes

virtio-spec-rs

Maintained by @mkroening

The virtio-spec crate provides definitions from the Virtual I/O Device (VIRTIO) specification. This project aims to be unopinionated regarding actual VIRTIO drivers that are implemented on top of this crate.

We merged the following PRs this month:

• ci: run Miri

• fix(net): make HdrGso an enum instead of a flag
• add support of console
• chore: release version 0.3.0

Thanks to @stlankes for their contribution!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Document physical memory mapping size

Thanks to @aaronzper for their contribution!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• Add "FMask" alias for SFMask.

Thanks to @ChocolateLoverRaj for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Miralis, a RISC-V virtual firmware monitor
• This Month in Redox
  • Redox is looking for a developer in the EU - see the job description in our monthly report!
• The Linux 6.15 kernel arrives - and it's big a victory for Rust fans
• Rust Coreutils 0.1 Released With Big Performance Gains - Can Match Or Exceed GNU Speed
• Edit is now open source
• ChromeOS Virtual Machine Monitor is written in Rust with over 300k LoC
• First look at Blinksy - A Rust no-std no-alloc LED control library for spatial layouts
• biski64: A Fast, no_std PRNG in Rust (~0.37ns per u64)
• RusTOS - Small RTOS in Rust
• A second iteration of my DOS-like hobby OS in Rust

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• aarch64-softfloat: forbid enabling the neon target feature

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• release: uefi-raw-0.11.0, uefi-macros-0.18.1, uefi-0.35.0
• xtask: Add --ovmf-shell arg
• xtask: simplify env variables
• uefi: use Duration for boot::stall
• xtask: Improve error message for enums in uefi-raw
• ConfigTableEntry move constants and add example
• uefi: system::with_* now take mutably closure
• uefi-test-runner: streamline memory related tests
• rust: edition 2024
• Unpin uguid
• uefi: SNP transmit: document parameters
• doc: improved documentation for boot allocation functions
• uefi-raw: Add binding for EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL
• doc: streamline device path documentation between uefi-raw and uefi
• clippy: fix upcoming nightly lints
• cleanup IPConfig2/Http Protocol
• uefi: deprecated since 0.36.0
• doc: help with feature selection
• uefi: Add safe EFI_USB_IO_PROTOCOL bindings
• uefi: Add (partial) safe protocol implementation for PCI_ROOT_BRIDGE_IO_PROTOCOL

Thanks to @seijikun, @fox0, and @JarlEvanson for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• feat(sev): add AMD SEV support
• implement functions for accessing CR8
• Add page attribute table support

Thanks to @zyuiop for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Podcast: Microsoft rewriting Hyper-V components in Rust; calls 2025 "the year of Rust at Microsoft"
• Memory-safe sudo to become the default in Ubuntu
• Migration to rust-coreutils in Ubuntu 25.10
• noshell, a no_std argument parser and a shell for constrained systems
• Ariel OS - library OS for microcontrollers - now building on stable Rust

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Stabilize naked_functions

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• uefi-raw: Add binding for EFI_DEVICE_PATH_UTILITIES_PROTOCOL
• clippy: fix
• helpers: Add AlignedBuffer
• xtask: fix nixfmt + update Nix flake + fix CI
• uefi/doc: improve documentation of exit_boot_services + change signature
• uefi: Some convenient DevicePathUtilities helper methods
• uefi: Add safe protocol wrapper for EFI_EXT_SCSI_PASS_THRU_PROTOCOL
• uefi-raw: Fix ATA_PASS_THRU_PROTOCOL bindings
• snp network test fixes
• uefi-raw: Add EFI_USB_IO_PROTOCOL bindings
• uefi: Add safe protocol wrapper for EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL
• uefi: Move PoolString to enable additional use
• uefi-raw: Fix EFI_USB_IO_PROTOCOL implementation
• uefi-raw: Add EFI_USB2_HC_PROTOCOL bindings
• uefi: Add safe protocol wrapper for EFI_ATA_PASS_THRU_PROTOCOL
• uefi-raw: Move EFI_SIMPLE_NETWORK_PROTOCOL
• Enable access to hidden RAII guard components
• UEFI Allocator: add PAGE_SIZE shortcut
• xtask: Update OVMF release to EDK2_STABLE202502_R2
• add ip4config2 + http protocols support
• uefi-raw: Redefine UsbPortStatus and UsbTransferStatus
• uefi: remove duplication in DevicePathHeader; use uefi-raw
• uefi: Implement CalculateCrc32() boot services function

Thanks to @seijikun, @andersson, @kraxel, and @JarlEvanson for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• fix kani build job
• improve VirtAddr Add & Sub impls
• Revert #529 on master
• merge master into next

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• implement Send+Sync for MemoryRegions

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Added [[bin]] section to Cargo.toml
• loading UEFI using ovmf_prebuilt=0.2.3 with ovmf_code and ovmf_vars

Thanks to @tigeryant and @v4zha for their contributions!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Rust, compiled to Holy C, running on TempleOS
• My non-unix like rust OS SafaOS, now has a rust libstd port
• Introducing Ariel OS - an embedded library OS for small MCUs
• Stalloc: fast memory allocation on the stack

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Allow *const W<dyn A> -> *const dyn A ptr cast
• Stabilize asm_goto feature gate

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• uefi: Implement SignalEvent() boot services function
• uefi: Improve handling of null-address allocations in allocate_pages
• uefi: Mark all function pointers in pxe::BaseCode unsafe
• uefi: Exclude null byte from CStr8 Display impl
• nix: switch to Nix Flake
• Fix unwanted rebuilds in xtask commands
• Create FUNDING.yml
• Implement conversions for IpAddress and MacAddress
• uefi: Clean up error docs in media protocols
• uefi: Reformat use items in pxe module
• uefi: Consistently use &mut self for pxe::BaseCode methods
• ci: fix typos
• Update Protocol/unsafe_protocol docs
• uefi: Use uefi_raw's PxeBaseCodeProtocol to implement the internals of pxe::BaseCode
• uefi-raw: Add DiskInfo protocol binding
• uefi-raw: Add EXT_SCSI_PASS_THRU protocol binding
• uefi runtime: Increase default size of name buffer
• uefi-raw: Add conversions to/from core::net IP address types
• uefi: Enable unsafe_op_in_unsafe_fn lint
• uefi: Make pxe::Mode an opaque struct
• uefi: Implement safe wrapper for EFI_DISK_INFO_PROTOCOL
• uefi-raw: Add EFI_NVM_EXPRESS_PASS_THRU_PROTOCOL bindings
• uefi-raw: Add documentation to ScsiIoScsiRequestPacket
• uefi-raw: Add EFI_ATA_PASS_THRU_PROTOCOL bindings

Thanks to @seijikun, @ifd3f, @ptf2, and @quic-bjorande for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• remove #[no_mangle] from panic handler

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Update blog to Rust 2024 edition
• Latam Spanish translation
• Fix translation in zh-CN testing post

Thanks to @dobleuber and @JINHUILYU for their contributions!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• This Month in Redox - January 2025
• RSoC 2024: Dynamic Linking - Part 2
• Asterinas in 2024
  • Asterinas is a Linux ABI-compatible OS written from scratch in Rust
• Towards Practical Formal Verification for a General-Purpose OS in Rust
• Writing a Simple Windows Driver in Rust
• FOSDEM talk: Rust for Linux
• No-Panic Rust: A Nice Technique for Systems Programming
• PSA: uuid's getrandom update may break no-std V4/V7 users
• The Embedded Rustacean: Issue #39 and Issue #40

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Create a generic AVR target: avr-none
• x86: use SSE2 to pass float and SIMD types
• add x86-sse2 (32bit) ABI that requires SSE2 target feature
• Update to LLVM 20

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• relicensing: Rewrite PR "DevicePathToText and DevicePathFromText Protocol"
• Relicense to "MIT OR Apache-2.0"
• Add SPDX headers
• release: uefi-raw-0.10.0, uefi-macros-0.18.0, uefi-0.34.0
• uefi: Update license info in docstring
• release: uefi-0.34.1
• uefi-raw: add Boolean type
• uefi-raw: use new Boolean type
• xtask/uefi-raw: improve check-raw error messages
• Fix upcoming lints in clippy 1.85
• uefi: clarify situation with boot::memory_map() and Status::BUFFER_TOO_SMALL
• Fix uefi-raw MSRV build, and improve CI for MSRV
• Add PXE types to uefi-raw
• uefi: Replace definition of MacAddress with a re-export from uefi-raw
• Use bitflags definitions from uefi-raw in uefi's pxe module
• uefi: Fix the BufferSize argument in SimpleNetwork::transmit
• Use newtype enum definitions from uefi-raw in uefi's pxe module

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Update x86_64 to 0.15.2
• change rustc-abi in custom targets to x86-softfloat
• [v0.9] change rustc-abi in custom targets to x86-softfloat
• Release v0.11.10
• Update uart_16550 to 0.3.2
• Specify kernel-code virt addr in BootloaderConfig
• Use Result::ok

Thanks to @Stazer, @Wasabi375, and @ChocolateLoverRaj for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• Ensure that addition and subtraction of addresses panics on overflow/underflow
• don't pass -Crelocation-model=static to host targets

Thanks to @farnz for their contribution!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• acpi: fix build errors

Thanks to @jellllly420 for their contribution!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• Add 202408.01, 202411, and 202502 releases
• fix(deps): update rust crate ureq to v3
• Set Source::LATEST to EDK2_STABLE202502_R1
• release: 0.2.2 y

Thanks to @mkroening for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Podcast: Rust in Production: Volvo Ships Memory-Safe ECUs in Production Cars
• The VEKOS operating system is now able to execute programs
• Video: Windows Kernel Programming with Rust - Matthias Heiden | EuroRust 2024
• Understanding the Microsoft Pluton security processor (uses Rust and TockOS)
• Linux: Resistance to Rust abstractions for DMA mapping

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Insert null checks for pointer dereferences when debug assertions are enabled
• Make missing_abi lint warn-by-default
• show linker output even if the linker succeeds

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• uefi-raw: Add FirmwareVolume{,Block}2Protocol
• uefi-raw: hii: Add Database Protocol
• uefi-raw: Add ScsiIoProtocol
• Add missing type/subtype checks to TryFrom<&DevicePathNode>
• uefi-raw: Add common impls for http types
• relicensing: Rewrite allocator, configuration table, and image unload PRs
• relicensing: Rewrite set_timer PR
• Fix memory leaks in DevicePathFromText
• Add warning to custom memory types
• test-runner: Clean up device path tests

Thanks to @crawfxrd and @hannahfluch for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• use threads instead of futures in build.rs
• Move test kernels to a separate workspace
• fix condition for running bootloader common tests

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• fix warnings & remove broken CI job
• Add page attribute table support
• use default python again
• feat(msr): add IA32_APIC_BASE support

Thanks to @hannahfluch and @adavis628 for their contributions!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• acpi: Remove Clone Copy traits for MADT
• acpi: Clone impl for PlatformInfo and ManagedSlice
• aml: fix clippy warnings and run clippy in CI
• Fix unsoundness in our representation of the MADT

Thanks to @IsaacWoods, @mrjbom, and @00xc for their contributions!

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

We merged the following PRs this month:

• fix: typos
• misc improvements

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

roeeshoshani/genesis

(Section written by @roeeshoshani)

genesis is a bare metal firmware implementation for mips. it implements everything from the bottom up, from initializing the cpu caches, to configuring pci devices and the interrupt controller.

this month, the core async executor was implemented.

this means that we can implement blocking operations (for example reading a byte from the UART) as rust futures, and we then .await them.

this makes our lives much easier when writing code that needs to block until some I/O events happen. instead of using callbacks, and having to pass our state all over the place, we can just .await the blocking future, and write our code using async functions, which is much more ergonomic.

example

currently, there is only one blocking operation implemented, the operation of reading a byte from the UART.

this allows code like the following to be written:

loop {
    let byte = uart_read_byte().await;
    println!("received uart byte: {}", byte);
}

which is a huge improvement over the previous implementation of putting the code inside the UART interrupt handler.

how does it work?

the way this works is that the core kernel's main loop looks roughly like the following:

loop {
    poll_tasks();
    wait_for_interrupt();
}

then, the interrupt handler is responsible for waking up the relevant tasks.

futures that need interrupt handlers to wake them up should somehow register themselves, and the interrupt hanlers will then wake the registered tasks.

then, in the next iteration, the tasks that were woken up will be polled again, which completes the loop.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• This Month in Redox OS - December 2024
• Video: Intro to Embassy : embedded development with async Rust
• 2025: The Year of COSMIC — Alpha 5 Released!
• Funding Opportunities - with Redox OS or on your own
  • The NGI Zero Commons Fund and NGI Zero Fediversity Fund each have a call for proposals with a Feb. 1 deadline. If the proposal is successful, it would be to start roughly in June or July (based on our experience) and run for up to 12 months, with an amount up to 50,000 EUR. There must be a "European component", so a EU-based developer would be an ideal fit, or perhaps a project where the maintainer is EU-based. Here are the links:
  • NGI Zero Commons Fund
  • NGI Zero Fediversity Fund
  • Redox is looking for a part-time or short-term developer to help with implementing device drivers, ACPI support, and similar, who would like to join our proposal. You must be knowledgeable in Rust and drivers, and have good reputation in the open source community. We have an existing relationship with NLnet, so we can craft the proposal, based on your skillset and our priorities. Please join us on Matrix and let us know you are interested.
  • https://matrix.to/#/#redox-join:matrix.org

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Improve default target options for x86_64-unknown-linux-none
• De-duplicate and improve definition of core::ffi::c_char

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• Fix clippy::needless_lifetimes in Rust 1.83 and ShimLock ABI on ia32
• Fix clippy::use_self
• uefi-raw: Add DriverBindingProtocol
• Increase MSRV to 1.81
• Update ptr_meta to 0.3.0
• Remove unstable gate for core::error::Error impls
• Use size_of/size_of_val/align_of/align_of_val from the prelude
• book: Set driver link-arg in build.rs

Thanks to @crawfxrd and @JarlEvanson for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• fix(idt): panic in impl fmt::Debug for EntryOptions
• Add MapperFlush method to get page
• feat: add update() to Cr3, Dr7, SFMask, UCet, SCet, mxcsr, rflags, and XCr0
• fix(model_specific): make {Fs,Gs,KernelGs}Base::write() unsafe
• Merge master into next

Thanks to @mkroening and @adavis628 for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Remove "UEFI boot" log message

Thanks to @ChocolateLoverRaj for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

roeeshoshani/genesis

(Section written by @roeeshoshani)

genesis is a bare metal firmware implementation for mips. it implements everything from the bottom up, from initializing the cpu caches, to configuring pci devices and the interrupt controller.

i noticed that every kernel implementation is always for x86, so i decided to implement it for something a little more esoteric - mips.

the project is currently in very early stages but the basics are there.

it is my hobby project for me to learn about embedded programming.

feel free to follow along the development of it :).

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• VEKOS, a cryptographically verified hobby OS written in Rust
• Rust in Production: Oxide Computer Company with Steve Klabnik (Podcast Interview)
• This Month in Redox - November 2024
• ‘Tis the Season for COSMIC Alpha 4!
• a #![no_std], #![no_main], no-[#tokio] runtime for AWS Lambda
• Ferrocene 24.11.0 released with medical qualification (reddit discussion)
• Embive: A low-level sandboxing library for RISC-V bytecode
• Rust in QEMU roadmap
• kartoffels, a game where you implement a firmware for a potato, v0.6 released! 🥔

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• mark some target features as 'forbidden' so they cannot be (un)set with -Ctarget-feature
• show abi_unsupported_vector_types lint in future breakage reports
• Stabilize extended_varargs_abi_support

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• fix field order for INVPCID descriptor
• fix CI job for building on MSRV
• gate HandlerFunc behind target_arch = "x86{_64}"
• fix typo in "InvPicdCommand"
• TryFrom implementation for ExceptionVector
• Typo fix in TaskStateSegment comment
• Minor clarification DescriptorTablePointer::limit comment
• fix signature of Step::steps_between implementations
• release 0.15.2
• backport #513

Thanks to @mrjbom for their contribution!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• Implement the multiprocessor wakeup mechanism.
• acpi-dumper: fix invocation of compile_error!
• aml: make resource descriptor fields public
• acpi: fix clippy warnings and run clippy in CI
• acpi: fix doc warnings and add missing links
• acpi: spcr: fix typo

Thanks to @pjhades, @00xc, and @Hsy-Intel for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Remove 3dnow features from stage4 target
• mention E820 in docs for UnknownBios
• release v0.11.8
• copy more PML4 entries
• Convert LF to CRLF when writing to serial port
• Update x86_64
• release v0.11.9

Thanks to @Ollrogge, @ChocolateLoverRaj, and @Makonede for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• chore(config): migrate renovate config
• uefi: Deny clippy::ref_as_ptr
• Move the UnicodeCollation protocol definition to uefi-raw and use it from uefi
• Use ovmf-prebuilt
• xtask: Update OVMF prebuilts
• uefi-raw: Drop unused dependency on ptr_meta
• Fix cargo xtask fmt --check
• Fix minor typo in protocols.md
• Add TCG protocols to uefi-raw and use them from uefi
• Mention to turn off secure boot.
• Clean up some use of unsafe in MemoryMapRefMut

Thanks to @diekmann for their contribution!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• ovmf-prebuilt: Update readme
• release: 0.2.1

uart_16550

Maintained by @phil-opp

The uart_16550 crate provides basic support for serial port I/O for 16550-compatible UARTs. We merged the following change this month:

• feat(mmio): add new_with_stride

Thanks to @kouchekiniad for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• This Month in Redox - October 2024
• Smart pointers for the kernel
• On Rust in enterprise kernels
• Unsafe Rust Is Harder Than C
• Version v2.0.0 of thiserror released with no_std support

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Taking a raw ref (&raw (const|mut)) of a deref of pointer (*ptr) is always safe
• mark some target features as 'forbidden' so they cannot be (un)set with -Ctarget-feature
• make unsupported_calling_conventions a hard error

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• uefi-macros: Require that the entry function takes zero args
• uefi: Delete the deprecated uefi::table::{boot,system} modules
• uefi: Derive Eq/PartialEq for GptPartitionEntry
• uefi: Add CStr16 conversions from slices with interior nuls
• uefi: Improve the VariableKey type and iterator
• Update timeline section of funcs_migration.md
• xtask: Add action to generate a code coverage report
• nix: add cargo-llvm-cov to nix shell + niv update
• Codecov configuration updates
• Move DeviceType and DeviceSubType enums to uefi-raw
• Add device path node types to uefi-raw
• release: uefi-raw-0.9.0, uefi-macros-0.17.0, uefi-0.33.0
• Increase MSRV to 1.79

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• Remove stabilized const_mut_refs feature
• Fix clippy warnings

pci_types

Maintained by @IsaacWoods

The pci_types library provides types for accessing and configuring PCI devices from Rust operating systems. We merged the following change this month:

• Add set bus number funcs

Thanks to @ZR233 for their contributions!

ovmf-prebuilt

Maintained by @nicholasbishop and @phil-opp

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• Implement ovmf-prebuilt library
• Add release workflow
• release: 0.2.0
• release: 0.2.0 (take two)

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

We merged the following PRs this month:

• multiboot2: various small fixes and doc improvements
• multiboot2: bug fixes

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• Add from_rsdt method for AcpiTables.

Thanks to @Hsy-Intel for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No updates were proposed for this section this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Redox OS 0.9.0
  • This Month in Redox OS - September 2024
• Google's Shift to Rust Programming Cuts Android Memory Vulnerabilities by 68%
• Binsider: new tool to analyze ELF binaries with a user-friendly TUI
• Rust in the Linux Kernel
  • Best practices for error handling in kernel Rust
  • Resources for learning Rust for kernel development
  • Committing to Rust in the kernel
• Rust in illumos
• I compiled Rust code to Nintendo Gameboy!
• Rust for Android
• Rust is rolling off the Volvo assembly line

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Safety Goggles for Alchemists: The Path Towards Safer Transmute
• Deprecate -Csoft-float because it is unsound (and not fixable)
• Stabilize const_refs_to_static
• Stabilize &mut (and *mut) as well as &Cell (and *const Cell) in const
• Implement raw lifetimes and labels ('r#ident)

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

Last month, we talked about the major milestone of the v0.22 release of the multiboot2 crate, where all Undefined Behaviour (UB) and a bunch of safety and memory issues have been removed / fixed. After a short grace-period of one month, we now yanked all prior releases. As all of them contain UB, sensitive low-level software can break in subtle ways.

We hope that all users can have a smooth migration to v0.22 or above (with Rust 1.70 from June 2023 as MSRV). If there are problems, we are happy to temporarily unyank certain versions or create a v0.22.x with a lower MSRV. We can discuss this here.

Further, we released v0.23 which contains dependency bumps and missing tags. Specifically:

• ApmTag
• BootdevTag
• NetworkTag

Please find more in the changelog.

We merged the following PRs this month:

• crate: fix latest clippy nightly complains
• multiboot2: add missing tags
• Replaces dead link home page multiboot2-header package definition
• multiboot2: streamline getters and public tags()
• multiboot2-common: improve documentation
• workspace: prepare updates
• talk about yanked versions in changelog files
• multiboot2-common: improve README and diagrams

Thanks to @filiplajszczak for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality.

We merged the following PRs this month:

• Fix unused warnings if log-debugcon is not enabled
• Add uefi::{boot,runtime,system} modules to the prelude
• uefi: Add panic doc to uefi::helpers::init
• uefi: Add uefi::runtime::variable_exists
• release: uefi-raw-0.8.0, uefi-macros-0.16.0, uefi-0.32.0
• Update the hello-world tutorial
• uefi: Delete the deprecated helpers::system_table function
• Drop FileSystem conversion from table::boot::ScopedProtocol
• test-runner: Remove BootServices from many protocol tests
• Delete deprecated RuntimeServices struct
• test-runner: Remove BootServices from remaining proto tests
• Fix handling of a null interface pointer in boot::open_protocol
• test-runner: Remove remaining tests for deprecated table types
• uefi: Delete deprecated allocator functions

xhci

Maintained by @toku-sa-n

The xhci crate provides types of xHCI structures, such as Registers and TRBs. We merged the following PRs this month:

• removed deprecated clippy check option

Thanks to @dbydd for their contributions!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• aml_tester:Make cli print more pretty
• Ignore MultiprocessorWakeup when parse interrupt model

Thanks to @jokemanfire, and @Hsy-Intel for their contributions!

pci_types

Maintained by @IsaacWoods

The pci_types library provides types for accessing and configuring PCI devices from Rust operating systems. We merged the following change this month:

• Match the output of lspci in the PciAddress Display impl

Thanks to @bjorn3 for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No updates were proposed for this section this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Asahi Lina on how Rust helps with API docs in the Linux kernel
• You can kick the alpha tires on System76’s Cosmic, a new Linux desktop
• WhenFS: a Rust FUSE filesystem for your Google Calendar
• Status update on CharlotteOS: a post-unix operating system written in Rust and assembly language

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• add Box::as_ptr and Box::as_mut_ptr methods
• Stabilize unsafe extern blocks (RFC 3484)
• Stabilize asm_const
• Stabilize unsafe_attributes
• Stabilize raw_ref_op (RFC 2582)
• Promote riscv64gc-unknown-linux-musl to tier 2
• float types: document NaN bit pattern guarantees
• Partially stabilize feature(new_uninit)

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

multiboot2

Maintained by @phip1611

Convenient and safe parsing of Multiboot2 Boot Information (MBI) structures and the contained information tags. Usable in no_std environments, such as a kernel. An optional builder feature also allows the construction of the corresponding structures.

🎉 We are happy to announce release v0.22 of the multiboot2 crate. This is a major step forward as all Undefined Behaviour (UB) and a bunch of safety and memory issues have been removed / fixed. 🎉 Now, all unit tests (and there are many) pass Miri! This was possible due to massive internal refactorings done in #226 and #227.

The quite complex logic to parse all these structures safe and correctly has been moved to a new multiboot2-common crate. This way, the multiboot2-header crate can also leverage the new abstractions. A comprehensive writeup about why the parsing of Multiboot2 structures and typing them correctly in Rust is much more complex than one initially might think is written down in lib.rs of multiboot2-common.

multiboot2-header also got a new release v0.5 and can now be considered safe and free of UB when parsing the corresponding structures. The internal refactorings only slightly leak to the public interfaces of multiboot2 and multiboot2-header.

Read more:

• Changelog of multiboot2
• Changelog of multiboot2-header

uefi

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

uefi makes it easy to develop Rust software that leverages safe, convenient, and performant abstractions for UEFI functionality. Recently, we released version v0.31 with some notable changes:

1. We introduced a completely new API to access boot and runtime services
2. We reorganized the MemoryMap-related types.
3. We reorganized and improved the documentation, and also added documentation about how the std implementation for UEFI targets compares to uefi and how both can be used together.

1. New API: Freestanding Functions API Change

We are planning a massive API change and introduced a new replacement API in release v0.31. The old API co-exists and will be marked as #[deprecated] in 0.32. The new API will make it easier to call boot or runtime services without having to pass &BootServices around all the time.

The typical use-case of our library users is to write a UEFI bootloader application that heavily leverages boot services. Then control is handed over to the next stage, which is typically the kernel of an OS. Boot services are usually exited either just prior to launching the kernel or by the kernel itself. In any case, the UEFI application spends almost all of its time with boot services active.

Although the old API design ensures via the type system that no boot services can be called after they have been exited, the test of time has proven that this adds unjustified complexity without bringing much real value add.

Instead, with the new API, which we provide additionally at this point, one can use freestanding functions which are behind the new modules:

• uefi::system: is a new module that provides freestanding functions for accessing fields of the global system table.
• uefi::boot: is a new module that provides freestanding functions for boot services using the global system table.
• uefi::runtime: is a new module that provides freestanding functions for runtime services using the global system table.

The freestanding functions itself are close to the originals ones but without &BootServices or &RuntimeServices parameters, as you can see for example here.

The new API design solves API inconsistencies and restrictions already existing so far, and makes the overall handling a lot easier. This comes with the costs that functions may panic, if the boot services were exited but one tries to use them. However, the massive API simplification justifies this.

Find more and follow the progress and discussions on:

• the GitHub Issue.
• The function Migration Guide

2. Memory Map Refactoring

TL;DR: What used to return MemoryMap<'buf> in the API, now returns MemoryMapOwned. Additionally, you can parse a chunk of memory using MemoryMapRef or MemoryMapRefMut.

We put significant effort into refactoring our abstractions for the UEFI memory map. These started in release v0.29 and were finalized in release v0.31. Instead of one MemoryMap<'buf> type, we now have the traits MemoryMap and MemoryMapMut along with the implementations MemoryMapRef, MemoryMapRefMut, and MemoryMapOwned. It is recommended to work with the specific implementations, as the main purpose for the traits is only to enforce a consistent API for these three implementations. This gives users the flexibility to cover all possible use cases one can have with an UEFI memory map. Read more:

• #1175
• #1251
• #1240
• #1263

In any case, obtaining the memory map from UEFI is hidden behind the public API of the crate, but we made it very easy to read/parse it in all possible scenarios!

3. Documentation Reorganization

We put notable work into our README and lib.rs files to improve the structure of our documentation. The main value-add and improvement is that we clearly, directly, and precisely talk about:

• What is uefi?
• Which problems does it solve?
• How can it be used?
• How does it compare to the ecosystem, such as std for Rust targets?

To see an example how uefi and std can be used together, please head to our repository.

Other

There were also a ton of other interesting fixes, changes, and additions! Check out our Changelog.

We merged the following PRs this month:

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Fixed "jc fail" instructions not working properly and updated README.md

Thanks to @spencer3035 for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• remove #![feature(asm_const)]

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• simple-fatfs: A filesystem library aimed at embedded ecosystems
• Redox OS: Towards userspaceification of POSIX - part I: signal handling and IO
• Jeremy Soller on OS Development, Legacy Code, Redox OS and the Future of Memory-Safe Languages (Podcast Interview)
• Developing a cryptographically secure bootloader for RISC-V in Rust

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Stabilize unsafe extern blocks (RFC 3484)
• Stabilize offset_of_nested
• Add #[must_use] to some into_raw* functions
• treat &raw (const|mut) UNSAFE_STATIC implied deref as safe
• Add NuttX based targets for RISC-V and ARM
• #[naked]: report incompatible attributes
• Fill out target-spec metadata for all targets

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

virtio-spec-rs (new project!)

Maintained by @mkroening

The virtio-spec crate provides definitions from the Virtual I/O Device (VIRTIO) specification. This project aims to be unopinionated regarding actual VIRTIO drivers that are implemented on top of this crate.

The origins of this crate are in Hermit. Due to the need for correct foundational definitions from the Virtio spec that are easily reviewable and independent of the actual driver logic, this project was created from the ground up and without any intended bias towards Hermit.

Currently, definitions are available for split and packed virtqueues, for Virtio over MMIO and Virtio over PCI, and for the network, socket and file system devices. Feature requests for additional devices are more than welcome!

fuse-abi (new project!)

Maintained by @mkroening

The fuse-abi crate provides bindings to FUSE devices. In motivation similar to that of virtio-spec, this project aims to provide correct foundational definitions for the FUSE kernel ABI. It can even be used together with virtio-spec when creating a driver for the Virtio file system device.

This crate essentially brings #include <linux/fuse.h> to Rust. The code is autogenerated using bindgen, ensuring the correctness of definitions.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• release: uefi-macros-0.14.0, uefi-raw-0.6.0, uefi-0.29.0
• book: Publish the latest release instead of main
• Add redirects for all the html files under HEAD
• Drop SystemTable arg from uefi::helpers::init
• uefi-macros: Allow zero-param function in the entry macro
• uefi: Fix return value lifetime for register_protocol_notify
• logger: Remove some unnecessary cfgs
• fix(deps): update rust crate syn to v2.0.70
• uefi: _print more failsafe
• mem: introduce traits MemoryMap and MemoryMapMut
• Add uefi::system module
• Add PcrEvent::new_in_box/PcrEventInputs::new_in_box
• Add uefi::runtime module
• runtime: Add freestanding functions to get/set/delete UEFI variables
• boot: Always impl Drop for MemoryMapBackingMemory
• test-runner: Drop the memory map OOM loop
• uefi-raw: Add more MemoryType constants
• Add variable key functions to uefi::runtime
• uefi: mem: mem.rs -> mem/mod.rs
• runtime: Add query_variable_info
• Fix CI for Rust 1.80
• Add capsule update functions to uefi::runtime
• Add uefi::boot module
• runtime: Add uefi::runtime::reset
• cleanup/follow-up: memory_map
• Move the global image handle to uefi::boot
• Add boot::locate_handle_buffer
• boot: Add freestanding version of open_protocol
• boot: Add freestanding version of open_protocol_exclusive
• Finalize memory_map module refactoring
• Add boot::{load_image, unload_image, start_image}
• clippy: add use_self and const fn
• clippy: streamline lints
• ci: reorganize nightly CI jobs

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• acpi: add support for SPCR table

Thanks to @00xc for their contributions!

uart_16550

Maintained by @phil-opp

The uart_16550 crate provides basic support for serial port I/O for 16550-compatible UARTs. We merged the following change this month:

• build(deps): update bitflags dependency to version 2
• feat: add try_send_raw and try_receive

Thanks to @mkroening for their contributions!

endian-num

Maintained by @mkroening

The endian-num crate provides the Be (big-endian) and Le (little-endian) byte-order-aware numeric types.

• test: fix doctests for 32-bit and 16-bit pointer widths
• chore: remove appendix from LICENSE-APACHE

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• always cover at least the first 4 GiB of physical memory

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• Ensure that Page actually implements Hash
• don't use label starting with 1
• Add size and len for PageRange, PhysFrameRange, PageRangeInclusive and PhysFrameRangeInclusive
• fix testing

Thanks to @Wasabi375 for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phip1611/bit_ops

(Section written by @phip1611)

I've recently created and published bit_ops. It offers common bit-oriented operations on primitive integer types with a focus on no_std and const compatibility. Unlike other crates that provide tooling to create sophisticated high-level types with bitfields, the focus of bit_ops is on raw primitive integer types.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Redox OS - Software Showcase #1
  • This is our first showcase video, showing several programs running on Redox OS
• This Month in Redox - June 2024
• k23 - Experimental WASM Microkernel
  • First announced at RustNL 2024, k23 is an experimental microkernel written in Rust that runs WebAssembly programs. Now Open Source!

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Split core's PanicInfo and std's PanicInfo
• Stabilize PanicInfo::message() and PanicMessage
• Unsafe extern blocks
• Size optimize int formatting
• Add f16 inline ASM support for RISC-V

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• uefi: Stop enabling error_in_core feature
• reorganize deps
• uefi: Add TryFrom u8 slice to DevicePathHeader
• test-runner: Consistently use global image handle
• uefi: Add TryFrom u8 slice to DevicePathNode
• Clean up duplicate global system table pointer in uefi::helpers
• uefi: make DevicePathHeader::try_from idiomatic
• uefi: Add TryFrom u8 slice to DevicePath
• uefi: re-export CapsuleFlags
• ci: Temporarily turn off warnings-as-errors for nightly CI jobs
• uefi: use UNSPECIFIED_TIMEZONE instead of magic number
• uefi: Make TimeError more descriptive
• Fix versions
• uefi-test-runner: speed up ploting of sierpinski triangle by updating changed pixel only
• memory map: improvements to fight pitfalls (MemoryMap now owns the memory)
• uefi: simplify usage of Mode
• template: fix build failure
• uefi: Add TryFrom<&[u8]> for Time

Thanks to @LightAndLight, @andre-braga, and @JeffLi01 for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Guard the lower 1MB of memory

Thanks to @Wasabi375 for their contributions!

pci_types

Maintained by @IsaacWoods

The pci_types library provides types for accessing and configuring PCI devices from Rust operating systems. We merged the following change this month:

• feat: accept FnOnce for updating commands
• ci: add workflow
• feat: don't truncate reserved bits in CommandRegister
• fix(breaking): clippy lints
• style: update rustfmt.toml
• feat: derive additional traits for CommandRegister
• feat: add EndpointHeader::update_interrupt
• feat: don't take explicit references to ConfigRegionAccess
• feat: implement Copy for all types that already implement Clone
• fix: don't take explicit reference in update_interrupt
• Add method to get the address of any capability
• Fix docs rendering for MsixCapability::set_enabled
• feat: make update_command take &mut self
• Add method to enable/disable function masking for MSI-X
• Add unwrap_io and unwrap_mem convenience methods on Bar
• Remove the function_exists method of ConfigRegionAccess
• Support 64-bit addressing in MSI capabilities and improve uniformity with rest of library

Thanks to @IsaacWoods, @bjorn3, and @mkroening for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• constify PhysFrame functions

volatile

Maintained by @phil-opp

The volatile crate provides a safe wrapper type for implementing volatile read and write operations. This is useful for accessing memory regions that have side-effects, such as memory-mapped hardware registers.

We merged the following PR this month:

• Release v0.6.0

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

nicholasbishop/ext4-view-rs

(Section written by @nicholasbishop)

I've released a new Rust crate for reading ext4 filesystems. It's easy to use, with an API very similar to std::fs. The crate is no-std compatible, but does require an allocator.

Note that by design this crate will remain read-only; writing to an ext4 filesystem is not a goal.

Thanks to @tedbrandston for doing a ton of code review on this project!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• This Month in Redox - May 2024: Redox is running COSMIC file manager, editor, and terminal now
• Bachelor's Thesis: Writing an NVMe Driver in Rust (PDF)
• Building an Async Runtime for the Windows Kernel
• Ferrocene 24.05.0 now available for purchase
• Rust 1.78: Performance Impact of the 128-bit Memory Alignment Fix
• GxHash - an extremely fast hardware-accelerated non-cryptographic hashing algorithm (zero dependencies, no_std compatible)
• The Embedded Rustacean Issue #19, Issue #20, and Issue #21

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Stabilize LazyCell and LazyLock (LazyCell is available in no_std)
• Stabilize error_in_core
• Add x86_64-unknown-linux-none target (freestanding linux binaries without libc dependency)
• Add opt-for-size core lib feature flag
• Implement feature integer_sign_cast

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

endian-num (new project!)

Maintained by @mkroening

The endian-num crate provides the Be (big-endian) and Le (little-endian) byte-order-aware numeric types.

• initial implementation
• docs: elaborate on differences to other crates
• docs: refer to related crates via docs.rs

Thanks to @mkroening for creating and maintaining this crate!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Fix risc target_arch cfg
• Match MaximumCapsuleSize to UEFI spec
• Add RuntimeServices::update_capsule
• Add RuntimeServices::query_capsule_capabilities
• Note about feature flags for uefi book
• uefi-raw: misc
• mem: clarify confusion around MemoryDescriptor
• uefi/helpers: logger logs to debugcon device
• Add basic API for a global system table
• uefi: BootServices::allocate_pool now returns NonZero instead of *mut u8
• Fix uefi-macros trybuild test

Thanks to @stillinbeta and @andre-braga for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Fix doc comment and error message only referencing the BIOS but used for UEFI
• Ensure all page table frames are mapped as writable

Thanks to @fmckeogh and @Wasabi375 for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• fix cfg related warnings
• merge master into next
• add Mapper::clear to clear any page table entry regardless of present flag
• fix warnings

Thanks to @Wasabi375 for their contribution!

multiboot2

Maintained by @phip1611

The multiboot2 crate provides abstraction types for the multiboot information structure (MBI) of multiboot2 bootloaders. We merged the following changes this month:

• multiboot2: builder: Allow to specify SMBIOS tag multiple times
• dev: misc improvements
• release
• multiboot2: fix handling of efi memory map

Thanks to @YtvwlD for their contribution!

linked-list-allocator

Maintained by @phil-opp and @jamesmunns

The linked-list-allocator crate provides a basic no_std allocator that builds a linked list from freed memory blocks and thus needs no additional data structures. We merged the following PR this month:

• Fix warnings about cfg(fuzzing)

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

mkroening/free-list

(Section written by @mkroening)

The free-list crate provides the FreeList type for managing virtual or physical memory. Opposed to normal memory allocators, FreeList does not use pointers but page ranges. It operates by keeping a list of free page ranges (hence the name) and allows allocating at user-provided ranges. Instead of operating directly on the unallocated memory through a linked list, this free list uses statically allocated memory before dynamically allocating more memory to hold its elements.

use free_list::{FreeList, PageLayout};

let mut free_list = FreeList::<16>::new();

unsafe {
    free_list.deallocate((0x1000..0x5000).try_into().unwrap()).unwrap();
}
assert_eq!(free_list.free_space(), 0x4000);

let layout = PageLayout::from_size(0x4000).unwrap();
assert_eq!(free_list.allocate(layout).unwrap(), (0x1000..0x5000).try_into().unwrap());

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Testing Virtualization Stacks by Utilizing Mini Operating System Kernels
  Multiple mini OS kernels help Cyberus Technology to investigate issues related to complicated problems in virtualization stacks, such as never delivered interrupts. Although the Cyberus Guest Tests are written in C++, they help to find issues and problems in Cloud-Hypervisor, a VMM written in Rust. For better debugging capabilities of the Guest Tests, Cyberus Technology upstreamed support for the Debug Console to Cloud Hypervisor, which is present since v38. The source code of the Guest Tests is on GitHub.
• Redox OS - April 2024 Report
• Giving Rust a chance for in-kernel codecs
• Video: From C to Rust: Bringing Rust Abstractions to Embedded Linux
• The Embedded Rustacean Issue #17 and Issue #18
• Rust-Written LAVD Kernel Scheduler Shows Promising Results For Linux Gaming
• Video: LinuxFest Northwest 2024: Meet COSMIC DE
• New offset-allocator crate, providing a fast, simple, hard real time allocator
  • not no_std yet, but should be easy to port (only requires a Vec-like type)
• Making an RISC-V OS (Part 3): Managing free memory
• Asterinas: a secure, fast, and general-purpose OS kernel written in Rust and compatible with Linux

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• f16 and f128 step 4: basic library support
• Stabilise inline_const
• Introduce perma-unstable wasm-c-abi flag
• Stabilize (const_)slice_ptr_len and (const_)slice_ptr_is_empty_nonnull
• Add aarch64-apple-visionos and aarch64-apple-visionos-sim tier 3 targets

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

volatile

Maintained by @phil-opp

The volatile crate provides a safe wrapper type for implementing volatile read and write operations. This is useful for accessing memory regions that have side-effects, such as memory-mapped hardware registers.

We merged the following PRs this month:

• Add VolatileRef::restrict and VolatilePtr::restrict
• Add VolatileRef::borrow and VolatileRef::borrow_mut
• docs: remove unused NonNull imports
• Add support for nested map_field operations
• Add #[derive(VolatileFieldAccess)] for easy, access-limited field-based access to structs
• fix(Cargo.toml): add categories
• ci: migrate away from unmaintained actions
• Enable all features and doc_auto_cfg on docs.rs
• Release v0.5.3
• Fix warnings and deny warnings in CI
• fix(macro): support #[repr(align(N))]
• fix(access): properly seal access traits
• Release v0.5.4
• Add a semver checks CI job
• feat: introduce RestrictAccess<To> and generalize restrict to all access types
• feat: implement derive macro for all access types
• fix: add #[must_use] to volatile types, read, and as_raw_ptr

Thanks to @mkroening for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. Recently, we deprecated the [uefi-services] crate and removed all usages from the uefi repository. A new drop-in replacement exists in uefi::helpers.

The test of time showed us that having a single crate with multiple cargo features is a better and more productive way forward with less maintenance burden - for users/consumers as well as maintainers.

Please find more information in:

• https://github.com/rust-osdev/uefi-rs/pull/1128
• https://github.com/rust-osdev/uefi-rs/pull/1141

We merged the following PRs this month:

• Add timestamp protocol
• Replace some as casts
• uefi: Add UnalignedSlice::as_ptr
• Add device path text protocols to uefi-raw and re-use in uefi
• uefi-services: Fix warning with --no-default-features
• uefi: Add more derives for Handle and Event
• misc: nix/niv updates and typo updates
• doc: update fs documentation
• doc: update README
• Deprecate uefi-services and add uefi::helpers as replacement
• Fix some warnings, and ensure CI catches them in the future
• release: uefi-raw-0.5.2, uefi-0.28.0, uefi-services-0.25.0
• build(deps): bump rustls from 0.22.2 to 0.22.4
• Nuke uefi services from repository
• [Misc] Add ResetNotification protocol. Add Misc to uefi-test-runner.
• Minor import/export cleanups
• uefi: Drop the panic-on-logger-errors feature
• Replace cstr16! with a declarative macro
• Replace cstr8! with a declarative macro
• Remove xtask from MSRV build and update clap

Thanks to @sky5454 for their contributions!

ucs2-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

• Add ucs2_cstr! macro
• release: 0.3.3

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• AML: Allow Field in ToInteger (rebased)

Thanks to @rw-vanc for their contribution!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• docs: fix and detect warnings
• docs: add aliases for in{,b,w,l} and out{,b,w,l}
• ci: migrate away from unmaintained actions
• chore: migrate from legacy rust-toolchain to rust-toolchain.toml
• test: replace x86_64-bare-metal.json with x86_64-unknown-none
• fix and detect warnings
• CI: Set -Crelocation-model=static in RUSTFLAGS for bootloader test job
• silence warning about cast
• Only enable instructions on x86_64

Thanks to @mkroening for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• CI: Fix macOS errors
• [v0.9] Silence dead code warning
• [v0.9] Rename .cargo/config to .cargo/config.toml

multiboot2

Maintained by @phip1611

The multiboot2 crate provides abstraction types for the multiboot information structure (MBI) of multiboot2 bootloaders. We merged the following changes this month:

• misc: various improvements

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

RatCornu/efs

efs is a recently published no-std library which provides an OS and architecture independent implementation of some UNIX filesystems in Rust.

Currently only the ext2 filesystem is directly implemented, but I will soonly work on other filesystems!

It's still young so it may contain bugs, but it's hugely tested so that it does not happen.

Some of the features provided :

• no_std support (enabled by default)
• General interface for UNIX files and filesystems
• read/write regular files
• retrieve, add and remove directory entries directly from a path and a current working directory.

I hope you will find this useful! If you have any remark, idea or issue, do not hesitate to submit an issue!

phip1611/tar-no-std

tar-no-std supports a relevant subset of Tar archives to extract multiple files from a single Tar archive in no_std environments with zero allocations. Recently, v0.3.0 was released with support for filenames with up to 256 characters (including the directory path) and various bug fixes. Using fuzzing, a lot of pitfalls and sudden panics could be removed in this release.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• An IRC client in your motherboard
• octox: Writing a Unix-like OS in Rust
• This Month in Redox
• Redox Kernel Improvements
• MOROS 0.10.3
• The server chose violence: Hubris's oddest syscall
• Red Hat's Long, Rust'ed Road Ahead For Nova As Nouveau Driver Successor
• A memory model for Rust code in the Linux kernel
• Embedded Rust Bluetooth on ESP: BLE Client
• EtherCrab 0.4: Distributed Clocks, io_uring, Derives, Oh My
• The Embedded Rustacean: Issue 15 and Issue 16

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Add basic trait impls for f16 and f128
• Add aarch64-apple-visionos and aarch64-apple-visionos-sim tier 3 targets
• Changes to Rust's WASI targets
• RFC: patchable-function-entry was merged
• unsafe attributes RFC completed FCP
• FCP complete to stabilize raw slice len() method (slice_ptr_len, const_slice_ptr_len)
• stabilize ptr.is_aligned
• downgrade ptr.is_aligned_to crate-private
• transmute: caution against int2ptr transmutation
• New RFC: Add realign_stack attribute to rustc
• c_unwind full stabilization request: change in extern "C" behavior

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• AML: Correctly invoke _SEG,_BBN, and _ADR methods for PCI region accesses, plus assorted bits
• acpi: Add SdtHeaderIterator to get all headers.
• aml: add extra debug info on parsing error
• AML: implement boolean field

Thanks to @fslongjin and @rw-vanc for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• miscellaneous improvements
• release v0.15.0
• doc: added help on update_flags to get flags
• Feat: add constructor for InterruptStackFrameValue
• properly jump the address gap in CleanUp
• expose DEBUG_STR more directly
• add write_pcid_no_flush
• release 0.15.1
• Implement function for creating a gdt in a const environment

Thanks to @uglyoldbob, @GZTimeWalker, and @Sxmourai for their contributions!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Change gitter badge to zulip badge
• avoid 32-bit relocation to __BOOTLOADER_CONFIG

Thanks to @nicholasbishop, and @Freax13 for their contributions!

ucs2-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

• Update Cargo.toml metadata
• Add a short changelog
• Add auto-release workflow
• Set MSRV and add CI job to check it
• Improve test coverage

pic8259

Maintained by @phil-opp

The pic_8259 crate provides abstractions for 8259 and 8259A Programmable Interrupt Controllers (PICs).

We merged the following PR this month:

• Update x86_64 dependency to version 0.15.0

Thanks to @iTitus for their contribution!

ovmf-prebuilt

Maintained by @phil-opp and @nicholasbishop

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• Transition to a workspace
• Add empty ovmf-prebuilt package
• fix(deps): update rust crate clap to v4.5.4

volatile

Maintained by @phil-opp

The volatile crate provides a safe wrapper type for implementing volatile read and write operations. This is useful for accessing memory regions that have side-effects, such as memory-mapped hardware registers.

We merged the following PRs this month:

• Implement some useful traits
• Fix clippy warning about clone implementation
• Fix build with very_unstable feature
• Remove Sized requirement for Send and Sync on VolatileRef

Thanks to @nspin and @kadiwa4 for their contributions!

linked-list-allocator

Maintained by @phil-opp and @jamesmunns

The linked-list-allocator crate provides a basic no_std allocator that builds a linked list from freed memory blocks and thus needs no additional data structures. We merged the following PR this month:

• Remove stabilized feature

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• uefi: Derive Hash for all char and string types
• uefi_raw: Add firmware_storage module
• Use auto-release from crates.io to release
• uefi-services: Use "dep:" syntax
• release: uefi-raw-0.5.1, uefi-0.27.0, uefi-services-0.24.0
• Fix some new lints/warnings

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Redox OS - Porting Strategy
• This Month in Redox
• Tock Compiles on Stable Rust!
• Making an RISC-V OS (Part 2): Kernel in virtual addresses
• The Embedded Rustacean Issue 13 and Issue 14
• Linux Kernel: Rewrite the VP9 codec library in Rust
• Anouncing stabby 3.0.0

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• only set noalias on Box with the global allocator
• Add stubs in IR and ABI for f16 and f128
• f16 and f128 step 2: intrinsics
• Add armv8r-none-eabihf target for the Cortex-R52
• Add a new wasm32-wasip1 target to rustc
• Add a new wasm32-wasi-preview2 target
• rename ptr::invalid -> ptr::without_provenance

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PRs this month:

• Fix data layout in custom target used for testing
• optimize from_page_table_indices
• mark as 0.15 as beta release
• Release v0.14.12
• Fix release script
• Merge next into master: releasing v0.15.0-beta
• Update data layout of test target for LLVM 18
• optimize Step impl for VirtAddr
• Miscellaneous improvements
• Release v0.15.0

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Add a method to create a MemoryMap from a raw buffer

Thanks to @bjorn3 for their contribution!

bootloader

Maintained by @phil-opp and @Freax13

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following improvements:

• Set NO_EXECUTE flag for all writable memory regions
• [v0.9] Fix data layout for custom targets for LLVM 18
• [v0.9] Fix map errors during kernel loading
• [v0.9] Fix: unify flags if multiple segments are mapped to same frame with different flags
• Fix invalid mapping to zero page caused by off-by-one bug
• adapt data layout to match LLVM's
• Release v0.11.7
• Remove unused paging imports

Thanks to @vinc and @tsatke for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• This Month in Redox
• x86 Kernel Development & Relocatable Binaries – What I learned about Toolchains and Relocatable Code
  • This post is roughly a summary of the obscure knowledge Philipp learned about toolchains and relocatable code in the last couple of years with a focus on relocatable x86_64 multiboot2 kernels for legacy BIOS boot.
• The Embedded Rustacean Issue 11 and Issue 12
• FOSDEM 2024
  • News from the Hermit Crab — From Soundness Foundations to GPU Virtualization
  • Making VirtIO sing - implementing virtio-sound in rust-vmm project
  • The case for a virtual Rust stateless codec driver
  • An open-source, open-hardware offline finding system
• Making an RISC-V OS (Part 1): Project Setup
• Looking for people to help out with CharlotteOS (Beginners are welcome!)
• The Linux kernel now contains the first useful component written in Rust
• BPF Opens Door to Linux Extensible Scheduling (Maybe with Rust!)

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Stabilize single-field offset_of
• LLVM 18 x86 data layout update
• cargo: Strip debuginfo when debuginfo is not requested

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• expose Cr3::write_raw

We also merged the following changes into the next branch, which will be released as v0.15 soon:

• Update next branch with latest changes from master
• remove deprecated from_bits_unchecked functions
• make HandlerFuncType unsafe
• Update docs to clarify new set_handler_fn behavior

bootloader

Maintained by @phil-opp

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following nightly fixes:

• Fix data layout for stage 3 target
• Release v0.11.6
• [v0.9] Fix data layout for x86_64-bootloader target
  • Released as v0.9.24

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• Add Debug impl for PhysicalMapping even when T is not Debug

Thanks to @Spartan2909 for their contribution!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Fix broken UEFI spec link in uefi-raw README.md
• book: Add a page on building drivers
• book: Add a link to rust's UEFI target docs
• uefi-raw: Add LoadFileProtocol and LoadFile2Protocol

Thanks to @gurry for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

phip1611/phipsboot

(Section written by @phip1611)

I'd like to announce my project PhipsBoot. 🎉 PhipsBoot is a relocatable x86_64 bootloader for legacy x86_64 boot written in Rust and assembly. It is intended to be loaded by GRUB via Multiboot2, where it uncovers its main benefit: It is relocatable in physical memory without having relocation information in the ELF! It outsources a lot of complexity to GRUB which also better fits into the ecosystem and makes it easier usable. The README contains more background about why I have chosen to use GRUB instead of writing my own stage 1 bootloader.

This project combines a lot of toolchain and binary knowledge and experience I collected and gained in recent years about legacy x86_64 boot. The main contribution IMHO is how the binary is assembled and that the thing boots with all the properties described in the README, but not the high-level functionality itself.

I am especially proud of the well-commented structure of the assembly files. For example the whole page-table mappings are done IMHO very nicely even tho it is assembly language. Also, I think it turned out quite cool how I configured the linker script. I hope this can be a learning resource for others!

TL;DR: It is a learning ground and a reference for how to solve the relocation problem with Multiboot2 and GRUB, as GRUB is not able to load DYN ELFs.

You have multiple options for testing it out:

• $ cloud-hypervisor --debug-console file=log.txt --kernel ./build/phipsboot.elf64 (using Xen PVH)
• $ qemu-system-x86_64 -kernel ./build/phipsboot.elf32 -debugcon stdio (using Multiboot 1)

phil-opp/blog_os

(Section written by @phil-opp)

We merged the following changes to the Writing an OS in Rust blog this month:

• Update data layouts in target specifications
• change some format errors for chinese edition minimal kernel
• fix testing and paging introduction chapter errors in zh-CN translation
• [Edition 3] fix a lil typo
• [Edition 3] Fix typos in code for embedded_graphics crate in chapter 3
• [Edition 3] Fix embedded_graphics code + typo in chapter 3
• [Edition 3] Fix typo in chapter 2
• [Edition 3] Fix formatting in chapter 2

Thanks to @acyanbird, @proudmuslim-dev, and @lachsdachs for their contributions!

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Motūrus OS - a new Rust-based Operating System targeting virtual machines.
• Maestro is a Unix-like kernel and operating system written from scratch in Rust
• MOROS 0.10.2
• The first rust driver has been merged into netdev/net-next
• Linus on Rust in the Linux kernel (December 2023)
• Rust for Linux — in space
• A no_std client for PostgreSQL
• The Embedded Rustacean: Issue #8, Issue #9, and Issue #10
• cargo-ft (cargo filter target) is a cargo extension for specifying supported targets for a crate

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Advisory: Miscompilation with opt-level="z" on Cortex-M
• Add core::intrinsics::simd
• Stabilize ip_in_core feature
• Stabilize ptr::{from_ref, from_mut}
• Add all known target_feature configs to check-cfg
• Add -Zfunction-return={keep,thunk-extern} option
• Add lint against ambiguous wide pointer comparisons
• Add new tier 3 aarch64-apple-watchos target
• Add more SIMD platform-intrinsics

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

bootloader

Maintained by @phil-opp

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following PRs:

• Fix: Enable test runner again
• Fix: Mark ramdisk as used in memory map
• Release v0.11.5
• Embed bios and uefi binaries
• Add a take method to Optional

Thanks to @mysteriouslyseeing for their contribution!

xhci

Maintained by @toku-sa-n

The xhci crate provides types of xHCI structures, such as Registers and TRBs. We merged the following PRs this month:

• Clarify the exact behavior of RW1C setters
• PR for Misc Issue #164
• Forgot to add a changelog for #167
• A little more Doorbell renaming
• Add an issue template
• Changelog for #170

Thanks to @paulsohn for their contribution!

ovmf-prebuilt

Maintained by @phil-opp and @nicholasbishop

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• Configure Renovate
• Enable the HTTP build flag
• renovate: Change stategy to update-lockfile
• Update Rust crate anyhow to v1.0.78

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Add some new char and string convenience impls/methods
• Simplify DevicePath to_string return type
• xtask: Allow unions in uefi-raw
• uefi-raw: Add Ipv4Address, Ipv6Address, and MacAddress types
• uefi-raw: Add ServiceBindingProtocol and Dhcp4Protocol
• fs: Remove a couple debug logs
• uefi-raw: Add HttpProtocol, Ip4Config2Protocol, and TlsConfigurationProtocol
• renovate: Change stategy to update-lockfile
• xtask: Upgrade OVMF prebuilt
• Fix logger connection after opening serial protocol
• uefi-raw: Add IpAddress type

pci_types

Maintained by @IsaacWoods

The pci_types library provides types for accessing and configuring PCI devices from Rust operating systems. We merged the following change this month:

• Add functionality needed to initialize PCIe on RISC-V

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• fix: issue #200 increment local_nmi_line_count and processor_count on X2APIC

Thanks to @ytakano for their contributions!

multiboot2

Maintained by @phip1611

The multiboot2 crate provides abstraction types for the multiboot information structure (MBI) of multiboot2 bootloaders. We merged the following changes this month:

• updating header to not include multiboot with alloc
• prepare release multiboot2-header-v0.3.2

Thanks to @elbiazofor their contribution!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following changes this month:

• CI: Run semver-checks using stable Rust

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Officially Qualified - Ferrocene
• Edge IoT with Rust on ESP: NTP

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

There weren't really any OS-related infrastructure updates this month, but there was some great progress on several upcoming language and tooling features that may also be of interest to OS development:

• Stabilize C string literals
• Stabilize ptr::addr_eq
• Feature gate enums in offset_of

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Configure Renovate
• uefi-raw: Add AbsolutePointerProtocol
• Add SimpleFileSystemProtocol & file types to uefi-raw, use those types from uefi
• uefi-raw: Add API guidelines
• uefi-macros: Change uefi dev-dependency from version to path
• Add per-package changelogs
• test-runner: Improve uninstall_protocol_interface example
• Release via Github Actions workflow
• release: uefi-raw-0.5.0, uefi-macros-0.13.0, uefi-0.26.0, uefi-services-0.23.0
• uefi-raw: Fill in [un]install_multiple_protocol_interfaces pointers
• book: Use cargo add command
• doc: update PUBLISHING.md
• uefi(data-types): allow is_ascii function on Char16 and CStr16

Thanks to @RaitoBezarius for their contributions!

linked-list-allocator

Maintained by @phil-opp and @jamesmunns

The linked-list-allocator crate provides a basic no_std allocator that builds a linked list from freed memory blocks and thus needs no additional data structures. We merged the following PR this month:

• fuzz: remove potential undefined behavior in chaos harness

Thanks to @00xc for their contribution!

pic8259

Maintained by @phil-opp

The pic_8259 crate provides abstractions for 8259 and 8259A Programmable Interrupt Controllers (PICs).

We merged the following PR this month:

• docs: Remove the redundant word and space

Thanks to @zoo868e for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

No projects updates were submitted this month.

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• On the Challenge of Sound Code for Operating Systems
  • An open access paper on common patterns of unsound abstractions in operating systems when the codebase or the programmers are more familiar with C than with Rust
• Bare-metal Rust in Android
• The Binder Linux driver is being rewritten in Rust
• Microsoft is planning to make Rust a 1st class language across their engineering systems
• Vivo Unveils BlueOS, Based on Rust Language

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

There weren't really any OS-related infrastructure updates this month, but there was some great progress on several upcoming language and tooling features that may also be of interest to OS development:

• Stabilize async fn and return-position impl Trait in trait
• Distribute cg_clif as rustup component on the nightly channel
  • Faster debug builds using cranelift
• Implement gen blocks in the 2024 edition
  • Allows creating iterators through generators
• Stabilize [const_]pointer_byte_offsets
• Stabilize Ratified RISC-V Target Features
• Guarantee that char has the same size and alignment as u32
• feat: implement RFC 3127 -Ztrim-paths
  • Allows sanitizing file system paths used in panic messages → can reduce binary size
  • See RFC 3127 for details

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

spinning_top

Maintained by @phil-opp

The spinning_top crate provides a simple spinlock implementation based on the abstractions of the lock_api crate.

We merged the following changes this month:

Features

• perf: inline everything
• feat: add backoff feature
• feat: add RwSpinlock readers-writer lock
• feat: add arc_lock feature and typedefs
• Prepare for v0.3.0 release

Other

• ci: build with all features
• docs: fix typo
• test: don't ignore statics example
• chore: remove const_spinlock function
• chore: remove deprecated nightly feature

Thanks to @mkroening for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Release
• Release uefi-services-0.22.0
• uefi-raw: Use workspace dependency for uguid
• uefi/gop: fix memory leak
• Allow indexing of MemoryMap.
• uefi-services: Return event in init
• Remove unused UefiRegularFileHandle type alias
• uefi-services: Remove NonNull wrapper from system_table
• Mark free_pages and free_pool as unsafe
• uefi: Change IMAGE_HANDLE to an atomic pointer
• uefi-services: Change SYSTEM_TABLE to an atomic pointer
• Change Logger to use an atomic pointer internally
• uefi: Use atomics instead of static mut in allocator
• Use const interface pointers in protocol management functions

Thanks to @JohnAZoidberg and @JarlEvanson for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following changes this month:

• fix(interrupts): replace compiler fences with potentially-synchronizing assembly
• add `from_slice`` to VirtAddr
• Enable dependabot to update actions
• Bump actions/checkout from 3 to 4

Thanks to @Wasabi375, @joycebrum, and @mkroening for their contributions!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• aml: Implement DefOr, DefSubtract and DefLNot opcodes
• Compile for aarch64 and i686 targets on CI in addition to x86_64

Thanks to @alnyan for their contribution!

ovmf-prebuilt

Maintained by @phil-opp and @nicholasbishop

The ovmf-prebuilt project provides pre-built edk2 releases to make it easier to set up OVMF. We merged the following improvement this month:

• Dockerfile: add riscv64 with QemuBuild.py

Thanks to @Firenezz for their contribution!

bootloader

Maintained by @phil-opp

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following PRs:

• Update rustix dependency
• Add an additional MB of space to the generated FAT partition

Thanks to @kennystrawnmusic for their contribution!

linked-list-allocator

Maintained by @phil-opp and @jamesmunns

The linked-list-allocator crate provides a basic no_std allocator that builds a linked list from freed memory blocks and thus needs no additional data structures. We merged the following PR this month:

• Fix potential panic due to huge layout

Thanks to @00xc for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

RavnOS

RanvOS, (from norwegian; raven), is a operative system programmed in Rust. Aims to be; minimal, stable, secure and modern ( this maybe you know as; state-of-art ).

The objective of RavnOS is make an operative system minimalist, self hosted (no external crates, all programmed by me), stable and secure.

• October updates;
  • Minor code changes to follow good practices
• September updates;
  • Rune - Added "du" as built-in. Right now is functional but in the future I will add results sorted by size.
  • Rune - Now "ls" built-in recognize and show where points the symbolinc link
  • Rune - Added show as built-in, expanded "info" built-in with more information. Show - Deleted because now is Rune's built-in

mkroening/interrupt-mutex

(Section written by @mkroening)

Building upon last month's interrupts crate, I created a mutex for sharing data with interrupt handlers or signal handlers.

RawInterruptMutex wraps any lock_api::RawMutex, be it a parking_lot::RawMutex on Unix or a spinning_top::RawSpinlock on bare metal. When such an InterruptMutex is locked, interrupts are disabled. When the InterruptMutex is unlocked again, the previous interrupt state is restored. This does not completely rule out deadlocks, since you can just enable interrupts manually when you should not. Still, it is very convenient to just change the mutex type of data that is shared with interrupt handlers instead of disabling and enabling interrupts manually on every access.

// Make a mutex of your choice into an `InterruptMutex`.
type InterruptSpinlock<T> = interrupt_mutex::InterruptMutex<spinning_top::RawSpinlock, T>;

static X: InterruptSpinlock<Vec<i32>> = InterruptSpinlock::new(Vec::new());

fn interrupt_handler() {
    X.lock().push(1);
}

let v = X.lock();
// Raise an interrupt
raise_interrupt();
assert_eq!(*v, vec![]);
drop(v);

// The interrupt handler runs

let v = X.lock();
assert_eq!(*v, vec![1]);
drop(v);

mkroening/interrupt-ref-cell

(Section written by @mkroening)

Also building upon last month's interrupts crate, I created a RefCell for sharing data with interrupt handlers or signal handlers on the same thread.

On the same thread (software thread or hardware thread (core)), a compiler fence is sufficient for synchronization with signal handlers (on Unix) and interrupt handlers (on bare metal). In these cases, the new InterruptRefCell allows easy sharing without the overhead of mutexes and without the deadlock potential of mutexes. Similar to InterruptMutex, this is helpful for disabling interrupts on accesses but does not protect you from manually enabling interrupts while holding a reference.

use interrupt_ref_cell::{InterruptRefCell, LocalKeyExt};
 
thread_local! {
    static X: InterruptRefCell<Vec<i32>> = InterruptRefCell::new(Vec::new());
}
 
fn interrupt_handler() {
    X.with_borrow_mut(|v| v.push(1));
}

X.with_borrow(|v| {
    // Raise an interrupt
    raise_interrupt();
    assert_eq!(*v, vec![]);
});
 
// The interrupt handler runs
 
X.with_borrow(|v| assert_eq!(*v, vec![1]));

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Toolchain Upgrade - Redox OS
• Open Sourcing Ferrocene
• ESP32 Standard Library Embedded Rust: GPIO Interrupts
• The Embedded Rust ESP Development Ecosystem
• ESP Embedded Rust: Multithreading with FreeRTOS Bindings
• How Rust can build an elegant API around raw memory
• Redox: Development Priorities for 2023/24

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• Add Minimal Std implementation for UEFI
• Stdio support for UEFI
• Promote loongarch64-unknown-none* to Tier 2
• Add initial libstd support for Xous
• added support for GNU/Hurd
• MCP661: Move wasm32-wasi-preview1-threads target to Tier 2
• add notes about non-compliant FP behavior on 32bit x86 targets
• add more explicit I/O safety documentation
• Change unsafe_op_in_unsafe_fn to be warn-by-default from edition 2024
• cargo: Stabilize lint table
• Final comments period
  • Stabilize atomic_from_ptr
  • Tracking Issue for pointer_bytes_offsets
  • Add f16 and f128 float types
  • RFC: Remove implicit features in a new edition

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

multiboot2

Maintained by @phip1611

The multiboot2 was bumped from 0.18.1 to 0.19.0. The new release includes the ability to add custom tags to the MBI builder and a bugfix when parsing Multiboot strings, such as the command line from a Module tag.

For more details, please have a look at the changelog.

Thanks to @A0lson for their contribution that helped to fix the string parsing bug.

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS.

This month, a new major version of acpi was published, offering greater control over how the crate allocates memory. Specifically, the new allocator_api and alloc features allow you to opt-out of allocation altogether (allowing the crate to be used from slimmer environments like bootloaders), or to provide your own allocator using the new (and still unstable) core::alloc::Allocator API. Enabling both features makes the crate behave very similarly to before, so migration should be relatively easy.

Because the acpi crate can now be used from environements without allocation, the rsdp crate has been deprecated, and all functionality moved into acpi. The rsdp crate will continue to work, but will not receive further updates. This should not affect users using rsdp to simply find the address of the RSDP, but is a breaking change as types that have been moved to acpi will no longer be usable across the crate boundary.

Some improvements were also made to the aml crate this month, adding functionality and improving our correctness

• many thanks to our contributors!

We merged the following changes this month:

• AML: Implement OpReg-relative PkgLength parser
• AML: Fix DefPackage len less than NumElements failing
• Prepare new version of acpi
• AML: add support for the DefSleep opcode
• AML: add support for the DefStall opcode

Thanks to @alnyan for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• fix(interrupts): add compiler fences to enable and disable
• add flush_broadcast and tlbsync functions
• Release v0.14.11
• Add HandlerFuncType trait

Thanks to @brandonchinn178 and @mkroening for their contributions!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Add ShellParams protocol
• github: Change dependabot interval to weekly

Thanks to @JohnAZoidberg for their contribution!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

mkroening/interrupts

(Section written by @mkroening)

I created a dependency-free interrupts crate, allowing you to temporarily disable interrupts on AArch64, 64-bit RISC-V, and x86-64. Two different paradigms allow you to run code without interrupts and synchronize with interrupt handlers running on the same hardware thread (core):

Use disable to disable interrupts with a guard:

// interrupts may or may not be enabled
let guard = interrupts::disable();
// interrupts are disabled
drop(guard);
// interrupts are restored to the previous state

Use without (similar to x86_64::instructions::interrupts::without_interrupts) to run a closure with disabled interrupts:

// interrupts may or may not be enabled
interrupts::without(|| {
    // interrupts are disabled
});
// interrupts are restored to the previous state

I would appreciate you dropping by and giving it a try. :)

Join Us?

Are you interested in Rust-based operating system development? Our rust-osdev organization is always open to new members and new projects. Just let us know if you want to join! A good way for getting in touch is our Zulip chat.

This series is openly developed on GitHub. Feel free to open pull requests there with content you would like to see in the next issue. If you find some issues on this page, please report them by creating an issue or using our comment form at the bottom of this page.

Announcements, News, and Blog Posts

Here we collect news, blog posts, etc. related to OS development in Rust.

• Fomos: Experimental OS, built with Rust
  • Discussion on HN, reddit, lobste.rs
• Interview with Rust and operating system Developer Andy Python

Redox Summer of Code

• Redox Summer of Code Wrapup
• VirtIO drivers for Redox in a VM - Andy-Python-Programmer: Part 1 and Part 2
• On-Demand Paging for Redox - 4lDO2: Part 1 and Part 2
• Using Linux drivers in a VM on Redox - Enygmator: Overview

Infrastructure and Tooling

In this section, we collect recent updates to rustc, cargo, and other tooling that are relevant to Rust OS development.

• WASI threads, implementation of `wasm32-wasi-preview1-threads`` target
• Re-enable atomic loads and stores for all RISC-V targets
• Update to LLVM 17
• feat: riscv-interrupt-{m,s} calling conventions
• Add the relocation_model to the cfg
• Default relax_elf_relocations to true
• add aarch64-unknown-teeos target
• cargo: Add support for target.'cfg(..)'.linker
• cargo: Support dependencies from registries for artifact dependencies, take 2

rust-osdev Projects

In this section, we give an overview of notable changes to the projects hosted under the rust-osdev organization.

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi-rs crate provides safe and performant wrappers for UEFI, the successor to the BIOS. We merged the following PRs this month:

• Drop memmove and set_mem from boot services
• Add block I/O protocol to uefi-raw and use it in uefi
• uefi-raw: Rename BlockIo to BlockIoProtocol
• Add raw memory protection protocol and use in uefi
• Use workspace.dependencies to declare shared dependencies
• Add component name protocol to uefi-raw and use from uefi
• Implement core::error::Error for all error types
• Fix 1.72 lints
• Derive Debug in more places (requires Rust 1.70)
• Memory map change

Thanks to @cmoylan and @julic20s for their contributions!

bootloader

Maintained by @phil-opp

The bootloader crate implements a custom Rust-based bootloader for easy loading of 64-bit ELF executables. This month, we merged the following PRs:

• kernel image fields & zero out rbp
• RacyCell<T>: Data race allowed on T
• Update license field following SPDX 2.1 license expression standard

Thanks to @frisoft, @devsnek, and @kuzeyardabulut for their contributions!

x86_64

Maintained by @phil-opp, @josephlr, and @Freax13

The x86_64 crate provides various abstractions for x86_64 systems, including wrappers for CPU instructions, access to processor-specific registers, and abstraction types for architecture-specific structures such as page tables and descriptor tables.

We merged the following PR this month:

• Add inline attribute to segment functions
• Add the iretq function to the InterruptStackFrameValue struct.
• Fix misc doc typos

Thanks to @tsoutsman, @NathanKolpa, and @xzmeng for their contributions!

acpi

Maintained by @IsaacWoods

The acpi repository contains crates for parsing the ACPI tables – data structures that the firmware of modern computers use to relay information about the hardware to the OS. We merged the following changes this month:

• AML: DefSizeOf implementation
• AML: Fix DefIfElse parser returning UnexpectedEndOfStream when If (...) {} is not followed by anything

Thanks to @alnyan for their contributions!

uart_16550

Maintained by @phil-opp

The uart_16550 crate provides basic support for serial port I/O for 16550-compatible UARTs. We merged the following change this month:

• x86: crate finally builds with x86 and x86_64

Thanks to @phip1611 for their contributions!

Other Projects

In this section, we describe updates to Rust OS projects that are not directly related to the rust-osdev organization. Feel free to create a pull request with the updates of your OS project for the next post.

mkroening/take-static

(Section written by @mkroening)

I published a tiny new crate, allowing you to get a mutable reference to static items safely (only once, though):

use take_static::take_static;

take_static! {
    static NUMBER: usize = 5;
}

assert_eq!(NUMBER.take(), Some(&mut 5));
assert_eq!(NUMBER.take(), None);