s2n-tls is a C99 implementation of the TLS/SSL protocols designed by AWS for simplicity, small size, and security. It supports TLS 1.2 and 1.3, including features like 0-RTT early data, session tickets, post-quantum KEMs (ML-KEM, ML-DSA), and QUIC transport integration. The library provides a public C API (api/s2n.h) and multiple libcrypto backends (OpenSSL, AWS-LC, BoringSSL, LibreSSL). Extensive formal verification (CBMC, SAW, SideTrail) and fuzz testing ensure memory safety and constant-time execution. The architecture is highly modular with a stuffer buffer abstraction, blob/array utilities, a table-driven TLS extension framework, and a robust error-handling macro system. Rust bindings are first-class, offering safe wrappers (s2n-tls), async Tokio integration (s2n-tls-tokio), an HTTP client connector for Hyper (s2n-tls-hyper), and a metrics subscriber for handshake analysis. The library is used by AWS services like S3 and KMS, and includes interoperability tests against OpenSSL, GnuTLS, Java, and rustls. It is actively maintained with a sophisticated CI pipeline covering unit, integration, fuzz, formal proof, and performance regression tests across multiple platforms and libcrypto versions.
Neon is a Rust framework for building safe and fast native Node.js addons via the Node-API (N-API). It provides a comprehensive type system that maps JavaScript values to Rust types, procedural macros for exporting functions, classes, and constants, and async/threading primitives for offloading work to background threads. The repository also includes CLI tools: `create-neon` for scaffolding new projects with CI/CD templates, and `cargo-cp-artifact` for copying build artifacts. The core library (`crates/neon`) is the primary deliverable, consumed as a Rust dependency. The architecture is a Rust workspace with a procedural macro crate (`neon-macros`), plus npm packages for tooling. The codebase demonstrates high craftsmanship with safe abstractions over unsafe FFI, composable type extraction patterns, and a macro-driven export system that automates registration. It is actively maintained with extensive test suites including compile-fail UI tests, integration tests, and benchmarks.
This repository provides safe, idiomatic Rust bindings to the MuPDF C library (Artifex Software), enabling programmatic reading, rendering, creation, and editing of PDF and other document formats. It is a library crate organized as a Cargo workspace with three sub-crates: `mupdf` (high-level API), `mupdf-sys` (FFI layer that compiles MuPDF from source), and optional font crates (`mupdf-fonts-droid`, `mupdf-fonts-noto`, `mupdf-fonts-sil`). The architecture is a classic FFI wrapper: `mupdf-sys` exposes raw C functions via `bindgen`, while `mupdf` provides safe Rust types (`Document`, `Page`, `Pixmap`, `PdfDocument`, `Shape`, etc.) with automatic resource management, error handling, and thread-safety checks. Key entry points include `Document::open()` for loading files, `Page::to_pixmap()` for rasterization, `Shape` for programmatic drawing, and `PdfDocument` for PDF-specific operations like annotation manipulation, form filling, and incremental saving. The library supports extensive feature flags (e.g., `js`, `xps`, `svg`, `tesseract`, `docx-output`) that control which MuPDF subsystems are compiled. The codebase demonstrates high craftsmanship through its safe wrapper patterns, builder-style APIs (e.g., `Shape`), extensible trait design (`FontLoader`, `NativeDevice`), and comprehensive test coverage including snapshot-based rendering tests and link extraction round-trip tests. It is not a data research project; it is a software library for document processing.
Blitzar is a high-performance C++ library for GPU-accelerated cryptographic zero-knowledge proofs, developed by Space and Time. It provides multi-scalar multiplication (MSM), Pedersen commitments, inner product arguments, sumcheck proofs, and sequential commitments over multiple elliptic curves (Curve25519/Ristretto255, BLS12-381, BN254, Grumpkin). The library supports both CPU and CUDA GPU backends, with a stable C API and Rust bindings (blitzar-sys). It is designed for use in Space and Time's Proof of SQL, enabling analytic queries on large datasets with sub-second proof generation. The codebase is well-structured with extensive unit tests, benchmarks, and a Bazel/Nix build system. It incorporates optimized algorithms (Pippenger, bucket methods) and low-level field/curve arithmetic adopted from libsodium and zkcrypto, demonstrating strong engineering craftsmanship in GPU cryptography.
libbpf-rs is a Rust workspace providing safe, idiomatic bindings to the Linux libbpf C library for eBPF program development. It consists of two main crates: `libbpf-rs`, a high-level runtime library for loading, attaching, and managing eBPF programs and maps, and `libbpf-cargo`, a Cargo plugin that compiles eBPF C source files and generates Rust skeleton code with type-safe accessors and lifecycle management. The library supports a wide range of eBPF attachment types (kprobes, tracepoints, XDP, TC, netfilter, etc.), CO-RE (Compile-Once-Run-Everywhere) via BTF, and includes utilities like ring buffer and perf buffer helpers, a query interface for inspecting loaded kernel objects, and a linker for combining multiple BPF objects. Architecture is a workspace with library crates and numerous example applications (e.g., runqslower, tcp_ca, tproxy) demonstrating real-world usage. Entry points include `ObjectBuilder`, `SkeletonBuilder` (from libbpf-cargo), and generated skeleton APIs. The project relies on `libbpf-sys` for FFI, and examples use `clap` for CLI and `plain` for safe byte conversion. It is heavily tested with integration tests requiring root privileges.
This repository provides safe Rust bindings to FFmpeg multimedia libraries (avcodec, avformat, avfilter, avutil, swscale, swresample). It functions as a multimedia processing library enabling audio/video decoding, encoding, filtering, muxing/demuxing, and device handling through idiomatic Rust abstractions over FFmpeg's C API. The architecture follows FFmpeg's subsystem organization with modules for codecs, formats, filters, software scaling/resampling, and utilities. Key entry points include ffmpeg::init() for initialization, format::context for I/O handling, codec::context for encoder/decoder setup, and filter::graph for filter chains. Data flows typically involve opening input contexts, decoding packets to frames, optional processing (filtering/scaling), encoding frames, and writing output contexts. The crate maintains compatibility with FFmpeg versions 3.4-9.0 via feature-gated version tracking.
This repository provides Rust bindings to Apple's Security.framework, enabling safe access to Keychain services and TLS/SSL functionality. It consists of a safe wrapper crate (`security-framework`) built upon raw FFI bindings (`security-framework-sys`), with platform-specific implementations for macOS. The library employs idiomatic Rust patterns such as the builder pattern for configuration, Core Foundation type wrappers for automatic memory management, and zero-cost abstractions using `PhantomData`. Examples demonstrate TLS client connections and Keychain password operations. The architecture separates unsafe FFI bindings (generated via `ctest2` from Apple headers) from safe abstractions. Key components include Keychain item management (search/add/update/delete), SSL/TLS client/server contexts, certificate handling, and cryptographic transforms. The project is actively maintained with recent commits, includes test harnesses for iOS and system validation, and shows awareness of API evolution through deprecation markers.
Rutie is a Rust library that provides comprehensive bindings to the Ruby C API, enabling bidirectional integration between Rust and Ruby. It allows Rust programs to embed the Ruby VM, create and manipulate Ruby objects, define Ruby classes and modules from Rust, and wrap Rust structs as Ruby objects with garbage collection support. The architecture is layered: `rubysys` contains raw FFI declarations to Ruby's C functions, `binding` provides safe wrappers around those FFI calls, and `class` offers a high-level public API with well-documented types like `Array`, `Hash`, `RString`, `Class`, and `VM`. The library also includes powerful macros (`class!`, `methods!`, `wrappable_struct!`) that simplify defining Ruby-compatible types and methods. It is actively maintained, supports Ruby 2.7 through 3.4, and uses the `rb-sys` crate for modern Ruby compatibility. The codebase is well-structured, extensively documented with examples, and demonstrates advanced FFI patterns, though it acknowledges that some operations are unsafe due to Ruby's exception handling model.