Lib.rs

ax-page-table-multiarch

Generic page table structures for various hardware architectures

ax-memory-set

Data structures and operations for managing memory mappings

x86_vlapic

x86 Virtual Local APIC

axklib

Small kernel-helper abstractions used across the microkernel

ax-driver-block

Common traits and types for block storage drivers

ax-driver-virtio

Wrappers of some devices in the virtio-drivers crate, that implement traits in the ax-driver-base series crates

arm_vgic

ARM Virtual Generic Interrupt Controller (VGIC) implementation

ax-errno

Generic error code representation

shpool

mechanism for establishing lightweight persistant shell sessions to gracefully handle network disconnects

ax-fs-vfs

Virtual filesystem interfaces used by ArceOS

axhvc

AxVisor HyperCall definitions for guest-hypervisor communication

ax-fs-ramfs

RAM filesystem used by ArceOS

oxios

Agent OS — Agent Operating System powered by oxi-sdk

riscv_vplic

RISCV Virtual PLIC implementation

axdevice

A reusable, OS-agnostic device abstraction layer designed for virtual machines

rust-apt

Bindings for libapt-pkg

uv-platform

internal component crate of uv

rusty-tip

Nanonis SPM system control via TCP

wasmtime-cli-flags

Exposes common CLI flags used for running Wasmtime

rattler

install conda environments

pib-service-api-permissions-inventory

pib-service edit API permission enforcement system - inventory-based backend

lean-rs-host

Opinionated Rust host stack for embedding Lean 4 as a theorem-prover capability: typed sessions, kernel-check evidence handles, bounded MetaM services, progress, batching, and session pooling

axvisor

A lightweight type-1 hypervisor based on ArceOS

qos_core

Core components and logic for QuorumOS applications

axplat-dyn

A dynamic platform module for ArceOS, providing runtime platform detection and configuration

axbuild

An OS build lib toolkit used by arceos

runtimo-core

Agent-centric capability runtime with telemetry, process tracking, and crash recovery for persistent machines

ax-mm

ArceOS virtual memory management module

ax-runtime

Runtime library of ArceOS

ax-dma

ArceOS global DMA allocator

ax-input

Input device management for ArceOS

ax-display

ArceOS graphics module

wasmtime-wizer

The WebAssembly Pre-Initializer

dma-api

Trait for DMA alloc and some collections

ax-arm-pl031

System Real Time Clock (RTC) Drivers for aarch64 based on PL031

ax-driver-net

Common traits and types for network device (NIC) drivers

ax-cpu

Privileged instruction and structure abstractions for various CPU architectures

procpilot

Production-grade subprocess runner with typed errors, retry, and timeout

mmio-api

Memory-mapped I/O abstraction API for OS kernel development

arceos-rust-interface

Arceos ABI definitions

epics-rs

Pure Rust EPICS control system framework

ax-plat-aarch64-peripherals

ARM64 common peripheral drivers with axplat compatibility

use-thread-name

Primitive thread name and count vocabulary for RustUse

use-os

Facade crate for primitive RustUse OS-facing vocabulary

ax-fs-devfs

Device filesystem used by ArceOS

use-architecture

Primitive CPU and target architecture vocabulary for RustUse

use-platform

Primitive platform identity and target triple vocabulary for RustUse

lighty-core

Core utilities for Lighty Launcher

use-env-key

Primitive environment variable key vocabulary for RustUse

use-thread-id

Primitive thread identity label vocabulary for RustUse

ax-lockdep

Lock dependency tracing helpers for ArceOS components

ax-api

Public APIs and types for ArceOS modules

skillfile-deploy

Platform adapters and installation for skillfile

uboot-shell

communicating with u-boot

ax-kspin

Spinlocks used for kernel space that can disable preemption or IRQs in the critical section

use-env-value

Primitive environment variable value and pair vocabulary for RustUse

ax-cap-access

Provide basic capability-based access control to objects

edera-check

CLI to run checks before installing or using Edera

htmos-boot-info

The Boot Information required when booting into HTMOS

ax-driver-input

Common traits and types for input device drivers

zerobox

Sandbox any command with file, network, and credential controls

