simdjson is a high-performance C++ JSON parsing library that uses SIMD instructions (AVX2, AVX-512, NEON, RVV, etc.) to parse and validate JSON at multi-gigabyte-per-second speeds. It provides two primary APIs: a DOM API (`simdjson::dom`) that builds a complete in-memory tree, and an On-Demand API (`simdjson::ondemand`) that performs lazy, forward-only parsing for streaming and large-document use cases. The library also includes a builder API for JSON serialization, compile-time JSON parsing via C++26 reflection, JSON Pointer/Path support, NDJSON/JSON-sequence streaming, and a single-header amalgamated distribution. The codebase is organized around a two-stage pipeline: stage 1 performs SIMD-accelerated structural indexing and UTF-8 validation, and stage 2 builds the DOM tape or drives the on-demand iterator. Runtime CPU dispatch selects the best implementation for the host architecture, with fallbacks for non-SIMD platforms. The repository is a mature, production-grade library used by major projects (Node.js, ClickHouse, etc.) and is backed by an extensive test suite, fuzzing harnesses, and cross-architecture CI. It is primarily an application/library rather than a data-research repository, though it contains benchmark and research-oriented components (e.g., performance modeling, static reflection experiments).
AsmJit is a low-level C++ library for runtime machine-code generation and execution (JIT compilation). It is not an application but a reusable library, with its main entry points in `asmjit/core.h`, `asmjit/x86.h`, `asmjit/a64.h`, and `asmjit/ujit.h`. The library provides three emitter tiers built on a shared emitter abstraction: `BaseAssembler` for direct binary encoding, `BaseBuilder` for node-based IR manipulation, and `BaseCompiler` for high-level code with virtual registers, liveness analysis, and automatic register allocation. The x86/x64 and AArch64 backends are the primary production targets; AArch32 database infrastructure exists but is not a fully implemented backend.
cross-rs/cross is a CLI tool that enables zero-setup cross-compilation for Rust projects by wrapping Cargo and executing builds inside container engines (Docker/Podman). It manages a comprehensive registry of pre-built Docker images for dozens of target triples (Linux, musl, Android, FreeBSD, NetBSD, Solaris, Windows, bare-metal, etc.), automatically selects the appropriate image based on the --target flag, mounts the project source and toolchain, and runs cargo build/test inside the container. The tool also supports remote Docker execution, custom Dockerfiles, and advanced configuration via Cross.toml and environment variables. The codebase is structured as a Rust CLI with two binaries (cross and cross-util), a library of container orchestration modules, and a developer xtask workspace for CI, codegen, and changelog management. It demonstrates strong engineering practices with extensive CI, testing, and reusable patterns for command execution, container abstraction, and configuration merging. The repository includes a large collection of Dockerfiles and shell scripts for building target-specific toolchain images, as well as CI workflows that test across many platforms and container engines.
iPXE is an open-source network boot firmware that provides a full PXE implementation with enhanced capabilities. It operates as a pre-boot environment, replacing or supplementing traditional BIOS/UEFI PXE ROMs. The firmware supports booting over HTTP/HTTPS, iSCSI, Fibre Channel over Ethernet (FCoE), AoE, InfiniBand, and wireless networks, with full TLS 1.2 support including modern cipher suites (ECDHE, GCM, X25519, P-256/P-384). It includes a built-in command-line shell, scripting engine, interactive menus, and extensive hardware drivers for network cards, USB controllers, and storage devices across x86, ARM, RISC-V, LoongArch, and s390x architectures. The architecture is modular and table-driven: drivers, protocols, commands, and startup functions are registered via compile-time tables (e.g., `__pci_driver`, `__net_protocol`, `__command`), enabling a highly configurable build. The core uses an interface/refcount pattern for object-oriented-like composition, with reference-counted objects and asynchronous data transfer via `struct interface`. The codebase is well-structured with clear separation between architecture-specific code (under `src/arch/`), platform interfaces (EFI, BIOS, Linux userspace, SBI), and generic core logic. A comprehensive test suite (over 50 unit tests plus Wycheproof vectors) validates cryptographic primitives, network protocols, and data structures. Key entry points include `src/core/main.c` (generic boot flow), EFI application entry (`efiprefix.c`), BIOS PXE ROM entry, and Linux userspace binary. The firmware is typically embedded into option ROMs, UEFI drivers, or bootable images. External dependencies are minimal—the firmware runs directly on hardware or under a hypervisor, relying only on platform firmware services (UEFI, BIOS, SBI) for low-level operations.
This repository implements 'moss', a monolithic, Unix-like operating system kernel written in Rust, targeting AArch64 (with stubs for x86_64). It boots on QEMU and aims to run unmodified Linux userspace binaries (e.g., bash, coreutils, strace) by providing a Linux-compatible syscall interface. The kernel features an asynchronous core: all non-trivial syscalls are async functions, and the scheduler (EEVDF) and synchronization primitives are designed for async operation. The architecture includes a Hardware Abstraction Layer (HAL) via the `Arch` trait, but the majority of the code is ARM64-specific, covering boot, exception handling, MMU, interrupt controllers (GICv2/v3), UART drivers, timers, RTC, virtio, and a virtio-GPU display driver. The kernel provides a full process model with clone, execve, signals, futex, epoll, inotify, ptrace, and POSIX credentials. Memory management includes demand paging, copy-on-write, mmap, brk, a slab allocator with per-CPU caches, and a buddy allocator for physical frames. The VFS supports multiple filesystems: tmpfs, ext4 (via the ext4plus crate), FAT32, procfs, devfs, sysfs, and a cgroupfs stub. Networking uses the smoltcp stack for TCP/UDP and provides Unix domain sockets. The codebase is experimental and contains many stubs and unimplemented syscalls, but it is actively developed with a working init process, shell, and basic tools. Key strengths include the clean separation of architecture-independent kernel building blocks in the `libkernel` crate, the async-friendly synchronization primitives (`WakerSet`, `CondVar`, `Mutex`), the generic page table framework, and the driver registration macro. The code is well-structured for a kernel of this complexity, with extensive use of Rust's type system for safety (e.g., typed addresses, user-copy abstractions). However, the project is not production-hardened, relies on nightly Rust, and has significant architecture-specific code that limits portability.
This repository is an educational companion to the book 'Programming with 64-Bit ARM Assembly Language', adapted for Apple Silicon (ARM64 macOS, iOS, watchOS, tvOS). It contains 16 chapters of progressively complex assembly examples, covering system calls, memory addressing, functions, floating-point, NEON, and optimization. The code demonstrates key differences between Linux and Darwin (Apple) ABIs, such as syscall numbers, addressing modes (ADRP/ADD vs LDR =symbol), and variadic function calling conventions. It includes reusable debug macros (printReg, printStr) for register inspection, file I/O macros, and a toupper function callable from C, Python, and Swift. The project also features an Xcode SwiftUI app that integrates assembly code across multiple Apple platforms. The repository is well-maintained and actively used as a reference for Apple Silicon assembly development.
This repository is a Jekyll-based static website that serves as a comprehensive database of PCI Express device compatibility with Raspberry Pi Compute Module 4 and Pi 5. It contains hundreds of markdown files documenting individual PCIe cards, carrier boards, and HATs, along with their functionality status, driver requirements, and community testing notes. The site is automatically built and deployed to GitHub Pages via GitHub Actions. While primarily a content site, it includes useful extras like a cross-compilation Docker environment for building custom Pi kernels, which is the most technically sophisticated component. The codebase is straightforward Jekyll with some custom plugins for thumbnail generation and YouTube embeds. The project is actively maintained with frequent additions of new hardware listings.