Lib.rs

axplat-dyn

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

axvisor

A lightweight type-1 hypervisor based on ArceOS

ax-input

Input device management for ArceOS

ax-kspin

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

ax-dma

ArceOS global DMA allocator

axklib

Small kernel-helper abstractions used across the microkernel

axbuild

An OS build lib toolkit used by arceos

ax-kernel-guard

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

ax-errno

Generic error code representation

ax-fs-vfs

Virtual filesystem interfaces used by ArceOS

starry-process

Process management for Starry OS

procpilot

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

libc

Raw FFI bindings to platform libraries like libc

ax-fs-devfs

Device filesystem used by ArceOS

ax-fs-ramfs

RAM filesystem used by ArceOS

polaris_shell

Shell command execution for Polaris agents

scope-local

Scope local storage

ax-driver-block

Common traits and types for block storage drivers

atuin-common

common library for atuin

atuin-server

server library for atuin

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-driver-net

Common traits and types for network device (NIC) drivers

ax-driver-base

Common interfaces for all kinds of device drivers

axdevice

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

ax-driver-display

Common traits and types for graphics device drivers

ax-driver-vsock

Common traits and types for vsock drivers

uv-platform

internal component crate of uv

axhvc

AxVisor HyperCall definitions for guest-hypervisor communication

ax-cap-access

Provide basic capability-based access control to objects

rattler

install conda environments

riscv_vplic

RISCV Virtual PLIC implementation

ax-driver-input

Common traits and types for input device drivers

ax-driver-pci

Structures and functions for PCI bus operations

arceos-helloworld

helloworld crate (from crates.io) 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-altalloc

Bump allocator exercise for ArceOS

arceos-collections

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

uv-once-map

internal component crate of uv

zerobox

Sandbox any command with file, network, and credential controls

jsph-tg-arceos-tutorial-exercise-hashmap

Exercise about supporting HashMap for ArceOS

jsph-tg-arceos-tutorial-exercise-printcolor

printcolor exercise for ArceOS

uv-dirs

internal component crate of uv

arceos-loadapp

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

nu

A new type of shell

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

ax-arm-pl031

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

arceos-loadapp-qfr

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

atomic-matrix

A lock-free, high end allocator primitive for high-performance IPC

routa-entrix

Entrix fitness function engine — Rust implementation of tools/entrix

crev-wot

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

prometric

Metric types to use with the prometric-derive crate

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

RAM filesystem used by ArceOS

ta-runtime

Runtime Adapter Trait for Trusted Autonomy agent process management

arceos-collections-qfr

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

hematite-cli

Senior SysAdmin, Network Admin, and Software Engineer living in your terminal. A high-precision local AI agent harness for LM Studio that runs 100% on your own silicon. Reads repos…

ax-page-table-multiarch

Generic page table structures for various hardware architectures

ax-memory-set

Data structures and operations for managing memory mappings

ta-goal

GoalRun lifecycle management and event dispatch for Trusted Autonomy

aarch64_sysreg

Address translation of system registers

ax-memory-addr

Wrappers and helper functions for physical and virtual addresses

epics-rs

Pure Rust EPICS control system framework

nu-cmd-lang

Nushell's core language commands

pcsc-mon

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

axplat-x86-qemu-q35

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

ksym

generating symbol tables for operating systems

ax-plat-x86-pc

axplat hardware abstraction layer for x86 Standard PC machine

ax-plat-aarch64-peripherals

ARM64 common peripheral drivers with axplat compatibility

nu-plugin

Functionality for building Nushell plugins

claude_runner_core

Claude Code process execution with builder pattern

ra-ap-rustc_hashes

Automatically published version of the package rustc_hashes in the rust-lang/rust repository from commit d32e620a107b5b3dccd9ddb53fa124956a92b589 The publishing script for this crate lives at:…

z_image_ai_app

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

edos_rt

edos runtime helpers

omegon-extension

Omegon extension SDK — safe, versioned interface for third-party extensions