scope-local

Scope local storage

onyx-rs

Cross-platform toolkit for building desktop applications without rewriting OS-specific glue every time

ax-ipi

ArceOS IPI management module

axplat-x86-qemu-q35

Hardware platform implementation for x86_64 QEMU Q35 chipset, supporting multiboot boot protocol

ax-plat-x86-pc

axplat hardware abstraction layer for x86 Standard PC machine

axplat-riscv64-qemu-virt-hv

Hardware platform implementation for the RISC-V64 QEMU virt machine used by AxVisor

nokhwa

A Simple-to-use, cross-platform Rust Webcam Capture Library

ax-riscv-plic

RISC-V platform-level interrupt controller (PLIC) register definitions and basic operations

tauri-plugin-gamepad

A plugin for Tauri that provides a polyfill for Gamepad Web API that works on most common platforms

ax-arm-pl011

ARM Uart pl011 register definitions and basic operations

rattler_sandbox

run executables in a sandbox

elicit_winit

Elicitation-enabled winit code-generation tools for windowing and input

lox-comms

Communication systems and link budget analysis for the Lox ecosystem

konfigkoll_types

Type definitions for konfigkoll backend (internal helper crate)

ax-page-table-entry

Page table entry definition for various hardware architectures

ax-kernel-guard

RAII wrappers to create a critical section with local IRQs or preemption disabled

arm-scmi-rs

ARM SCMI (System Control and Management Interface) protocol implementation for no_std embedded environments

lex-fmt

Canonical Rust embedder API for the lex document format. Hosts Engine::builder() plus the boot helpers shared by lexd and lexd-lsp.

alumy

A batteries-included Rust SDK for rapid application development. Logging, system utilities, and filesystem helpers — all ready to use.

sbi-rt

Runtime library for supervisors to call RISC-V Supervisor Binary Interface (RISC-V SBI)

zellij

A terminal workspace with batteries included

elf_loader

A no_std-friendly ELF loader, runtime linker, and JIT linker for Rust

sldo-common

Shared library for the SunLit Orchestra (SLO) skill-pack tooling — utilities used by sldo-install and sldo-research

libkernel

Architecture-independent kernel building blocks for operating systems

atuin-common

common library for atuin

sbi-testing

Provide a set of test cases for supervisors to verify functions of the supervisor executation environment

atuin-server

server library for atuin

aqua-registry

Aqua registry backend for mise

runkon-notify

Domain-neutral notification dispatch primitives — generic event envelope, shell/HTTP hook execution, glob pattern matching, and web-push subscription store

syspeek

A fast and simple system information library for CPU, GPU, RAM, battery, disk, network, packages, and OS info

runkon-runtimes

Portable agent runtime harness — spawn, poll, and cancel agents without depending on a host orchestrator's full domain

ebi_objects

Objects for Ebi - a stochastic process mining utility

ranges-ext

Extensions for core::ops::Range and related types

palo-projects

Project discovery and initialization adapters for Palo

kernutil

kernel development

sp1-gpu-sys

FFI bindings and CUDA build system for SP1-GPU

lightspeed_scheduler

An in-process scheduler for periodic jobs. Schedule lets you run Rust functions on a cron-like schedule.

repo

An opinionated tool for repo management

execra

Typed job runtime for Rust apps that wrap external CLI tools: events, interpreters, cancellation, Tauri integration, and optional persistence

pinget-core

Pure Rust Pinget core library that works directly with source caches, REST endpoints, and installed package state without COM

boltpm

A blazing fast package manager and CLI tool

yosh-plugin-api

WIT package and capability definitions for yosh plugins

kasm-aarch64

AArch64-specific assembly macros for kernel development

ax-memory-addr

Wrappers and helper functions for physical and virtual addresses

perl-subprocess-runtime

Shared subprocess execution abstraction with OS and mock runtimes

ax-driver-base

Common interfaces for all kinds of device drivers

somehal-macros

SomeHAL-related procedural macros

ax-driver-display

Common traits and types for graphics device drivers

ax-driver-vsock

Common traits and types for vsock drivers

ax-driver-pci

