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);

This allows you to easily use statically allocated memory before dynamic memory allocators may be available. Compared to cortex_m::singleton, take_static is thread-safe. Compared to takecell::TakeCell, take_static also supports !Send types.

hermit-os/kernel

(Section written by @mkroening)

The Hermit unikernel project allows you to bundle your Rust application with our library operating system to create a bootable unikernel image. Hermit is a single-address-space operating system. Since there is only one application running in the virtual machine, no isolation between applications or between user space and kernel space is necessary. This reduces system call overhead immensely, since every system call is just a library call. For more information, see our The Hermit Operating System showcase post.

The RustyHermit project has been renamed. We have renamed our GitHub organization from @hermitcore to @hermit-os and reserved the http://hermit-os.org domain.

We have also renamed some of our core projects to reduce confusion:

• hermit-os/kernel is the Hermit kernel.
• hermit-os/hermit-rs provides Rust application support.
• hermit-os/uhyve is a specialized hypervisor for Hermit.
• hermit-os/loader is a bootloader for other platforms, such as QEMU.

We have a new logo! As hermit crabs occupy empty shells produced by other organisms, the original HermitCore occupied one or several cores on a computer. Because we migrated to Rust in 2018, our new logo of a hermit crab occupying the Rust logo's bike gear fits quite nicely with the Rust logo as well as Rust's Ferris.

And as always, please come and try Hermit! :)

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 2 with beginner friendly cargo tips
• Grammar fix
• minimal-rust-kernel: fix missing .toml in zh-CN translation

Thanks to @Connortsui20 and @xzmeng for these 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.

• Mutex without lock, Queue without push: cancel safety in lilos
• Kani 0.32.0 has been released! (verification tool for unsafe code blocks)
• bwrap: A fast, lightweight, embedded environment-friendly Rust library for wrapping text
• ESP32 Standard Library Embedded Rust
  • GPIO Control
  • UART Communication
  • I2C Communication
• allocator_api2 crate to use Rust's nightly allocator API 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.

• Enable chkstk/alloca intrinsics on x86_64-unknown-uefi
• Add riscv64gc-unknown-hermit target
• Add x86_64-unikraft-linux-musl target
• Optimize AtomicBool for target that don't support byte-sized atomics

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.16.0 to 0.17.0. The new release includes the builder pattern for the MBI builder and the ability to use custom memory types in the memory map in addition to pre-defined ones. For more info, look here.

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:

• Cargo.lock: Update proc-macro2 to fix nightly CI
• Return a SimpleFileSystem from BootServices::get_image_file_system
• uefi-raw: Derive Ord, PartialOrd, and Hash for all newtype enums
• Add GraphicsOutputProtocol to uefi_raw and use it from uefi
• uefi: Use uefi_raw's SimplePointerProtocol to implement Pointer
• build(deps): bump regex from 1.8.1 to 1.9.0
• Fix target_arch name: i386 -> x86
• Add some uefi-raw links/badges
• Fix a new lint in 1.71
• Add raw serial protocol and use it in uefi
• Add raw disk protocols and use them in uefi
• uefi: Change try_exists to return FileSystemResult
• dependabot: Enable updates for Github Actions
• Rework FileSystem::copy to operate on 1MiB chunks
• build(deps): bump crate-ci/typos from 1.13.20 to 1.16.1
• ci: Add merge_group trigger
• build(deps): bump cachix/install-nix-action from 20 to 22
• add event to smp

Thanks to @devsnek 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:

• Switch Clippy runner on CI
• Fix wrong calculation of data_buffer_pointer of transfer::Normal
• Release 0.9.2

Thanks to @lemolatoon 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:

• Add Descriptor::tss_segment_unchecked

Thanks to @SamZhang3 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 released a new patch version to fix the build on the latest nightlies:

• Run cargo update to fix build on nightly
• Release v0.11.4

ovmf-prebuilt

Maintained by @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:

• Dockerfile: use QemuBuild.py for aarch64 build

Thanks to @nicholasbishop 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.

SFBdragon/talc

(Section written by @SFBdragon)

Talc is a recently published, fast, and flexible no-std memory allocator.

• It's the fastest allocator I've tested as of yet (galloc falls short, buddy_alloc is close but lacks heap efficiency).
• It features a OOM-handling component with dynamic arena resizing.

By the time you're seeing this, hopefully v2 should be out or coming soon:

• The OOM handler system has been made more powerful.
• lock_api is used to allow for custom allocator synchronization.
• The internals and API has been improved to pass miri's stacked borrows validation.
• You can now move the allocator struct around freely.
• And more :3

I hope you find it useful!

vinc/moros

(Section written by @vinc)

MOROS is a text-based hobby operating system targeting computers with a x86-64 architecture and a BIOS.

Since last month's release, I focused on adding new syscalls to interact with network sockets from userspace. The DNS and HTTP clients are now using the new UDP and TCP sockets.

I also added another syscall to poll multiple handles at the same time, to read from the console and a socket, improving the main network tool that can now be used as a simple chat program.

The VGA driver, the filesystem, and the editor got a few significant improvements as well, to support downloading and reading larger files.

valibali/cluu

(Section written by @phil-opp)

There is a new project featured in our Showcase series:

• CLUU (Compact Lightweight Unix Utopia) by @valibali

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 elects its first Board of Directors
• Frida 16.1.0 Released
• Intercepting Allocations with the Global Allocator
• Building an out-of-tree Rust Kernel Module Part Three
• Discussion: How hard would it be to port the Rust toolchain to a new non-POSIX OS written in Rust and get it to host its own development?
• Discussion: Will there be fewer jailbreaks in the future if operating systems like iOS start adopting rust?

Infrastructure and Tooling

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

No updates were proposed 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.

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 or framebuffers.

Unfortunately, the design crate had a soundness issue because it used reference types for accessing the volatile memory. This is problematic because the Rust compiler marks references are "dereferenceable", which allows LLVM to insert spurious read operations. This is fine for accessing "normal" memory, but it can lead to correctness issues when used in combination with memory-mapped device registers. These registers look like normal memory, but they are actually accessing some device-specific registers, which might change at any time. So they might change between spurious reads, which violates the assumptions of LLVM and can lead to undefined behavior.

To solve this issue, we started a full redesign of the crate that uses raw pointers only. This solves the issue because raw pointers are not considered "dereferenceable", so LLVM is not allowed to insert spurious reads. While we started working on the new design more than 2 years ago, we didn't merge it until this month because we weren't sure about the implementation details. The main discussion point was whether we should treat the proposed VolatilePointer type like Rust's reference types or like Rust's raw pointer types. The difference is that raw pointers implement the Copy trait, but are not Send to prevent aliasing. References, on the other hand, can safely implement Send because they're only Copy if the reference is read-only.

After a lot of back and forth, we decided to provide both options and finally publish volatile v0.5. So the new design has two wrapper types, VolatilePtr (behaves like a raw pointer) and VolatileRef (behaves like a reference). We hope that we support most use cases this way!

Note that there is also some ongoing discussion about a potential VolatileCell type to wrap values in-place. Most implementations of such a type would require support from the Rust compiler, which needs an RFC. However, there is one promising design based on zero-sized types and proc-macros by @Freax13 that should not require any new language features. We will continue to investigate.

multiboot2

Maintained by @phip1611

The multiboot2 and the multiboot2-header crates got a big overhaul. The list of new features includes but is not limited to:

• use DSTs for tags where applicable (#134)
• model the MBI as DST (#155)
• add a runtime builder for an MBI (#133)
  Huge thanks to YtvwlD / Niklas for this great external contribution
• added an integration test including a multiboot2 chainloader for better test coverage (#129)
• added miri to the CI for more memory safety (#128)
• several fixes and small improvements

multiboot2 was updated from 0.15.1 to 0.16.0 and multiboot2-header was updated from 0.2.0 to 0.3.0. Both releases come with a large amount of breaking changes. However, after a sensible consideration, they are all worth it for a more streamlined API and more memory safety.

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:

• Change Star::write() to use checked subtractions
• Bump bitflags to 2.3.2
• add workaround for recursive page tables with recursive index 511
• Fix off-by-one in documentation

Thanks to @Qix-, @grant0417, and @Egggggg for their contributions!

vga

Maintained by @RKennedy9064

The work-in-progress vga crate allows the configuration of the VGA hardware, e.g. switching from text-based mode to a pixel-based graphics mode. This month, we merged the following pull request:

• implement a draw_rect function

Thanks to @tsatke for their contribution!

uefi-rs

Maintained by @GabrielMajeri, @nicholasbishop, and @phip1611

The uefi crate provides safe and performant wrappers for UEFI, the successor to the BIOS firmware. It empowers everyone to write EFI- applications with Rust in a convenient way, such as your own bootloader.

In June, we added multiple small improvements for developers using Nix(OS) and simplifications for working with device paths. Additionally, we moved more definitions to the new uefi-raw crate.

Furthermore, we'd like to mention the new high-level File-System API. It was merged in April actually, but not mentioned in this newsletter so far. Feel free to give it a try!

We merged the following PRs this month:

• Release uefi-raw-0.2.0, uefi-0.22.0, and uefi-services-0.19.0
• Fix various CI failures
• uefi: Fix wrong install_configuration_table() signature
• Release uefi-0.23.0 and uefi-services-0.20.0
• build(deps): bump tempfile from 3.5.0 to 3.6.0
• device_path: add more convenience (part 2)
• Make UEFI shell protocols testable
• Add DevicePathProtocol to uefi-raw
• Integration test for boot service function load_image
• cargo: Use [workspace.package] to deduplicate metadata
• uefi: Update MSRV policy language
• uefi: Remove some uses of MaybeUninit in BootServices
• nix: add more convenience for Nix/NixOS users
• ci: Fix developer_productivity push error
• uefi-raw: Add BootServices table
• uefi: Add raw pointer Event/Handle methods
• uefi: Make BootServices fn ptrs unsafe
• xtask: add "cargo xtask fmt" (and formatting for nix and yml files)
• build(deps): bump ureq from 2.6.2 to 2.7.0
• uefi-raw: Fix arg type in connect_controller
• uefi: Improve support for null protocol interfaces
• uefi: Make BootServices a wrapper around uefi_raw::table::boot::BootServices
• uefi-raw: Add common derives to EventType
• xtask: Improve an error location in check-raw
• uefi-raw: Add ConfigurationTable
• uefi-raw: Add SimpleTextInputProtocol and SimpleTextOutputProtocol
• uefi-raw: Add SystemTable
• uefi-raw: Fill in a few more BootServices function pointers
• uefi-raw: derive all the things
• device_path: add more convenience (part 1)
• Release uefi-raw-0.3.0, uefi-0.24.0, uefi-services-0.21.0
• uefi-raw: Add LoadedImageProtocol
• uefi: Check for null pointer in config_table
• test-runner: Simplify an iterator chain
• build(deps): bump itertools from 0.10.5 to 0.11.0
• uefi: Use uefi_raw's SimpleTextInputProtocol in Input
• uefi: Use uefi_raw's SimpleTextOutputProtocol in Output
• uefi: Use uefi_raw's LoadedImageProtocol to implement LoadedImage
• uefi: Fix warnings when compiling without the alloc feature
• uefi-raw: Add SimplePointerProtocol
• uefi: Use uefi_raw's SystemTable to implement SystemTable

Thanks to @medhefgo 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.

hermitcore/rusty-hermit

(Section written by @mkroening)

The Hermit library operating system allows you to bundle a whole OS directly with your application, creating a freestanding, bootable Unikernel image. This month, we achieved several milestones for reaching more users with Hermit:

• Stable Rust support.

  You can now compile your programs for Hermit using the stable Rust toolchain! 🥳

  While the Hermit targets (x86_64-unknown-hermit and aarch64-unknown-hermit) are still at tier 3, we now distribute pre-built artifacts of the Rust standard library for use with stable toolchains! This means, no more -Zbuild-std, resulting in faster builds, and the bliss of the stable Rust compiler.

  See hermitcore/rust-std-hermit for details on our rust-std artifacts.

• Windows support.

  Thanks to Rust's awesome cross-compilation capabilities, you can now compile Hermit applications from anywhere! 😎

  We have resolved a longstanding issue when building Hermit applications on Windows (hermitcore/rusty-hermit#431). The issue is all sorted out now and Windows, macOS, and Linux are tested and verified by our CI.

• AArch64 (ARM64) support.

  You can now run real applications on AArch64, with scheduling, network and everything! 🤯

  • PCI now works on AArch64, which allows us to use the network devices (hermitcore/libhermit-rs#748).

  • We merged scheduling support for AArch64 (hermitcore/libhermit-rs#765).

  • You can also now chainload Hermit apps for AArch64 using our loader (hermitcore/rusty-loader#201).

    This means, you don't have to statically compile the full application into the final loader image anymore.

We'd love if you gave Hermit a try. Just start with our "Hello, World!" application template: hermitcore/rusty-demo.

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.

CLUU is a hobby operating system being written in Rust - in the active development phase - targeting x86_64 and with plans to support aarch64 in the future. The project is made for fun and joy, drawing inspiration from various operating systems and projects while incorporating unique approaches and ideas.

Motivation

CLUU is driven by the motivation to explore operating system development in a powerful language like Rust. The project seeks to break away from the traditional approach using languages like C, which can sometimes feel limiting or mundane. With CLUU, the goal is to embark on a learning journey and have fun in the process. Contributions from the community are highly encouraged and welcomed.

Project Information

CLUU draws inspiration from the following operating systems:

• Plan 9: Plan 9 from Bell Labs is a distributed operating system developed at Bell Labs in the late 1980s. It provides a unique approach to system organization, with a focus on simplicity and distributed computing.
• BSD: FreeBSD is a modern, advanced operating system for x86 and ARM architectures. It offers a rich feature set and has a long history of stability and reliability.

As well as heavily influenced by the following projects:

• RedoxOS: RedoxOS is an operating system written in Rust, aiming to bring the innovations of Rust to a modern microkernel and full set of applications. It's fair to say it is the most advanced of all Rust OS-es.
• k4dos: k4dos is another hobby-os of that sort, it's fairly cool, with userspace, that can run FreeDoom for example. It has a nice shell implementation: kash
• blog_os: blog_os is a cutting-edge project by Philipp Oppermann that provides a detailed tutorial on building an operating system in Rust. It covers various aspects, including the bootloader, memory management, and device drivers.

CLUU aims to create a UNIX-like operating system, although not plannig to fully adhere to the POSIX standards. The goal is to get as close to the UNIX philosophy and compatibility as possible. This would enable easier porting of Linux software to CLUU and provide a familiar environment for developers.

Current State and Goals

CLUU is currently in the early stages of development, with the focus on building a solid foundation for the operating system. At this stage, the following basic functionalities have been implemented:

• UART16550 driver: A driver for UART16550, allowing communication with the serial port for debugging and logging purposes.
• Preparation for PIO and MMIO: The groundwork has been laid for implementing both Programmed I/O (PIO) and Memory-Mapped I/O (MMIO) for interacting with hardware devices.
• Framebuffer driver: A driver for the framebuffer, providing a graphical output display.
• Simple graphics and writing: Basic graphical capabilities have been implemented, allowing for drawing and writing on the screen using a PSF font.
• Basic Logging framework: A basic logging framework has been developed to facilitate debugging and information output during the development process.

As the project progresses, the focus will shift towards implementing additional features, such as:

• Kernel Implementation: Further development of the microkernel's core functionality, including process management, interprocess communication, and resource management.
• Device Drivers: Continued development of drivers for essential hardware components, including keyboard, storage devices, and other peripherals.
• Filesystem Support: Introducing filesystem support to enable file I/O operations and provide a foundation for user-level processes and applications.

The project remains open-source, and contributions from the community are highly encouraged. If you're interested in exploring the code, contributing enhancements, or reporting issues, please visit the GitHub repository.

License

CLUU is licensed under the MIT License. See LICENSE for more information.

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.

Infrastructure and Tooling

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

No updates were proposed for this section this month.

Announcements, News, and Blog Posts

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

• RTIC (The hardware accelerated Rust RTOS) releases v2.0.0!
• My Rust OS for microcontrollers now has a dir command
• First Rust Code Shows Up in the Windows 11 Kernel
• May Flowers Spring COSMIC Showers
• Ironclad-Shell: a "shell" made in rust and for OS classes
• This moment in mnemos
  • An update/introduction on the current state of mnemos, an async-first hobby OS

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: Switch Rng repr from C to transparent
• uefi: Make MEMORY_DESCRIPTOR_VERSION an associated constant
• macros: allow to create empty cstr8/16 slices
• Add Revision to uefi-raw and use it from uefi
• Add Tpl to uefi-raw and use it from uefi
• Add PhysicalAddress/VirtualAddress to uefi-raw and use them from uefi
• cstr16: add method to get the underlying bytes
• Move various memory types to uefi-raw and re-export in uefi
• uefi/fs: add path and pathbuf abstraction
• uefi: Clear the Vec in DevicePathBuilder::with_vec
• uefi-macros: Restore entry macro tests
• Add LoadedImageDevicePath protocol
• fs: add new error type
• deps: bump bitflags from 1.0 to 2.1
• uefi-macros: Fix entry macro with docstring
• fs: implement remove_dir_all
• uefi-raw: Drop dep on uefi-macros
• Disable some tests on aarch64
• allocator: Use appropriate memory types
• Release branch
• uefi: Rename FileSystemIOErrorContext to IoErrorContext
• uefi: Improve fs error Display impls, drop derive_more
• Move InterfaceType to uefi-raw
• uefi-raw: Add table Header struct
• build(deps): bump bitflags from 2.2.1 to 2.3.1
• Relax bitflags dep version to 2.0.0
• xtask: Drop an unused test file
• xtask: Improve QEMU boot time
• Move some runtime services types to uefi-raw
• Fix and enable uefi-raw unit/doc tests
• Add Time to uefi-raw and use it from uefi
• uefi-raw: Add Char8/Char16
• uefi: Fix use of tuples in pointer structs
• build(deps): bump clap from 4.2.7 to 4.3.0
• uefi(boot_services): add install_configuration_table
• xtask: Add check-raw
• uefi-raw: Add Update Capsule types
• Download OVMF files rather than relying on distro package
• Export FileInfoCreationError
• Move EventType to uefi-raw
• uefi: Derive Eq for Handle
• Add RuntimeServices definition to uefi-raw and use it from uefi
• loaded_image: Add set_unload
• uefi: Change file reading to read in 1 MiB chunks

Thanks to @RaitoBezarius and @medhefgo for their contributions!

multiboot2

Maintained by @IsaacWoods, @phip1611, @robert-w-gries, @ahmedcharles, and @Caduser2020

• add missing functionality in multiboot2-header (finding the header, getting tags)
• multiboot2: properly type DST tags
• Add BasicMemoryInfo and SMBIOS tags
• multiboot2: Add the end tag

Thanks to @YtvwlD for their contributions!

vga

Maintained by @RKennedy9064

• implement Graphics1280x800x256

Thanks to @tsatke for their contribution!

ovmf-prebuilt

Maintained by @phil-opp

• Rework the repo to build edk2 release tags

Thanks to @nicholasbishop for this contribution!

acpi

Maintained by @IsaacWoods

• rsdp: Make whole RSDP readable
• Clean up allocator_api feature
• acpi: fix length of "extended_area_bytes" in RSDP search

Thanks to @YtvwlD, @semiviral, and @A0lson for their contributions!

pci_types

Maintained by @IsaacWoods

• add function to determine the inteerupt pin and interrupt line

Thanks to @stlankes for their contributions!

bootloader

Maintained by @phil-opp

• Use cargo-semver-checks-action

Thanks to @mgr0dzicki 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 panics caused by misaligned pointer dereferences in "Double Faults" & "Introduction to Paging"
• Correcting typos and errors in French translation of Post 1
• posts/06-double-faults/index: fixup deprecated fn

Thanks to @SPuntte, @Firenezz, and @twilfredo for these contributions!

There wasn't much progress on the upcoming third edition this month, as I've been on vacation for the past few weeks. I still have a lot of catching up to do, but I'll try my best to continue writing soon :).

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.

Infrastructure and Tooling

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

No updates were proposed for this section this month.

Announcements, News, and Blog Posts

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

• Rust Kernel Programming
• Linux Kernel Rust Modules
• Aero OS: A new modern operating system made in Rust, now able to run the Links browser, Alacritty and much more!
• Felix, an x86 hobby OS written in Rust

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

Features

• Introducing a high-level FS abstraction
• uefi: debug: add DebugPort protocol
• uefi: Panic if an error is created from Status::SUCCESS
• uefi-macros: Drop !Send and !Sync from unsafe_protocol macro
• cstr[ing]16: convenience functions
• uefi: Clean up some Status -> Result conversions
• Use the uguid crate to replace the Guid struct and guid! macro
• gop: Derive PartialEq on ModeInfo
• Add RngProtocol to uefi-raw and use it from uefi
• uefi: Add get_variable_boxed

Docs

• uefi: Update Status documentation
• doc: build with --no-deps
• uefi: Minor cleanups in the fs module doc