ax-page-table-entry

Page table entry definition for various hardware architectures

redox_syscall

access raw Redox system calls

skillfile-deploy

Platform adapters and installation for skillfile

nu-cmd-base

The foundation tools to build Nushell commands

libredox

Redox stable ABI

savvy-ffi

Minimal FFI bindings for R's C API

ebi_bpmn

A BPMN parser, writer and executor

ebi_objects

Objects for Ebi - a stochastic process mining utility

kley

local package manager for npm (JS/TS)

proka-bootloader

The bootloader for Proka OS

ipmb

Inter-process message bus

system_env

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

qos_core

Core components and logic for QuorumOS applications

brewr

Better brew update with desc of new formulae/casks

carboy

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

nu-plugin-test-support

Testing support for Nushell plugins

deno_lockfile

lockfile used in Deno

tokio-process-tools

Interact with processes spawned by tokio

slotbus

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

releasaurus-core

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

deno_signals

Signals for Deno

zellij

A terminal workspace with batteries included

deno_npm_installer

Installer of npm packages used in Deno

nexus-memory-mcp

MCP server implementation for Nexus Memory System

sp1-gpu-cudart

High-level Rust API for SP1 GPU operations

native-theme

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

sp1-gpu-sys

FFI bindings and CUDA build system for SP1-GPU

wasmer-wasix

WASI and WASIX implementation library for Wasmer WebAssembly runtime

mmap-sync

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

wasmtime-wizer

The WebAssembly Pre-Initializer

cranelift-srcgen

Helper functions for generating Rust and ISLE files

wasmtime-wasi-config

Wasmtime implementation of the wasi-config API

wasmer-wasix-types

WASI and WASIX types for Wasmer WebAssembly runtime

rez-next-bind

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

opsis-core

Core types and traits for the Opsis world state engine

perl-subprocess-runtime

Shared subprocess execution abstraction with OS and mock runtimes

proses

Professional Secure Execution System

rattler_sandbox

run executables in a sandbox

aios-kernel

Kernel orchestration layer for the Agent OS — tick lifecycle, agent loop, and composite runtime

input-sys

Bindgen generated unsafe libinput wrapper

axplat-x86-pc

axplat hardware abstraction layer for x86 Standard PC machine

arceos-altalloc

Bump allocator exercise for ArceOS

virtualbox_rs

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

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

aios-runtime

Canonical Agent OS runtime engine

rusk-revocation

Revocation subsystem for rusk

kspin

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

arcand

Canonical session API router for the Arcan daemon

axdriver_virtio

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

axdriver_block

Common traits and types for block storage drivers

pib-service-api-permissions-inventory

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

pib-service-api-permissions

pib-service edit API permission enforcement system

axdriver_net

Common traits and types for network device (NIC) drivers

page_table_multiarch

Generic page table structures for various hardware architectures

axdriver_display

Common traits and types for graphics device drivers

riscfetch-core

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

axdriver_pci

Structures and functions for PCI bus operations

xchecker-runner

Process execution with timeouts and job control

arcan-tui

Terminal UI for the Arcan agent runtime

wayle-battery

Battery monitoring service with reactive state

kernel_guard

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

memory_addr

Wrappers and helper functions for physical and virtual addresses

memory_set

Data structures and operations for managing memory mappings

browser-locations

Umbrella crate for browser executable discovery

arm-fvp-base-pac

Arm Base Fixed Virtual Platform Peripheral Access Crate

chromium-locations

Locate Chromium executables across desktop platforms

arm_pl031

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

cap_access

Provide basic capability-based access control to objects

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

axfs_ramfs

RAM filesystem used by ArceOS

axfs_devfs

Device filesystem used by ArceOS

axfs_vfs

Virtual filesystem interfaces used by ArceOS

redoubt-buffer

Page-aligned memory buffers with mlock and mprotect support

axdriver_vsock

Common traits and types for vsock drivers

firefox-locations

Locate Firefox executables across desktop platforms

edge-locations

