Spacedrive is a cross-platform file manager and virtual distributed file system (VDFS) that unifies files across devices and cloud storage into a single, searchable library. The core engine is written in Rust and provides indexing, media processing (thumbnails, OCR, speech-to-text), P2P sync with conflict resolution, volume detection, file operations, and an extensible WASM plugin system. The codebase is a large monorepo with multiple frontends: a Tauri desktop app, React Native mobile app, CLI, and web interface, all communicating with a daemon process via a typed RPC protocol. The architecture follows CQRS/DDD patterns with auto-generated TypeScript types and a job/task system for background work.
This is a large, multi-language monorepo from X (formerly Twitter) containing the core code for the For You feed recommendation system. It includes real-time Rust services (home-mixer, thunder, vm-ranker), a Scala rule engine (botmaker) for spam/abuse detection, Python ML training infrastructure (phoenix/xrex), content safety pipelines (grox), and batch feature extraction jobs (simclusters, agatha). The system is composed of loosely coupled services communicating via thrift/gRPC and Kafka, with a strong emphasis on modular pipeline architectures (sources, hydrators, filters, scorers, selectors). While the code demonstrates high craftsmanship with clean abstractions and extensive use of traits/interfaces, it is deeply integrated with internal infrastructure (Manhattan, Strato, Finagle) and requires significant adaptation for external reuse. The repo is hybrid, containing both production application services and substantial ML research/training code.
Vibe Kanban is a full-stack, dual-deployment application (local Tauri desktop app + remote cloud service) that combines Kanban-style issue tracking with AI coding agent workspaces. The local backend is a Rust Axum server backed by SQLite, while the remote backend uses PostgreSQL with ElectricSQL for real-time sync. The system allows users to create projects, manage issues, and launch coding workspaces where AI agents (Claude, Codex, Gemini, Copilot, etc.) execute tasks on isolated branches with preview servers, git operations, and automated code review. It includes a relay tunnel system for remote host pairing, a WebRTC transport for low-latency streaming, and an MCP server for external tool integration. The frontend is built with React, Tailwind CSS, and a shared component library, supporting localization in 7 languages. The project is officially sunsetting, as stated in the README, but the codebase remains a substantial example of a modern Rust/TypeScript monorepo with real-time collaboration, AI executor abstraction, and multi-platform delivery.
Sled is an embedded key-value store written in Rust that provides ACID transactions, crash safety, and high concurrency. It uses a lock-free architecture based on a lock-free pagecache, lock-free log, and lock-free B+ tree with epoch-based memory reclamation. The database supports multiple keyspaces, watch prefixes, merge operators, and a crash-safe monotonic ID generator. Currently in active development with a major rewrite underway (komora project), it is alpha software with known instability and frequent breaking changes, but demonstrates advanced concurrent data structure techniques.
Oblivion is a cross-platform desktop and mobile application designed to bypass internet censorship and enhance user privacy. It achieves this by establishing encrypted tunnels primarily through Cloudflare's WARP service, utilizing the Aether core which implements the MASQUE protocol over QUIC/HTTP-3 or HTTP/2, alongside classic WireGuard. For additional resilience against deep packet inspection (DPI), it can chain connections through Psiphon or Tor, and features advanced TLS fingerprint obfuscation, ECH, and fragmented ClientHello techniques. The application follows a hybrid architecture. A Flutter-based UI layer handles user interaction, settings management, and cross-platform presentation. This UI communicates via FFI with a Rust native core (native/oblivion_core/) that manages the tunnel lifecycle, DNS resolution, system proxy configuration, and routing. Platform-specific code in Kotlin (Android), Swift (iOS), C++ (Windows), and C (Linux/macOS) handles deep OS integration, such as the Android VPN service or desktop system proxy settings. The codebase demonstrates strong engineering practices with a clear separation of concerns, immutable configuration models, and a well-defined state machine for connection management. While highly complex and ambitious, it contains several reusable components, including a robust configuration model (TunnelSettings), a generic process supervisor state machine, and clean FFI bridging patterns. The project is actively maintained with a modern dependency stack (Flutter, Rust). Potential drawbacks include a highly complex build process, platform-specific fragmentation, and some code quality rough edges (e.g., extensive use of unwrap() in Rust, fragile log parsing). The CC BY-NC-SA 4.0 license restricts commercial use and reuse.
Kalker is a multi-platform mathematical calculator implemented primarily in Rust. It provides a CLI with a REPL, a web component compiled to WebAssembly, and an Android mobile app via Capacitor. The core library (`kalk`) supports user-defined variables and functions, units, differentiation, integration, root finding, equation systems, matrices/vectors, complex numbers, and multiple number bases. The codebase is well-structured with a clear separation between parsing (lexer/parser), evaluation (interpreter), and a custom value system. It features extensive test files and integration tests for numerical methods. While the core numerical routines (tanh-sinh quadrature, Newton's method, Gaussian elimination) are tightly coupled to the interpreter, they are implemented with care and demonstrate non-trivial numerical analysis. The repository also includes build scripts for multiple targets and CI/CD pipelines.
MiniRust is a formal specification of an idealized subset of Rust, known as MiniRust, with an executable model defined in a custom specification language (specr). The repository provides tooling that translates real Rust MIR (via rustc) into MiniRust and runs it through a reference interpreter. It includes a comprehensive test suite (minitest) covering pass, panic, and undefined behavior scenarios, along with utilities for program construction and pretty-printing. The work is squarely a formal-semantics research project, not a production application. It models pointer provenance, aliasing (Tree Borrows), concurrency, and data-race detection, and is primarily used to validate the Rust memory model. The codebase is well-structured with clean abstractions (pluggable memory model, builder API) but depends heavily on unstable rustc internals and has many incomplete features (e.g., floats, operators, casts).
SuperCoder is a local-first, open-source AI coding agent with a desktop application (Tauri + Rust + React) and a suite of backend services. The core agent (Rust crate) provides an LLM-driven loop with tool execution (file editing, bash, git, code search), subagent spawning, and an 'Auto' mode where an orchestrator LLM generates plans executed by worker agents. The desktop app offers a rich UI for agent interaction, diff review, file exploration, and permission management. A separate Go-based 'Context Engine' service indexes codebases into vector (Qdrant), graph (FalkorDB), and text stores, enabling semantic code search, dependency analysis, and automated PR review with risk scoring. The repository also includes a legacy v1 backend (Go) with workflow executors for Django/Flask/Next.js code generation and a workspace service for managing isolated development environments. While primarily an application, the context engine introduces data/research elements through its indexing pipelines, retrieval strategies, and code review analytics.
AutoPy is a cross-platform GUI automation library implemented in Rust and exposed to Python through PyO3. It provides programmatic control of the mouse and keyboard, screen capture, bitmap pixel inspection, and color detection. The library abstracts over Windows, macOS, and X11 backends, so the same Python API works across desktop platforms. It is distributed as a Python extension module built with maturin/setuptools-rust and is also usable as a Rust crate.
ThinkWatch is a Rust workspace implementing an AI gateway platform that fronts multiple model providers and MCP (Model Context Protocol) servers. It exposes OpenAI-compatible chat/completion endpoints, streaming, MCP tool-call routing, content filtering, and provider failover. The backend is split into crates: `common` (shared lifecycle/limits/access), `auth` (PoW login, API keys), `gateway` (model routing), `mcp-gateway` (MCP server proxying), `server` (REST admin/audit/trace endpoints), and `test-support` (integration test client). A React/TypeScript frontend in `web/` provides an admin console, setup wizard, limits panels, and MCP server management. Data flows: requests enter the gateway, pass through `check_limits`, `check_budget`, `check_access`, then `run_post_invoke`; `trace_id` is propagated across gateway, MCP, audit, and app logs stored in ClickHouse; Postgres holds users, API keys, budgets, and MCP server configs; Redis/Lua scripts enforce rate limits.
This repository is the full-stack implementation of Mega, a large-monorepo Git hosting and code collaboration platform with a Rust backend and a large React/Next.js frontend. The backend is split into several crates: mono provides the HTTP/SSH API server, ceres contains application services for Git operations, change lists (CLs), code review, build triggers, webhooks and notifications, jupiter handles persistence through SeaORM entities and storage services, jupiter-migrate manages a large sequence of database migrations, and orion/orion-server implement a Buck2-based distributed build orchestration system. The frontend in moon/apps/web is a feature-rich collaboration application with posts, notes, chat, notifications, project management, diff viewing, CL/merge-queue review, admin groups, OAuth integrations, and editor support. The core operational flow is: git push/import -> ceres transport and jupiter storage -> change list and merge-queue workflows -> build triggers sent to Orion -> build events/checks streamed back to the UI.
Memospot is a desktop application that bundles the Memos note-taking service as a self-contained Tauri v2 wrapper. It manages the Memos server as a sidecar process, provides a SvelteKit frontend for settings and interaction, and handles configuration persistence, database migrations, window state, keyboard shortcuts, and auto-updates. The architecture is a Rust backend with a web frontend, using a Rust workspace with multiple crates for config, dialogs, sidecar management, port picking, and homedir resolution. The frontend is built with SvelteKit, Tailwind CSS, and uses Paraglide for i18n. The build system includes GitHub Actions CI/CD, Docker-based builds, and installers for Windows (NSIS/WiX), Linux (deb, AppImage, Flatpak), and macOS. The codebase demonstrates solid engineering practices with clean abstractions and reusable utility crates, though it has some pinned dependencies and complex CI workflows.
This repository is a Rust workspace that provides two main libraries: `daisy_rsx`, a collection of reusable UI components for the Dioxus framework styled with DaisyUI, and `ssg_whiz`, a static site generation framework that renders Dioxus components to HTML, processes markdown with syntax highlighting, and supports blog, documentation, and marketing layouts. The workspace also includes an example site that demonstrates the full pipeline from content to deployed static output. The code is well-structured with enums for styling, SSR rendering, and a build pipeline that includes image resizing and diagram generation. While `daisy_rsx` components are standalone and readily reusable across projects, `ssg_whiz` is more opinionated and tightly integrated into the workspace, limiting reuse without additional decoupling.
Mevlog-rs is a Rust-based, open-source alternative to commercial blockchain explorers like Dune Analytics, providing a comprehensive toolchain for indexing, storing, and querying EVM-compatible blockchain data. The core system downloads raw chain data from RPC endpoints, stores it in per-chain SQLite databases, and allows read-only SQL queries enriched with custom U256 arithmetic, formatting, and ENS resolution. It includes a CLI with 20+ subcommands, a web backend (Axum + React) for hosted exploration, a TUI (ratatui) for interactive browsing, and an MCP server for AI agent integration. The system is heavily oriented toward MEV (maximal extractable value) analysis, with coinbase transfer detection, state diffs, and call tracing via local revm replay or RPC. Key architectural patterns include a shared dependency initializer, a secure read-only SQL sandbox with progress limits, a config-driven custom table engine, and a reorg-aware indexing pipeline that handles chain reorganizations. While the codebase demonstrates strong craftsmanship and modularity, its large dependency surface, reliance on external services (ChainList, Pinata, cryo), and some commented-out tests indicate ongoing evolution and moderate maintenance risk.
MooTool is a cross-platform developer toolbox with over 30 utilities including JSON formatting, HTTP client, regex testing, encryption/decryption, color picker, diff viewer, QR code, cron expressions, translation, image processing, PDF manipulation, code runtime, and more. The repository contains three concurrent implementations: a legacy Java Swing desktop application (with FlatLaf theming and MyBatis/SQLite persistence), an Electron+React+TypeScript rewrite (using CodeMirror, pdf-lib, and native IPC bridges), and a Tauri 2 (Rust+React) version with additional native features like screen capture, system tray, and updater integration. A macOS native SwiftUI app is also provided as a preview. The architecture is modular per tool, with shared contracts across platforms, session tracking, operation history, and vault-based note storage with Git versioning. Key entry points include the Java MainFrame, the Electron main process (electron/main/index.ts), and the Tauri Rust backend commands. Data flows are entirely local (SQLite, file vault, settings JSON) with no cloud dependency except automated translation APIs and optional update checks. External dependencies include Java runtime, Git, protoc, Tesseract OCR, system keyring, and translation web services (Google, Bing).
This repository is a comprehensive, step-by-step tutorial series for learning wgpu, the Rust implementation of WebGPU. It contains over 30 example crates organized into beginner, intermediate, compute, and showcase categories, each demonstrating a specific GPU concept (window creation, pipelines, buffers, textures, uniforms, instancing, depth, lighting, normal mapping, HDR, compute shaders, etc.). The code is production-quality Rust with extensive use of wgpu, winit, cgmath, and bytemuck. A reusable framework crate (`code/showcase/framework`) provides a `Demo` trait, camera, model/texture loading, and pipeline builders, which many showcases implement. The repository also includes a VuePress documentation site with embedded WebAssembly demos, build scripts for WASM deployment, and a demo server. While the tutorials are well-structured and educational, there is significant code duplication across crates (e.g., identical `build.rs` files, repeated initialization boilerplate), and some showcases are stale or excluded from builds. The codebase tracks wgpu API changes closely (news files document migrations from 0.12 to 30.0), but some patterns use deprecated APIs (e.g., `wgpu::Backends::PRIMARY`, `immediate_size` in pipeline layouts). Overall, it is a valuable learning resource with solid engineering practices, though not a production library.
This is the playit.gg tunnel agent, a production-grade client-side daemon that exposes local servers (e.g., Minecraft, game servers, web services) to the internet through the playit.gg tunnel network. The system is organized as a Rust multi-package workspace comprising five main crates: `agent_core` (tunnel state machine, TCP/UDP proxying, control connection), `playitd` (background daemon with IPC server, stats, log rotation), `playit-cli` (CLI and TUI frontend using ratatui), `playit-ipc` (local IPC protocol with version negotiation), and `playitd-tray` (Windows system tray controller). It supports Linux, Windows, macOS, and FreeBSD, with platform-specific path handling (Unix sockets, named pipes, Windows service management). The architecture centers on a UDP control connection to playit.gg servers: the agent authenticates via HMAC-SHA256, receives tunnel assignments, then proxies TCP and UDP traffic between tunnel ingress points and local origin servers. The daemon runs as a background service (systemd, OpenRC, Windows service) and exposes a local IPC endpoint for the CLI/TUI to monitor logs, stats, and lifecycle status. Key entry points include `packages/playitd/src/bin/playitd.rs` (daemon binary), `packages/playitd/src/bin/playitd-service.rs` (Windows service host), `packages/playit-cli/src/main.rs` (CLI with attach/start/stop/claim commands), and `packages/playitd-tray/src/main.rs` (Windows tray application). External dependencies include tokio (async runtime), ratatui (TUI), crossterm (terminal), serde (serialization), reqwest (REST client), and ring (HMAC). The codebase demonstrates strong craftsmanship in low-level networking (zero-copy UDP packet pools, PROXY protocol, statically-sized control messages) and state machine design (connection recovery, MTU probing, address selection). However, it suffers from some production debt: panics in critical paths (UDP channel shutdown, flow invariants), duplicated code between `playitd-tray` and `playitd-windows-setup` startup shortcuts, and hardcoded configuration values (control port, protocol version). The build and release infrastructure is extensive (nfpm, WiX, Docker, Arch PKGBUILD, code signing) but shows signs of fragility (stale binary name in mac-deploy.sh, sed-based version overrides).
This repository is a Chinese-language translation and expansion of the Learn wgpu tutorial series, teaching the wgpu Rust implementation of the WebGPU graphics API through a Cargo workspace of ~25 runnable example crates. The curriculum progresses from window/surface setup (tutorial1-2), render pipelines and buffers (tutorial3-4), textures/uniforms/instancing/depth (tutorial5-8), through OBJ model loading, Blinn-Phong lighting, normal mapping, camera control, compute-shader terrain generation, HDR rendering, and particle systems. Each example is a small but complete winit application that runs natively and as WebAssembly via wasm-bindgen, sharing a common utils crate that provides the WgpuAppAction lifecycle trait, node-based render abstractions (ViewNode, ComputeNode, BufferlessFullscreenNode), and buffer/bind-group helpers. A VitePress documentation site embeds live WASM demos of the examples, and showcase crates demonstrate a Pong game, offscreen GIF encoding, multithreaded model loading, and compute-shader tangent generation. Although primarily a tutorial codebase, it is genuinely hybrid: it doubles as a deployable documentation site and a reference implementation of modern wgpu patterns.
speakersafetyd is a Rust system daemon that implements a software Smart Amp speaker protection model for Apple Silicon Macs running Linux. It reads voltage and current sense (V/ISENSE) data from a TAS2764-class codec via an ALSA capture PCM, simulates voice coil and magnet temperatures using per-machine configurable thermal parameters, and reduces speaker volume through ALSA mixer controls when temperatures approach limits. The daemon is fail-safe by design: the kernel keeps speakers volume-limited until the daemon writes an unlock magic value, and any panic causes the daemon to exit so the kernel can restore the safe state.
This repository is a polyglot web converter application built with Next.js. It provides a large collection of code transformations (e.g., JSON to TypeScript, SVG to JSX, GraphQL to Resolvers, HTML to Pug, etc.) in a user-friendly two-pane editor interface. The architecture is a monolith with each transformation implemented as a separate page under `pages/`, all sharing a common `ConversionPanel` component that manages the input/output editors, web workers for heavy processing, and server-side API routes for a few transforms that require Node.js native modules. External dependencies include numerous npm libraries for the actual conversion logic (e.g., `json_typegen_wasm`, `@svgr/core`, `graphql-codegen`), the Monaco editor for code editing, and the evergreen-ui component library for the UI. The application uses web workers extensively (via a custom `workerWrapper` utility) to offload CPU-intensive conversions off the main thread, ensuring a responsive UI. Data flows from the user's input editor, through a transformer function (which may call a web worker or an API endpoint), and into the output editor, with results automatically formatted by Prettier. The codebase is well-structured with a consistent pattern for each converter, making it straightforward to add new transformations.