Structures and functions for PCI bus operations

memory_addresses

Unified virtual and physical address types for the Hermit ecosystem and beyond

hyperlight-guest-bin

opinionated bits of the guest library, such as the panic handler, the entry point, the guest logger, the exception handling logic, and third-party code used by our C-API needed to build a native hyperlight-guest binary

axpanic

Shared panic and oops state helpers for ArceOS components

arf-harp

High-level R abstractions for safe R object manipulation

hermit-entry

Hermit's loading and entry API

hitrace

Safe bindings to the HiTrace tracing system of OpenHarmony

nexus-memory-agent

Always-on memory agent for Nexus Memory System

osdk-test-kernel

The OSTD-based kernel for running unit tests with OSDK

nexus-memory-orchestrator

Orchestrator core for Nexus Memory System - session management, event bus, and cross-agent sync

redox_syscall

access raw Redox system calls

ksym

generating symbol tables for operating systems

aarch64_sysreg

Address translation of system registers

cargo-axplat

Manages hardware platform packages using axplat

releasaurus-core

A comprehensive release automation tool that streamlines the software release process across multiple programming languages and forge platforms

tauri-plugin-fcm

Tauri 2 plugin for Firebase Cloud Messaging

cast-os-stdlib

Experimental: A curated library of reusable OS-level architectural concepts expressed in cast vocabulary. Downstream OS/kernel/cluster projects pull this in and reference its concepts via cast::continues_in…

cf-account-management-sdk

Account Management SDK — public inter-module contracts (canonical-errors re-export, IdP provisioner client trait, tenant CRUD input/output shapes)

tokio-hrtime

Hires timers for tokio

penta_v_kernel

A mission-critical Geometric Stability Protocol for kernel-level load balancing and system resilience

openhawk-sdk

SDK and project scaffold generator for OpenHawk agents (Rust, Python, TypeScript)

temporalio-sdk

Temporal Rust SDK

openhawk-watch

API drift and phantom dependency detection for OpenHawk — wraps ghostdep and etch

zr

quick, simple zsh package manager

spikex

Ultimate zero-copy library for inter-process shared memory

dcap-artifact-retrieval

DCAP artifact retrieval tool for Intel SGX remote attestation. DCAP attestations require access to Intel-signed artifacts. This library provides clients with access to these artifacts both from Intel directly…

whoami

getting information about the current user and environment

riot-sys

Rust FFI wrappers for the RIOT operating system

pcs