Locate Microsoft Edge executables across desktop platforms

opera-locations

Locate Opera executables across desktop platforms

zen-locations

Locate Zen executables across desktop platforms

floorp-locations

Locate Floorp executables across desktop platforms

chrome-locations

Locate Chrome executables across desktop platforms

brave-locations

Locate Brave executables across desktop platforms

arc-locations

Locate Arc executables across desktop platforms

helium-locations

Locate Helium executables across desktop platforms

vivaldi-locations

Locate Vivaldi executables across desktop platforms

librewolf-locations

Locate LibreWolf executables across desktop platforms

system-monitor-rs

A lightweight cross-platform system monitoring tool with desktop notifications

depos-cli

Shared dependency workspace CLI

axdriver_input

Common traits and types for input device drivers

portwatch

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

vaultick-bin

CLI for secure secret storage and process injection with vaultick

browser-locations-core

Shared browser executable discovery engine and typed models

etcd-bin-vendored

etcd precompiled binaries bundled into a crate

lox-comms

Communication systems and link budget analysis for the Lox ecosystem

nein

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

wsdg-xdg

Translation Layer - Translates XDG environment to WSDG interface logic

page_table_entry

Page table entry definition for various hardware architectures

volumecontrol

Cross-platform crate to control system audio volume

axdriver_base

Common interfaces for all kinds of device drivers

claude-knowledge-mcp

MCP server for active tapping into Claude's knowledge management system and anatomical tools

uboot-shell

communicating with u-boot

volumecontrol-core

Common traits, errors and utilities for volumecontrol crates

edera-check

CLI to run checks before installing or using Edera

redox-pkg

redox package manager library

wasma-ubin

WASMA Unified Binary Interface

zesh_git

Package to provide git functionality to zesh

perl-dap-platform

Cross-platform runtime utilities for perl-dap

counter-awareness

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

lessons-mcp

MCP server for capturing lessons learned about hooks with primitive extraction

skills-mcp

MCP server exposing vocabulary programs (LEARN, PROVE, VITALS, etc.) as callable tools

bux-krun

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

nexcore-cybercinetics

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

fontique

Font enumeration and fallback

pkgar-repo

Redox Package Repository

boxkit

Agent sandbox toolkit

punch-kernel

The Ring — central kernel and orchestrator for the Punch Agent Combat System

tauri-wasm-rs

tauri wasm bindings

limine

Rust interface for the Limine boot protocol

memlink-runtime

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

astrid-mcp

MCP client with server lifecycle management for Astrid

astrid-approval

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

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

vfs

A virtual filesystem for Rust

kozan

UI platform — re-exports and prelude for application authors

astrid-hooks

Hook system for Astrid secure agent runtime

tg-rcore-tutorial-easy-fs-zgy

filesystem implementation for rCore tutorial OS

im-switch

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

helicity

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

tg-rcore-tutorial-ch4-zgy

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

tg-rcore-tutorial-ch6-zgy

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

tg-rcore-tutorial-ch5-zgy

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

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.

phantom_os

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

wyp-tg-rcore-tutorial-ch2-multicore

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

lbl-tg-rcore-tutorial-ch1-storage

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

procmod-hook

Inline function hooking and detouring for x86_64

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-ch3-zgy

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

path_resolver

trie-based data structure to track and resolve relative path ownership across multiple packages

cargowatch-detector

Best-effort detection of active Rust toolchain processes for CargoWatch

rucos

Rust Microcontroller Operating System (RuCOS) Kernel

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

system_info_collector_core

Core library for system_info_collector - concurrent data collection engine

oris-intake

Automatic issue intake system for Oris self-evolution

elizaos-plugin-webhooks

HTTP webhook ingress plugin for ElizaOS

repo

An opinionated tool for repo management

tauri-plugin-fcm

Tauri 2 plugin for Firebase Cloud Messaging

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)

cnf-lib

Distribution-agnostic 'command not found'-handler

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)

ruvix-aarch64

