GNvim is a GTK4-based Neovim GUI written in Rust. It communicates with Neovim via the MessagePack-RPC protocol, providing a native desktop experience with features like floating windows, popup menus, tabline, cmdline, and smooth animations for cursor and scrolling. The architecture is a single Rust binary split into a workspace: the main `ui` crate contains the GTK4 frontend with custom widgets (e.g., Grid, GridBuffer, Cursor, Fixedz, Popupmenu, Shell), and the `nvim-rs` library crate provides a reusable, async RPC client for Neovim with auto-generated API bindings. The system's entry point is `ui/src/main.rs`, which registers resources and launches the GTK application. Data flows bidirectionally: Neovim sends UI events (redraw, options, notifications) as RPC messages, which are deserialized into Rust types and applied to the GTK widget tree; user input (keyboard, mouse) is captured by GTK event controllers and sent back to Neovim as RPC calls. The codebase is well-structured, modular, and follows modern Rust async patterns, with extensive use of GTK4's property system and custom layout managers for complex UI composition.
Rusted PackFile Manager (RPFM) is a desktop application for modding Total War games. It provides comprehensive tools for opening, editing, and saving proprietary game pack files (.pack) and dozens of embedded binary formats (animations, models, sound banks, battle maps, UI layouts, etc.) across all major Total War titles from Empire to Warhammer 3. The application is built in Rust with a Qt6 frontend, using a client-server architecture where the UI delegates heavy file operations to a background server over WebSocket. It also exposes a headless server with WebSocket and MCP endpoints for AI tool integration. The codebase is modular, with separate crates for core library (`rpfm_lib`), extended features (`rpfm_extensions`), IPC protocol (`rpfm_ipc`), telemetry (`rpfm_telemetry`), and shared UI utilities (`rpfm_ui_common`). It includes custom C++ Qt widgets, a plugin scripting system (Lua/Python), and self-update capabilities.
This repository is neo4rs, a production-grade asynchronous Rust driver for the Neo4j graph database. It implements the Bolt binary protocol (versions 4.x with partial 5.x support) and provides a complete client library for querying, transaction management, connection pooling, cluster routing, and serialization of Neo4j's rich data types (nodes, relationships, paths, temporal and spatial values). The architecture is modular: a connection layer handles TCP/TLS handshakes and chunked message framing; a PackStream serializer/deserializer converts between Rust types and the Bolt wire format; a routing module manages cluster membership and load balancing; and a high-level API (Graph, Session, Txn, RowStream) offers async query execution with automatic retry on transient errors. The codebase includes two parallel Bolt protocol implementations—a legacy one and a newer feature-gated version—which introduces maintenance overhead. Despite this, the project is actively maintained with extensive integration tests against multiple Neo4j versions and a robust CI pipeline. The library is suitable for any Rust application that needs to interact with Neo4j, offering both a high-level ergonomic API and low-level control over the protocol.
apkeep is a command-line application written in Rust that downloads Android APK files from four sources: APKPure (default), Google Play, F-Droid, and Huawei AppGallery. The binary accepts individual app IDs or CSV lists, supports specifying versions, listing available versions, parallel fetches, sleep throttling, and per-source options. For Google Play, it supports AAS or AUTH token authentication, device profiles, locale/timezone overrides, split APK and OBB expansion file downloads. For F-Droid, it downloads and cryptographically verifies the signed repository index (both legacy index-v1.jar and the newer entry.jar) before selecting APKs, checking certificate fingerprints and digest chains.
Sailfish is a compile-time template engine for Rust, designed for high-performance server-side rendering. Unlike runtime template engines that parse templates on every request, Sailfish uses procedural macros to parse `.stpl` files and generate optimized Rust code at compile time. This architecture ensures type safety, eliminates runtime parsing overhead, and allows for aggressive compiler optimizations. The engine integrates seamlessly with Rust's ecosystem, supporting features like embedded Rust code, filters, and includes within templates. The architecture is split into three main crates: `sailfish-compiler` handles the parsing and translation of template syntax into Rust AST, `sailfish-macros` provides the derive macros that trigger compilation, and `sailfish` contains the runtime logic for rendering and buffer management. The project emphasizes performance through custom memory allocation strategies and SIMD-optimized HTML escaping routines. It also includes comprehensive editor support via Tree-sitter grammars and VS Code/Vim syntax extensions. While the core engine is robust and well-architected, there are significant maintenance inconsistencies. The `Cargo.toml` specifies `edition = "2024"`, which is not a stable Rust edition, indicating experimental or forward-looking configuration. Additionally, the `CHANGELOG.md` lags significantly behind the actual version in `Cargo.toml` (v0.4.0 vs 0.11.2), suggesting documentation is not kept in sync with releases. Despite these issues, the codebase demonstrates high craftsmanship in its performance-critical components.
OpenMod is a .NET-based plugin framework designed for extensibility across game servers and applications. It provides core services including dependency injection, event handling, command processing, permission systems, user management, and configuration management. The framework features a modular architecture with platform-specific adapters for games like Unturned and Rust, enabling developers to create plugins that extend functionality without modifying the core. The system uses an event-driven approach for loose coupling and supports self-updating via NuGet package management. While primarily focused on game server modding, the core abstractions are general enough to apply to other extensible application scenarios.
sax-wasm is a high-performance SAX-style XML/HTML/JSX parser written in Rust and compiled to WebAssembly, with JavaScript/TypeScript bindings for Node.js and browsers. It provides streaming parsing of byte streams, emitting events for tags, attributes, text nodes, processing instructions, comments, CDATA, and doctype declarations. The parser is non-validating and focuses on raw speed, using SIMD instructions and optimized grapheme cluster handling. It includes a comprehensive TypeScript API with async generator support for streaming reads from ReadableStream. The repository contains the full Rust source, JS/TS bindings, build tooling (wasm-bindgen, wasm-opt), and extensive test suites covering XML, JSX, Angular templates, edge cases with multi-byte characters, and write-boundary splitting. While the parser is highly optimized and well-tested, the project appears to be in a stale maintenance state with no recent commits (last commit dated 2026-09-13, likely erroneous) and a small community following.
Wisp is a local-first, real-time meeting transcription desktop application built with Rust and SvelteKit, using Tauri v2 for cross-platform deployment (macOS Apple Silicon, Windows x64). It captures microphone and system audio, runs on-device automatic speech recognition (ASR) using multiple engines (whisper.cpp, sherpa-onnx, Apple Speech), provides live speaker-diarized transcripts with timestamps, and supports offline semantic search via local ONNX embedding models. The architecture is modular, with pluggable traits for audio sources, ASR engines, denoisers, echo cancellers, and model stores. It also offers optional cloud transcription (OpenAI, Gemini, Groq, etc.) and AI assist features. Although primarily an application, it integrates significant data engineering patterns for streaming audio processing, feature extraction (VAD, diarization), and on-device model management.
This repository is the 'Awesome Rust' curated list of Rust projects, libraries, and resources. The core of the repository is the `README.md` file. The application code (`src/main.rs`) is a monolithic CLI tool that acts as a linter and validator for this list. It parses the markdown, checks all URLs for liveness, fetches GitHub stars and crates.io download counts to enforce minimum popularity thresholds, and validates the alphabetical ordering and formatting of entries. It runs as a GitHub Action on every push and pull request to maintain the quality of the list. The code is functional and actively maintained, but it is a single-script application with outdated dependencies and no tests, representing a pragmatic but technically debt-ridden solution tailored specifically to this project.
This repository is an open-source terminal-based AI coding assistant built in Rust, clean-room reimplementing Anthropic's Claude Code. It provides an interactive TUI (ratatui) for multi-provider LLM conversation (Anthropic, OpenAI, Google, and 30+ OpenAI-compatible) with a rich tool ecosystem for file editing, bash execution, MCP integration, code analysis, web fetching, and agent orchestration. The architecture is modular: a provider abstraction layer (`LlmProvider` trait), plugin system, slash commands, session management, and an Agent Client Protocol (ACP) for external IDE integration. The codebase is organized into 12+ workspace crates with clear separation of concerns, but many modules are still in active refactoring (issue #232) with stubs, TODOs, and incomplete feature gates (36 experimental features). The permission system, tool budget enforcement, and streaming decoders demonstrate strong engineering, while dual feature flag systems and global mutable state introduce maintenance risk. Overall, it is a feature-rich, well-architected application with some rough edges from ongoing migration.
turm is a terminal user interface (TUI) application for monitoring and managing Slurm workload manager jobs. It provides real-time job tracking, log viewing, and job control capabilities through a keyboard-driven interface. The application architecture centers around two main background threads: a job watcher that periodically executes `squeue` to gather job information, and a file watcher that monitors job output files for changes using efficient tail-like reading with polling fallback for network filesystems. The UI is built with ratatui and handles user input via crossterm, offering features like job filtering, sorting, scrollable logs, and interactive dialogs for job control operations. The project includes mock implementations of Slurm commands for local development and testing without requiring an actual Slurm cluster.
This repository implements the Dusk Network blockchain node (Rusk), a full Proof-of-Stake node with privacy-preserving transactions (Phoenix) and public transactions (Moonlight). The system is a Rust workspace containing a consensus engine (succinct attestation consensus with proposal/validation/ratification steps), a WebAssembly-based smart contract VM (Piecrust), a RocksDB/SQLite ledger, a mempool, an HTTP/GraphQL API server (Axum), and a CLI/TUI wallet. It also includes a JavaScript SDK (w3sper.js) for browser/Deno wallet interaction and a wallet-core library compilable to WASM. The architecture is modular: the node binary (rusk/src/bin/main.rs) composes services via a builder pattern (RuskNodeBuilder), supporting both full-chain and HTTP-only modes. Key data flows include transaction submission via RUES (Rusk Event System) or GraphQL, consensus message propagation over Kadcast P2P, block execution through the VM with hard-fork feature gating, and state persistence via RocksDB column families. External dependencies include dusk-plonk, dusk-poseidon, jubjub-schnorr, wasmtime, rkyv, and sqlx. The codebase demonstrates high craftsmanship in areas like deterministic committee sortition, zero-knowledge proof verification caching, and a reusable data-driver pattern for contract encoding/decoding.
rsclaw is a production-grade AI agent gateway and runtime written in Rust, with a React/Tauri desktop UI. It provides a local-first autonomous agent engine that routes messages through 13+ messaging channels (WeChat, Telegram, Discord, Slack, Feishu, etc.) to any of 15+ LLM providers (Anthropic, OpenAI, Gemini, Grok, DeepSeek, etc.). The core architecture is a WebSocket gateway that manages agent sessions, tool execution, memory persistence, skill invocation, and a knowledge base RAG pipeline. Key subsystems include a computer-use GUI agent (native + browser + ADB + iPhone Mirror operators), a plugin system (WASM, JS subprocess, Codex bundles), an agent-to-agent (A2A) protocol for distributed orchestration, and a three-tier memory store (redb KV + Tantivy FTS + HNSW vectors). The binary is a single compiled crate (~21MB) with no Node.js runtime dependency for the backend. The accompanying Next.js web UI and Tauri desktop shell provide a ChatGPT-like chat interface, memory management, model configuration, and computer-use overlays. While primarily an application, the knowledge base and memory subsystems incorporate significant data engineering patterns: content-aware chunking, hybrid vector/FTS search, entity extraction, and a job-based ingestion pipeline with leadership/leaderboard semantics.
term39 is a cross-platform terminal multiplexer and emulator built in Rust, featuring a retro MS-DOS aesthetic. It provides a full-screen text interface with window management (drag, resize, minimize, maximize, auto-tiling), terminal emulation via VTE ANSI parsing and PTY integration, session persistence through a Unix daemon, a lockscreen with OS-level authentication (PAM, macOS DS, Windows Security, PIN), and an optional Linux framebuffer backend for direct console rendering. The application supports multiple platforms including Linux, macOS, Windows, FreeBSD, NetBSD, OpenBSD, and Android/Termux, with feature-gated builds via Cargo features. The architecture is modular: an event loop drives input handling (keyboard, mouse) and rendering through a `RenderBackend` trait that abstracts terminal (crossterm) and framebuffer backends. The UI is composed of widgets (top bar, battery, network, system menu) and dialogs (config, prompt, toast, info). Terminal state is managed by `TerminalGrid` and `TerminalEmulator`, with ANSI escape sequences parsed by `AnsiHandler`. Session persistence uses a client/daemon pattern over Unix domain sockets, allowing windows to be detached and reattached. The lockscreen supports multiple authentication backends via a factory pattern. While the codebase is feature-rich and well-structured in many areas, it exhibits some technical drift: dead code artifacts (e.g., a disabled restore line in main.rs), heavy use of `#[allow(dead_code)]`, platform-specific code duplication, and unsafe operations in forking and signal handling. The rapid version history (0.1.0 to 1.6.0 in about a year) suggests fast iteration, which may have introduced some technical debt. Nonetheless, the project demonstrates strong engineering in its abstraction layers, widget system, and cross-platform support.
cargo-sweep is a Cargo subcommand designed to selectively clean unused build artifacts from Rust project target directories. It operates based on various criteria such as file age, installed Rust toolchains, or target directory size limits, allowing users to reduce disk usage without performing a full 'cargo clean'. The tool is implemented as a standalone Rust binary that integrates with Cargo's metadata system to locate projects and analyze their build artifacts. The architecture centers around a modular design where command-line argument parsing (using clap) feeds into a criterion-based cleaning system. Key components include a sophisticated fingerprinting module that replicates Cargo's internal mechanism for associating build artifacts with specific Rust compiler versions, a timestamp handling system for time-based cleaning, and utility functions for human-readable byte formatting. The tool recursively discovers Cargo projects, evaluates which artifacts to retain based on the selected criterion, and safely removes the rest. Despite its technical sophistication, the project carries a maintenance warning in its README indicating it is currently unmaintained and lacks a dedicated maintainer. This is reflected in outdated dependencies (particularly cargo_metadata at version 0.9 versus the latest 0.18.0) and the project's reliance on the original author for issue triage and pull request reviews. While the code demonstrates strong engineering practices and reusable components, its future viability depends on renewed community stewardship.
NOALBS is a Rust application that automatically manages OBS stream quality by monitoring real-time stream health (bitrate, RTT, offline detection) from various stream servers (Nginx-RTMP, SLS, Xiu, Mediamtx, etc.) and switching scenes in OBS accordingly. It also functions as a Twitch/Kick chat bot, allowing streamers to control streaming behavior via commands. The architecture is a single async binary using Tokio, with modular traits for stream servers (StreamServersCommands), broadcasting software (BroadcastingSoftwareLogic), chat platforms, and configuration. Key data flows: config loading → state initialization → polling stream server stats via HTTP → receiving OBS WebSocket events → switching logic updates OBS scenes. External dependencies include OBS WebSocket, Twitch IRC/PubSub, and various streaming server APIs. The codebase demonstrates non-obvious Rust patterns such as using `typetag::serde` for serializable trait objects and a localization system with YAML files. However, some commented-out code, hardcoded delays, and a warning about an OBS source feature being broken indicate areas of incomplete refactoring.
This repository contains implementations of a 'swapview' program that displays Linux process swap usage in many different programming languages. Each implementation reads from the /proc filesystem to gather swap information for all processes and outputs a formatted table sorted by swap usage. The project includes a top-level Makefile to build all implementations, benchmarking tools (bench.py and a Rust-based benchmarker) to compare performance across languages, and result files showing historical performance data. The code serves as both a practical utility for monitoring swap usage and a comparative study of language performance and idioms.
This is the original zkSync L2 scaling monorepo (zkSync Lite), implementing a ZK-rollup on Ethereum with low-gas ETH/ERC20 transfers, plus NFTs, swaps, and forced exits. The code is primarily a Rust backend with multiple binaries and services: the core state-keeper/committer (`zksync_core`), REST/JSON-RPC/Web3 API server (`zksync_api`), PLONK prover and witness generator, Ethereum transaction sender, event listener, data-restore tool, and exit-tree generator. It also contains Solidity smart contracts, JavaScript/Rust SDKs, a TypeScript integration test suite, and a large PostgreSQL storage layer with Diesel migrations. In production, the system receives L1 deposits and L2 transactions, validates them in a mempool, builds pending blocks in the state keeper, generates witnesses and proofs, and commits/verifies/executes blocks on Ethereum. The API exposes account, transaction, fee, and NFT endpoints, with WebSocket event notifications. The main external dependencies are Ethereum (via web3/ethabi), PostgreSQL, CoinGecko/CoinMarketCap price feeds, and custom `franklin_crypto`/`rescue`/`jubjub` zero-knowledge circuit libraries. The project is now in a deprecation/sunset phase: zkSync Lite is no longer the active product, and the `exit_tree_generator`/exit-tool paths exist primarily to help users withdraw funds. Architecturally, the monorepo is modular and contains several well-isolated patterns worth studying: a generic `Balancer` for channel-based load distribution, an async shared LRU cache, and generic serde wrappers for hex/BigUint/ratio serialization. These components demonstrate solid Rust engineering, but the repository also carries substantial legacy weight: multiple contract and schema versions, ignored tests, hardcoded development keys, old dependency versions, deprecated testnets, and a custom crypto fork. It is best treated as a reference for the original zkSync architecture or as a base for maintaining a sunset service, not as a codebase to absorb as a whole.
MicroBin is a self-hosted pastebin and URL shortener implemented as a monolithic Rust web application using actix-web. It stores pastes (text, files, or URL redirects) in either SQLite (default) or a JSON file, with all state held in memory behind a single global Mutex. The application supports server-side and client-side AES encryption, expiration and burn-after-read limits, QR code generation, server-side syntax highlighting via syntect, multiple file attachments, and animal-name or hash-based opaque identifiers. It is configured entirely through CLI arguments or environment variables, and ships as a single static binary with templates and assets embedded via rust-embed and askama. The architecture is straightforward: actix-web route handlers in src/endpoints process HTTP requests, while src/util contains the database backends, encryption helpers, ID encoders, telemetry, and HTTP client construction. The system is designed for single-instance self-hosting with a small memory footprint. External dependencies include actix-web, rusqlite, askama, syntect, magic-crypt, and reqwest. A background telemetry thread posts anonymized configuration to api.microbin.eu every 24 hours unless disabled, and the admin panel checks for updates against the same API. Maintenance is active with recent commits, multi-platform release CI, and clippy analysis. Technical drift is medium: clap 3, env_logger 0.9, and askama 0.10 lag behind current major versions, and the CI pipeline uses deprecated actions-rs tooling and ::set-output syntax. The codebase has notable duplication (six near-identical auth handlers, repeated SQL schema definitions across every db_sqlite function) and a latent bug in the JSON database path where remove_expired calls delete(None, ...) which panics in JSON mode; the JSON path also hardcodes pasta_data/database.json instead of honoring the data_dir argument. The encryption scheme pads passwords with '#' instead of using a proper KDF, a design weakness for a security-focused feature.
This repository contains the source code for the Poseidon game engine, which powers the remastered version of Arma: Cold War Assault (CWR). It is a large, monolithic C++20 codebase with a modular subsystem architecture covering graphics (OpenGL 3.3), audio (OpenAL), networking (UDP with custom transport), input (SDL), AI, world simulation, UI, and asset management. The engine supports dedicated servers, modding via PBO archives, and a scripting language (SQF/SQS). The repository also includes a suite of CLI tools (PBO packing, image conversion, model inspection, etc.), a Blender addon for importing P3D models, and Rust components for a master server and test harness (Trident). Extensive unit tests (Catch2) and fuzz harnesses are provided. The codebase is a locked snapshot with no active development, but it demonstrates high craftsmanship in areas like custom containers, memory management, and network protocol design. However, it suffers from technical debt including heavy use of preprocessor macros, global state, and platform-specific conditionals.