Provisioning Certification Service (PCS) data structures. Data structures related to the Intel Provisioning Certification Service. DCAP attestation requires handling of DCAP artifacts (e…

dacopy

A cross-platform tool for copying text into the clipboard in a shell

swaswa-system-lib

Cross-platform helpers for system info, network probing, and filesystem utilities (hashing, dedup, JSON I/O, text/binary detection)

libkrun

A dynamic library providing Virtualization-based process isolation capabilities

zrx-module

Module system

rhai-safe-system-info

Rhai bindings for safe system information access in REX scripts

deno_signals

Signals for Deno

deno_npm_installer

Installer of npm packages used in Deno

rustrc

rc-inspired init system as a library

spytools

Tools for spying on running processes

verdant-query-preprocessor

The tree-sitter query pre-processor used by verdant

rpecli

Rust cli tool to display information about PE files

bellows

Durable task processing framework in Rust for applications of all sizes

deno_lockfile

lockfile used in Deno

nua

No μarch Attacks - A tool for checking CPU vulnerabilities and mitigation status

sdl-keybridge

Universal Rosetta Stone for SDL keyboards: scancode ↔ keycode ↔ localized glyph across layouts and platforms

fontique

Font enumeration and fallback

wasmer-wasix

WASI and WASIX implementation library for Wasmer WebAssembly runtime

wasmer-wasix-types

WASI and WASIX types for Wasmer WebAssembly runtime

cubeb

Bindings to libcubeb for interacting with system audio from rust

savvy-ffi

Minimal FFI bindings for R's C API

brewr

Better brew update with desc of new formulae/casks

cubeb-core

Common types and definitions for cubeb rust and C bindings. Not intended for direct use.

plato-tile-scorer

Multi-signal tile scoring with controversy signal and counterpoint survival

native-theme

Cross-platform native theme detection and loading for Rust GUI applications

mythroad

A Rust-based HLE implementation for the Mythroad (MRP) platform

leenfetch

Fast, minimal, customizable system info tool in Rust (Neofetch alternative)

agent-client-protocol-tokio

Tokio-based utilities for the Agent Client Protocol

nu

A new type of shell

qos_p256

Signing and encryption utilities for P-256 keys

vmi-core

Core VMI library

qssm-gadget

BLAKE3–lattice gadgets: degree-2 bit witnesses and MS Merkle helpers (QSSM integration)

nu-plugin

Functionality for building Nushell plugins

starry-process

Process management for Starry OS

nu-cmd-lang

Nushell's core language commands

clawft-kernel

WeftOS kernel: boot sequence, process table, service registry, and health subsystem

polaris_shell

Shell command execution for Polaris agents

nispor-cli

Command line tool for nispor project

nu-cmd-base

The foundation tools to build Nushell commands

arceos-helloworld

helloworld crate (from crates.io) for ArceOS

arceos-collections

collections (String, Vec) crate (from crates.io) for ArceOS

jsph-tg-arceos-tutorial-exercise-altalloc

Bump allocator exercise for ArceOS

arceos-msgqueue

A message-queue crate (from crates.io) for ArceOS demonstrating cooperative multi-task scheduling with PFlash MMIO

jsph-tg-arceos-tutorial-exercise-hashmap

Exercise about supporting HashMap for ArceOS

jsph-tg-arceos-tutorial-exercise-printcolor

printcolor exercise for ArceOS

arceos-loadapp

A filesystem-based app loader crate (from crates.io) for ArceOS demonstrating FAT-fs initialization and file I/O

jsph-tg-arceos-tutorial-exercise-ramfs-rename

Exercise about supporting rename operation for ramfs for ArceOS

arceos-msgqueue-qfr

A message-queue crate (from crates.io) for ArceOS demonstrating cooperative multi-task scheduling with PFlash MMIO

arceos-helloworld-qfr

helloworld crate (from crates.io) for ArceOS

arceos-loadapp-qfr

A filesystem-based app loader crate (from crates.io) for ArceOS demonstrating FAT-fs initialization and file I/O

nu-plugin-test-support

Testing support for Nushell plugins

enclave-runner-sgx

High-level abstractions for running SGX enclaves. This crate can be used to load and interface with SGX applications compiled for the x86_64-fortanix-unknown-sgx target

riscv64-qemu-virt-hv

Hardware platform implementation for the RISC-V64 QEMU virt machine used by AxVisor

prometric

Metric types to use with the prometric-derive crate

jsph-tg-arceos-tutorial-exercise-ramfs-rename-axfs-ramfs

RAM filesystem used by ArceOS

crev-wot

Scalable, social, Code REView system that we desperately need - Web of Trust library

arceos-collections-qfr

collections (String, Vec) crate (from crates.io) for ArceOS

ta-goal

GoalRun lifecycle management and event dispatch for Trusted Autonomy

pcsc-mon

Monitor PC/SC smart card readers with hotplug and card event support

nu_plugin_file_dialog

nu plugin to select files through the native dialog

claude_runner_core

Claude Code process execution with builder pattern

edos_rt

edos runtime helpers

z_image_ai_app

Minimal Rust package for Z Image AI platform site metadata and docs.rs indexing

libredox

Redox stable ABI

mmap-sync

package allowing sharing of data between processes in a wait-free and zero-copy fashion from mapped memory

system_env

Information about the system environment: operating system, architecture, package manager, etc

carboy

OS-level isolation, WASM sandboxing, ephemeral sessions, and OCI image management for developer tools and AI agents

slotbus

Lock-free shared memory IPC with slotted request/response. Sub-microsecond wake latency, zero-copy payloads, 32 concurrent in-flight requests per worker.

rez-next-rex

Rex command language implementation for rez-next

rez-next-bind

rez bind implementation for rez-next - bind system tools as rez packages

proses

Professional Secure Execution System

perl-dap-platform

Cross-platform runtime utilities for perl-dap

input-sys

Bindgen generated unsafe libinput wrapper

virtualbox_rs

interacting with VirtualBox, providing a safe and idiomatic interface to the VirtualBox API

arceos-altalloc

Bump allocator exercise for ArceOS

axplat-x86-pc

axplat hardware abstraction layer for x86 Standard PC machine

arceos-printcolor

printcolor exercise for ArceOS

arceos-hashmap

Exercise about supporting HashMap for ArceOS

arceos-ramfs-rename

Exercise about supporting rename operation for ramfs for ArceOS

axcpu

Privileged instruction and structure abstractions for various CPU architectures

rusk-revocation

Revocation subsystem for rusk

arcand

Canonical session API router for the Arcan daemon

kspin

Spinlocks used for kernel space that can disable preemption or IRQs in the critical section

axdriver_block

Common traits and types for block storage drivers

axdriver_virtio

Wrappers of some devices in the virtio-drivers crate, that implement traits in the axdriver_base series crates

axdriver_base

Common interfaces for all kinds of device drivers

axdriver_net

Common traits and types for network device (NIC) drivers

axdriver_display

Common traits and types for graphics device drivers

axdriver_pci

Structures and functions for PCI bus operations

riscfetch-core

RISC-V system information library - ISA extensions, hart count, hardware IDs

page_table_multiarch

Generic page table structures for various hardware architectures

somehal

hardware abstraction layer for kernel development

memory_addr

Wrappers and helper functions for physical and virtual addresses

wayle-battery

Battery monitoring service with reactive state

ipc-channel-mux

IPC channel multiplexer

memory_set

Data structures and operations for managing memory mappings

kernel_guard

RAII wrappers to create a critical section with local IRQs or preemption disabled

cap_access

Provide basic capability-based access control to objects

arm_pl031

System Real Time Clock (RTC) Drivers for aarch64 based on PL031

arm-fvp-base-pac

Arm Base Fixed Virtual Platform Peripheral Access Crate

browser-locations

Umbrella crate for browser executable discovery

axfs_ramfs

RAM filesystem used by ArceOS

axfs_devfs

Device filesystem used by ArceOS

redoubt-buffer

Page-aligned memory buffers with mlock and mprotect support

axfs_vfs

Virtual filesystem interfaces used by ArceOS

arc-locations

Locate Arc executables across desktop platforms

chrome-locations

Locate Chrome executables across desktop platforms

firefox-locations

Locate Firefox executables across desktop platforms

edge-locations

Locate Microsoft Edge executables across desktop platforms

brave-locations

Locate Brave executables across desktop platforms

opera-locations

Locate Opera executables across desktop platforms

vivaldi-locations

Locate Vivaldi executables across desktop platforms

zen-locations

Locate Zen executables across desktop platforms

chromium-locations

Locate Chromium executables across desktop platforms

librewolf-locations

Locate LibreWolf executables across desktop platforms

helium-locations

Locate Helium executables across desktop platforms

floorp-locations

Locate Floorp executables across desktop platforms

system-monitor-rs

A lightweight cross-platform system monitoring tool with desktop notifications

portwatch

A cross-platform TUI for monitoring network ports and managing processes

browser-locations-core

Shared browser executable discovery engine and typed models

vaultick-bin

CLI for secure secret storage and process injection with vaultick

axdriver_vsock

Common traits and types for vsock drivers

axdriver_input

Common traits and types for input device drivers

wsdg-xdg

Translation Layer - Translates XDG environment to WSDG interface logic

nein

Programmatic nftables firewall — network policy, NAT, port mapping, and service access control for AGNOS

page_table_entry

Page table entry definition for various hardware architectures

volumecontrol

Cross-platform crate to control system audio volume

volumecontrol-core

Common traits, errors and utilities for volumecontrol crates

riscv_plic

RISC-V platform-level interrupt controller (PLIC) register definitions and basic operations

redox-pkg

redox package manager library

arm_pl011

ARM Uart pl011 register definitions and basic operations

zesh_git

Package to provide git functionality to zesh

libpkgx

Install and run pkgx packages

counter-awareness

Detection/counter-detection matrix formalization for multi-spectral awareness resistance

pkgx

Run anything

bux-krun

Raw FFI bindings to libkrun — lightweight VM engine for sandboxed code execution

nexcore-cybercinetics

Feedback-controlled kinetic governance — ∂(→(ν, ς, ρ)) typed as Rust

pkgar-repo

Redox Package Repository

astrid-approval

Approval system for Astrid secure agent runtime - types, allowances, and security policy

tauri-wasm-rs

tauri wasm bindings

memlink-runtime

Dynamic module loading framework with circuit breaker, caching, pooling, health checks, versioning, and auto-discovery

vhost-user-backend

A framework to build vhost-user backend service daemon

virtfw-efi-apps

efi applications, mostly for testing

realitykit-sys

Raw FFI bindings to RealityKit — compiled automatically from Swift via build.rs

astrid-hooks

Hook system for Astrid secure agent runtime

helicity

Fast, pypa-compliant Python package manager, powered by Rust

tg-rcore-tutorial-easy-fs-zgy

filesystem implementation for rCore tutorial OS

im-switch

A cross-platform input method switcher — Rust crate + CLI

tg-rcore-tutorial-ch5-zgy

Chapter 5 of rCore Tutorial: Process management with fork, exec and wait syscalls

tg-rcore-tutorial-ch6-zgy

Chapter 6 of rCore Tutorial: File system with easy-fs and virtio block device

phantom_os

An asynchronous, distributed operating system framework with IIT-based ECS architecture

hpc-audit

Shared audit event types and sink trait for HPC systems. Loose coupling, high coherence — each system owns its log, shared format for SIEM forwarding.

wyp-tg-rcore-tutorial-ch2-multicore

Chapter 2 Multicore Extension: Batch processing system with multicore support - main core runs apps, secondary cores park

procmod-hook

Inline function hooking and detouring for x86_64

lbl-tg-rcore-tutorial-ch1-storage

rCore Tutorial ch1 storage lab: virtio-blk read/write demo kernel

memlink-shm

High-performance shared memory IPC library with multi-priority messaging and lock-free ring buffers

posthog-symbol-data

A shared library for serialising/deserialising PostHog symbol data

tg-rcore-tutorial-ch4-zgy

Chapter 4 of rCore Tutorial: Address space management with SV39 virtual memory

tg-rcore-tutorial-ch3-zgy

Chapter 3 of rCore Tutorial: Multiprogramming and time-sharing multitasking

cargowatch-detector

Best-effort detection of active Rust toolchain processes for CargoWatch

ebi_optimisation

Optimisation techniques for Ebi - a stochastic process mining utility

netconfig-rs

managing network interfaces and IP addresses in a cross-platform way

wyp-tg-rcore-tutorial-ch1-multicore

Chapter 1 Multicore Extension: RISC-V multi-core startup demonstration with HART identification and WFI parking mechanism

synwire-agent

Agent runtime implementations for synwire

wyp-tg-rcore-tutorial-ch1-clock

Chapter 1 extended: A minimal kernel crate with clock interrupt support for learning RISC-V interrupt mechanism

oris-intake

Automatic issue intake system for Oris self-evolution

system_info_collector_core

Core library for system_info_collector - concurrent data collection engine

elizaos-plugin-webhooks

HTTP webhook ingress plugin for ElizaOS

handy-keys

Cross-platform global keyboard shortcuts library

ruvix-cap

seL4-inspired capability management for the RuVix Cognition Kernel (ADR-087)

ruvix-sched

Coherence-aware scheduler for the RuVix Cognition Kernel (ADR-087)

ruvix-proof

Proof engine with 3-tier routing for the RuVix Cognition Kernel (ADR-087)

shrouded

Secure memory management with mlock, guard pages, and automatic zeroization

supplicant-rs

Pure Rust WPA supplicant: WPA2/WPA3, EAP, 802.1X. Memory-safe replacement for wpa_supplicant.

picoring

High-performance, zero-copy circular buffer for Rust using hardware memory mirroring

ruvix-types

No-std kernel interface types for the RuVix Cognition Kernel (ADR-087)

ruvix-nucleus

Integration crate for RuVix Cognition Kernel - syscall dispatch, deterministic replay, and full acceptance tests (ADR-087)

ruvix-vecgraph

Kernel-resident vector and graph stores for RuVix Cognition Kernel (ADR-087)

ruvix-queue

io_uring-style ring buffer IPC for RuVix Cognition Kernel (ADR-087)

arcbox-vmm

Virtual Machine Monitor for ArcBox

ruvix-aarch64

AArch64 support for RuVix Cognition Kernel (ADR-087)

ruvix-physmem

Physical memory allocator for RuVix Cognition Kernel (ADR-087)

ruvix-boot

RVF boot loading for RuVix Cognition Kernel (ADR-087)

netsock

Cross-platform library for network sockets information

axinput

Input device management for ArceOS

axdma

ArceOS global DMA allocator

uhyve-interface

The interface between uhyve and a guest VM

cbqn

Embed BQN in Rust via CBQN FFI

axipi

ArceOS IPI management module

netlink-socket2

Type-safe Rust bindings for Netlink generated from YAML specifications

tortia

ternsig-core

Shared substrate types for the Ternsig runtime

bare-script

The type-safe scripting authority for Rust. A framework for building robust shell commands and automation with 'Parse, don't validate' philosophy.

deep_causality_core

Core types for deep_causality crate

surrealdb-host-adapter

Rust host adapter for SurrealDB WASI components

hxn

Blazingly fast tool to grab screenshots of url/webpages from terminal

tileview

run tiled commands in a single terminal

hasami

(鋏) — clipboard manager with timed clearing and history

sysray

Modern cross-platform system observability engine

hermit-rs

A universal package manifest for any package manager

os_image_lens

Dependency-free ELF64 kernel image inspector and load-plan builder for Rust OS development

os_state_maestro

Deterministic, no_std finite-state machinery and event orchestration for OS development, with zero dependencies

os_abi_sentinel

Dependency-free, no_std-first ABI contract utilities for Rust OS development: compile-time layout/offset assertions and minimal ABI versioning

os_foundry_suite

2024 suite crate that unifies and orchestrates multiple OS-building crates

orcs-component

Component trait for ORCS CLI

orcs-event

Event system for ORCS CLI (Signal, Request, Response)

sysexits

The system exit codes as defined by <sysexits.h>

memtrace

A CLI tool for generation heap consumption flamegraphs

if-watch

crossplatform asynchronous network watcher

memtrace-ui

A GUI tool for profiling heap memory consumption

horus-resources

Dynamic resource detection (RAM/CPU/cgroups) for adaptive behavior and OOM prevention across Horus projects

os_slab_vault

Dependency-free, no_std generational slab/object-pool for Rust OS kernels

redox_event

Redox I/O events

os_metal_primitives

Dependency-free bare-metal primitives for Rust OS development: typed MMIO, registers, bitfields, port I/O, IRQ tables, and driver state patterns

os_kernel_foundry

A modular, heavily test-driven foundation crate for building Rust-based operating systems in Rust

platify

Streamline cross-platform Rust development with declarative attribute macros

arceos-childtask

A multi-task child-thread crate (from crates.io) for ArceOS with PFlash MMIO access via page tables

arceos-readpflash

A PFlash reader crate (from crates.io) for ArceOS with MMIO remapping via page tables

dlib

Helper macros for handling manually loading optional system libraries

memtrace-utils

utils for parsing heap tracing files

alloc_kern

A no_std physical + virtual memory allocator with fragmentation handling, quarantine system, and safe IO API

arceos-fairsched

A preemptive CFS scheduling crate (from crates.io) for ArceOS demonstrating timer-interrupt-driven task switching

arceos-readblk

A block device reader crate (from crates.io) for ArceOS demonstrating VirtIO-blk driver discovery and disk I/O

arceos-guestvdev

ArceOS Guest Virtual Device (Hypervisor): runs a guest OS with virtual device support (timer, console, NPF passthrough) — RISC-V H-extension, ARM AArch64 EL2, and AMD SVM

arceos-guestmonolithickernel

ArceOS Guest Monolithic Kernel (Hypervisor): runs a guest monolithic OS kernel with user-space process support (task management, syscall handling, pflash passthrough) — RISC-V H-extension, ARM AArch64 EL2, and AMD SVM

memtrace-lib

A dynamic library for collecting heap consumption

arceos-guestaspace

ArceOS Guest Address Space (Hypervisor): runs a guest OS with loop-based VM exit handling and nested page fault support — RISC-V H-extension, ARM AArch64 EL2, and AMD SVM

arceos-guestmode

ArceOS Guest Mode (Hypervisor): runs a minimal guest OS (skernel) using hardware-assisted virtualization — RISC-V H-extension, ARM AArch64 EL2, and AMD SVM — with VM exit handling and second-stage page table support

arceos-lazymapping

Lazy page mapping for ArceOS: loads and runs a user-space app with demand paging and syscall handling

arceos-userprivilege

User privilege mode execution for ArceOS: loads and runs a user-space app with syscall handling

hermit

unikernel for Rust

hermit-kernel

A Rust-based library operating system

astrid-tools

Built-in coding tools for the Astrid agent runtime

astrid-telegram

Telegram bot frontend for the Astrid agent runtime

bux-sys

Raw FFI bindings to libkrun — lightweight VM engine for sandboxed code execution

mltop

Resource monitor for ML engineers written in Rust

tauri-plugin-system

Comprehensive cross-platform system information plugin for Tauri applications. Provides CPU, RAM, disk, GPU, battery, network, thermal, display, and OS information through native platform APIs.

cargo-image-runner

A generic, customizable runner for building and booting kernel/embedded images with Limine, GRUB, QEMU, and more

keyper

TUI password manager

ping

naive ping implementation in Rust

ohos-abilitykit-sys

Bindings to the Abilitykit of OpenHarmony

steel-doc

Document generation for steel

crate-seq-registry

crates.io API client and cargo publish subprocess with exponential backoff

silicon-monitor

Silicon Monitor: Comprehensive hardware monitoring for CPUs, GPUs, NPUs, memory, I/O, and network silicon across all platforms

waterkit-bluetooth

Cross-platform Bluetooth (BLE and Classic)

enclave-runner

High-level abstractions for secure enclaves, for any Fortanix EDP target

fortanix-sgx-abi

interface for Intel SGX enclaves. This is the interface for the x86_64-fortanix-unknown-sgx target. This is a small yet functional interface suitable for writing larger enclaves…

ohos-window-sys

Raw Bindings to the OpenHarmony native window

product-os-monitoring

A lightweight, no_std compatible system and process monitoring library for Rust with structured return types and efficient byte formatting

ankurah-connector-local-process

Ankurah connector for local processes

architecture

Commonly used constants for architectures, platforms, and related targets

code-baseline

Enforce architectural decisions AI coding tools keep ignoring

astrid-plugins

Plugin trait and registry for the Astrid secure agent runtime SDK

regio

High level abstractions for register access of all sorts

vmaware

A cross-platform Rust library for virtual machine detection — port of VMAware (C++)

k1

A cargo runner for Rust-based operating system kernels

browser-url

Cross-platform (planned) library retrieving active browser URL and information

oma-utils

General system API and utilities used by oma

insecure-time

Insecure time computation based on rdtsc

pacx

Wrapper for package managers, allowing you to define and configure your package managers in Lua

libarch

API for low-level machine access and related type abstractions

gen-elf

generating ELF files for testing ELF loaders

bum-os

A minimal OS

bootloader

An experimental x86_64 bootloader that works on both BIOS and UEFI systems

bootloader-x86_64-bios-stage-2

Second BIOS stage of the bootloader crate

wash

wasmCloud Shell (wash) - CLI tool and library for wasmCloud development

randix

A minimal random number generator for Rust

bootloader-x86_64-bios-common

Common code for BIOS stages of the bootloader crate

kclip-cli

A cross-platform CLI for accessing the system clipboard

bootloader-x86_64-bios-stage-4

Fourth BIOS stage of the bootloader crate