AArch64 support for RuVix Cognition Kernel (ADR-087)

ruvix-physmem

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

shpool

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

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

axmm

ArceOS virtual memory management module

uhyve-interface

The interface between uhyve and a guest VM

tortia

netlink-socket2

Type-safe Rust bindings for Netlink generated from YAML specifications

bare-script

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

rpecli

Rust cli tool to display information about PE files

elf_loader

A high-performance, no_std compliant ELF loader and JIT linker for Rust

surrealdb-host-adapter

Rust host adapter for SurrealDB WASI components

hxn

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

openentropy-server

HTTP entropy server with an ANU-style random endpoint

hermit-entry

Hermit's loading and entry API

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

tileview

run tiled commands in a single terminal

infrarust_ban_system

A ban system for Infrarust

netru

Cross-platform network utilities for Rust

picon

Get process icons in a cross-platform way

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_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

orcs-component

Component trait for ORCS CLI

orcs-event

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

horus-resources

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

sysexits

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

nu_plugin_file_dialog

nu plugin to select files through the native dialog

if-watch

crossplatform asynchronous network watcher

orcs-mcp

MCP (Model Context Protocol) client integration for ORCS

memtrace-ui

A GUI tool for profiling heap memory consumption

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

alloc_kern

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

arceos-readpflash

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

arceos-childtask

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

memtrace-utils

utils for parsing heap tracing files

dlib

Helper macros for handling manually loading optional system libraries

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

orcs-types

Core types for ORCS CLI

platify

Streamline cross-platform Rust development with declarative attribute macros

hermit

unikernel for Rust

hermit-kernel

A Rust-based library operating system

bootimage

create a bootable OS image from a kernel binary

astrid-gateway

Gateway daemon for the Astrid secure agent runtime

bux-sys

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

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

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

dnx-core

Core library for dnx, a fast Rust-based package manager for Node.js

rong_process

Process module for RongJS

keyper

TUI password manager

steel-interpreter

Steel repl and command line interface

ping

naive ping implementation in Rust

steel-doc

Document generation for steel

crate-seq-registry

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

ohos-abilitykit-sys

Bindings to the Abilitykit of OpenHarmony

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)

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…

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…

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

pcs

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

ankurah-connector-local-process

Ankurah connector for local processes

architecture

Commonly used constants for architectures, platforms, and related targets

regio

High level abstractions for register access of all sorts

enclave-runner

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

whoami

getting information about the current user and environment

vmaware

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

rusty-tip

Nanonis SPM system control via TCP

mmi

OS Triage for Anyone and Everyone

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

includium

A complete C preprocessor implementation in Rust

bootloader

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

randix

A minimal random number generator for Rust

wash

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

bootloader-x86_64-bios-common

Common code for BIOS stages of the bootloader crate

bootloader-x86_64-bios-stage-2

Second BIOS stage of the bootloader crate

bootloader-x86_64-bios-stage-4

Fourth BIOS stage of the bootloader crate

bootloader_api

Makes a kernel compatible with the bootloader crate

bootloader-x86_64-bios-stage-3

Third BIOS stage of the bootloader crate

tauri-plugin-shell

Access the system shell. Allows you to spawn child processes and manage files and URLs using their default application.

bootloader-boot-config

The runtime configurations that are saved in a JSON file for the bootloader crate

kclip-cli

A cross-platform CLI for accessing the system clipboard

system-uptime

A cross-platform Rust library for retrieving operating system uptime

envflag

A strict, zero-boilerplate env manager with dotenvy support and validation

env-settings

initialize rust structs using environment variables (like pydantic’s BaseSettings)

xous

System call interface for Xous

x64

x86_64 support with LA57 (5-level paging) for 57-bit virtual addresses

xous-sys

Xous kernel system interface

xous-ipc

System call interface for Xous

edlcodegen-host

Host-side ABI and runtime support for Rust crates generated by edlcodegen

memory_addresses

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

edlcodegen-macros

Internal procedural macros used by edlcodegen-generated crates

xous-api-names

Xous microkernel OS inter-process name resolution server

opener

Open a file or link using the system default program

bookit

Fast and simple bookmark manager for your operating system

embeddenator-interop

Kernel interop and system integration for Embeddenator

manualmap

Manually map PE to process memory

herolib-os

Unified system utilities including OS, process, virtualization, git, and Kubernetes management

ua

Cross-platform User-Agent generator with best-effort installed browser detection (Chrome/Edge/Firefox/Brave/Opera/Chromium; Safari best-effort)

konfigkoll_types

Type definitions for konfigkoll backend (internal helper crate)

ejb

The EJ Builder (EJB) application for managing build processes and board communication

herolib-mos

Mycelium Operating System (MOS) - Network and VM abstraction layer

nodejs_package_managers

Helpers for npm, pnpm, yarn, and bun package managers

vsched_utils

vsched的依赖库，提供了无锁的btreemap和deque

vsched_config

vsched的依赖库，用于配置常量

vsched_base_task

vsched的依赖库，定义基本任务类型

unistore-process

Process management capability for UniStore

cubeb

Bindings to libcubeb for interacting with system audio from rust

deep_causality_core

Core types for deep_causality crate

cubeb-core

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

unistore-tray

System tray capability for UniStore - cross-platform tray icon, menu, and notifications

taco-acs-model-checker

Model Checker constructing an abstract counter system to verify threshold automata. This model checker is part of the TACO toolsuite.

taco-model-checker

Model Checker interface and specification definitions for model checkers that are part of the TACO toolsuite

taco-zcs-model-checker

Model Checker constructing an abstract counter system encoded into BDDs to verify threshold automata. This model checker is part of the TACO toolsuite.

rust-apt

Bindings for libapt-pkg

kconfq

A portable way to query kernel configuration on a live system

alumy

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

stoptrackingme

remove tracking IDs from URLs

kcr_groupsnapshot_storage_k8s_io

Kubernetes Custom Resource Bindings

background-jobs-actix

in-process jobs processor based on Actix

pupoxide

A high-performance, memory-safe, declarative configuration management tool inspired by Puppet

proc_jail

Process execution guard for agentic systems

hitrace

Safe bindings to the HiTrace tracing system of OpenHarmony

lowlet

Low-latency IPC library using shared memory and lock-free structures

uhyve

A specialized hypervisor for Hermit

ps2_keyboard

A PS/2 keyboard driver for the ArceOS kernel

duende-mlock

Memory locking for swap-critical daemons (DT-007: Swap Deadlock Prevention)

wasite

WASI Terminal Environment API

redpowder

SDK / Devkit para Redstone OS

secmem-proc

Process hardening through system APIs

uv-migrator

converting various python package soltutions to use the uv solution by astral

os-interface

Interface to retrieve OS information

raw-input

A cross-platform library for capturing and simulating global input events (keyboard and mouse)

aion-reactor

State Machine

ltfi-wsap

(Layered Transformer Framework Intelligence - Web System Alignment Protocol) Rust SDK

sysuri

A cross-platform crate for registering custom URIs with the OS

zeroize_derive

Custom derive support for zeroize

sentry-uapi

Sentry kernel user API implementation

moto-rt

Motor OS Runtime

sysinfo-cli

A lightweight, efficient, and professional CLI wrapper around the sysinfo crate

os_info

Detect the operating system type and version

proxy_cfg

get proxy configuration from the OS

ohos-drawing-sys

Bindings to the native_drawing API of OpenHarmony OS

rattler_libsolv_c

Bindings for libsolv

system

Cross-platform crate to easily run shell commands, similar to the C system function

dozr

A flexible sleep-like command-line utility for pausing execution with fun timing features

hitrace-sys

Bindings to the HiTrace tracing system of OpenHarmony

ohos-deviceinfo-sys

Bindings to OpenHarmony OS APIs providing information about the device

hilog-sys

Rust bindings to the HiLog logging system of OpenHarmony