Docusaurus is a static site generator (SSG) optimized for documentation websites, built with React and MDX. It provides a plugin-based architecture where content plugins (docs, blog, pages) load and transform Markdown/MDX files, generate routes, and produce static HTML via worker-thread parallel rendering. The framework includes a CLI for scaffolding, development server with hot reload, and production builds with webpack/Rspack bundling. Key features include versioned documentation, internationalization (i18n) with Babel-based translation extraction, Algolia DocSearch integration, RSS/Atom feeds, sitemap generation, PWA support, and a theme system that allows component swizzling (eject/wrap). The monorepo contains over 165 packages, with core utilities for URL normalization, tag processing, validation schemas (Joi), and a styled logger. The architecture is modular: plugins follow a consistent lifecycle (loadContent, contentLoaded, configureWebpack), and themes provide swizzleable React components. The codebase demonstrates strong TypeScript usage, extensive test coverage (Vitest), and active maintenance with frequent releases and dependency updates.

RocksDB is a high-performance, embeddable, persistent key-value store library written in C++. It uses an LSM-tree architecture with memtables, sorted string tables (SSTs), multi-level compaction, write-ahead logging (WAL), and advanced caching (LRU, Clock, tiered secondary caches). The codebase is exceptionally well-engineered, with extensive use of templates, platform abstractions, and custom allocators to achieve high throughput and low latency on flash storage. It is not a standalone application but a library consumed by databases (e.g., MyRocks, Cassandra), storage engines, and other infrastructure. The repository includes a comprehensive public API under include/rocksdb/, a C API, Java bindings via JNI, command-line tools (ldb, sst_dump, db_bench), and a fuzz testing suite. The project is actively maintained by Meta and the open-source community, with frequent commits, rigorous CI, and performance benchmarks.

Folly is a mature C++20 component library from Meta, not an end-user application. It provides high-performance primitives for systems programming: containers (F14 hash maps, small_vector, sorted_vector_types), string and JSON handling, concurrency (MPMCQueue, AtomicHashMap, Synchronized), async I/O (EventBase, AsyncSocket, AsyncServerSocket, SSLContext, io_uring integration), multiple async programming models (futures, fibers, coroutines), logging, settings, memory allocation, debugging/symbolization, hashing, compression, and statistics. Consumers embed the library via CMake or Buck2 and link libfolly; there is no standalone service or primary CLI except tools, tests, and examples. Internally, the architecture is strongly modular and header-first: most components are templates in header files with optional .cpp implementations, heavily gated on platform feature macros. Data flows are data-structure and callback oriented: events from sockets/timers are dispatched through EventBase, async results move through Future/SemiFuture/coro::Task continuations, fibers perform cooperative context switches, and the logging framework routes formatted log messages through configurable handlers. External dependencies include Boost, OpenSSL, libevent, fmt, zstd/lz4/zlib, and googletest for testing; the repo includes a dependency builder (getdeps.py) and CI for Linux/macOS/Windows. Folly is actively maintained with frequent commits, broad CI, and extensive test/benchmark suites. Some parts are experimental (folly::result, channels), but core components are production-tested. Technical drift is low: it tracks modern C++, supports current compilers and kernels, and adapts to new CPU features (AVX-512, SVE2, io_uring). A small internal Python-based agent backtesting kit exists under folly/agents/, but it is peripheral; the dominant character of the repository is a high-performance C++ library.

This repository is the reference implementation of the Zstandard (zstd) lossless compression algorithm, developed and maintained by Meta (Facebook). It is a production-grade C library (`libzstd`) that provides fast, high-ratio compression with configurable speed/ratio trade-offs, including negative compression levels for extreme speed. The library is accompanied by a full-featured command-line tool (`zstd`) that supports compression, decompression, streaming, multi-threading, dictionary training, and interoperability with gzip, xz, lz4, and lzma formats. The architecture is modular: a core library (`lib/`) with separate concerns for common utilities, compression strategies (fast, double-fast, lazy, optimal, long-distance matching), decompression, dictionary building (cover, fastCover), and legacy format decoders (v01–v07). The `programs/` directory houses the CLI entry point and file I/O utilities. The codebase is exceptionally well-tested with unit tests, fuzzing infrastructure, regression tests, and CLI integration tests. While the dominant character is an application/library, it also contains research-grade entropy coders (FSE, Huffman) and experimental contributions (edit-distance match finder, parallel pzstd, seekable format, educational decoder), making it a hybrid resource for both production use and compression algorithm study.

Lexical is a modular, extensible rich text editor framework designed for building customizable text editors in web applications. It features an immutable state model with built-in undo/redo, real-time collaboration via Yjs integration, and a plugin-based architecture for extensibility. The framework provides core editing functionality including text manipulation, selection handling, and DOM rendering, along with specialized features for tables, lists, code blocks, equations, and accessibility. Built with TypeScript and supporting React, vanilla JS, and headless environments, Lexical emphasizes reliability, performance, and developer experience through comprehensive testing and documentation.

StyleX is Meta's CSS-in-JS framework that compiles style definitions at build time into atomic CSS classes. The core is a Babel plugin that transforms `stylex.create()`, `stylex.defineVars()`, `stylex.keyframes()`, and other API calls into optimized JavaScript objects with deterministic class names and CSS rules. A small runtime injects the generated CSS into the DOM with priority-based ordering. The monorepo includes a comprehensive set of tools: an ESLint plugin for enforcing best practices, a CLI for pre-compilation, bundler plugins (Vite, Webpack, Rollup, esbuild, Rspack, PostCSS), a Chrome DevTools extension for debugging, and a documentation site built with StyleX itself. The architecture is modular, with separate packages for the runtime, compiler, and integrations, all sharing common utilities. The framework supports theming via CSS custom properties (`defineVars`/`createTheme`), compile-time constants (`defineConsts`), contextual selectors (`stylex.when`), and experimental nested token APIs. It is production-ready, used at Meta, and actively maintained with frequent releases.

Chisel is a collection of LLDB commands for debugging iOS and macOS applications. It provides a rich set of commands to inspect and manipulate the UI hierarchy, view controllers, accessibility, auto layout, animations, and memory. The project consists of Python scripts that define LLDB commands using a custom base class (FBCommand) and a native C/Objective-C framework (Chisel.framework) that enables heap scanning for Objective-C instances. The Python layer evaluates Objective-C expressions in the debugged process, while the native framework uses malloc zone enumeration to find live objects. The architecture is a plugin for LLDB, with commands loaded dynamically from a directory. Key entry points are the LLDB commands themselves (e.g., pviews, pvc, visualize, border, findinstances). External dependencies include LLDB, the iOS/OS X runtime, UIKit, CoreAnimation, and Foundation. The codebase is well-structured but shows some technical drift (Python 2 usage, deprecated imp module, old Xcode project settings).

Proxygen is a production-grade C++ HTTP library developed by Meta, providing comprehensive support for HTTP/1.1, HTTP/2, HTTP/3 (QUIC), and WebTransport. It offers both a classic callback-based server/client framework and a modern coroutine-based API using folly::coro. The architecture is layered: low-level codecs for wire protocol parsing, session management with flow control and rate limiting, transport abstraction (TCP, TLS, QUIC), and high-level handler/filter chains. The library includes extensive utilities for DNS resolution, consistent hashing, stream compression, structured headers, and connection pooling. It is heavily tested and designed for high-performance, multi-threaded production environments. While primarily a server framework, it also provides a full client stack and sample applications (echo, proxy, push, WebSocket, H3). The codebase is well-structured with many reusable components, though it remains tightly coupled to Meta's ecosystem (folly, wangle, fizz, mvfst).

Memlab is a comprehensive JavaScript memory leak detection and heap analysis framework developed by Meta. It provides a CLI, a programmatic API, and an MCP (Model Context Protocol) server for AI-assisted debugging. The system captures heap snapshots from Chromium (via Puppeteer), Node.js, Electron.js, and Hermes, then parses and analyzes them to identify memory leaks, optimization opportunities, and retention patterns. It includes specialized detectors for detached DOM elements, React component leaks, event listener accumulation, duplicate strings, and global variable bloat. The architecture is a monorepo with packages for core parsing and algorithms, E2E browser automation, heap analysis plugins, a public API, a CLI, an in-browser visualizer (MemLens), and an MCP server that exposes over 100 analysis tools. Key data flows involve warmup, browser interaction, snapshot capture, parsing, leak filtering, trace clustering (heuristic and ML-based), and report generation. External dependencies include Puppeteer, Chromium, and the MCP SDK.

FBJS is a monorepo containing Facebook's internal JavaScript utility library and associated tooling. It provides a Babel preset for transforming JavaScript with Flow types, ESLint configurations enforcing Facebook's code style, a core utility library with functional programming helpers, data structures, DOM utilities, and cross-browser compatibility helpers. The repository also includes build scripts for dependency checking, module mapping, and test environment setup. Designed primarily for Facebook's internal projects (like React and Relay), it explicitly warns that external consumers may experience instability due to non-semver adherence and API changes. The architecture consists of multiple loosely coupled packages under a monorepo structure. Key entry points include the Babel preset (`babel-preset-fbjs/index.js`), ESLint config (`eslint-config-fbjs/index.js`), core utility index (`fbjs/index.js` which directs users to sub-packages), and build scripts (`fbjs-scripts/index.js`). Data flows involve source code transformation via Babel, linting via ESLint, runtime utility consumption via the fbjs package, and build automation via gulp-based scripts. External dependencies include Babel, ESLint, Jest, Gulp, and Flow, with versions locked in package.json files. Notable reusable components include the Deferred.js promise-like utility, PromiseMap for request deduplication, Heap and CircularBuffer data structures, areEqual for deep equality with circular reference handling, normalizeWheel for cross-browser wheel event handling, and UserAgent/VersionRange for browser detection and version checking. These components are self-contained, demonstrate non-obvious engineering (e.g., circular reference safety, cross-browser normalization), and could be extracted with minimal modification. The codebase shows strong craftsmanship in utility design but is coupled to Facebook-specific tooling and internal conventions, limiting external reuse without adaptation.

This repository is a production-grade Rust implementation of the Starlark language, the deterministic Python-like configuration language used by build systems such as Bazel and Buck2. The system is structured as a multi-crate workspace: `starlark` provides the core runtime (parser, bytecode compiler, evaluator, garbage-collected heap, type system, and standard library), `starlark_syntax` handles parsing and AST, `starlark_map` offers high-performance ordered hash maps and sets, `starlark_derive` supplies procedural macros for defining Starlark-compatible Rust types, and `starlark_bin` bundles a CLI with REPL, linter, and Debug Adapter Protocol (DAP) server. Additional crates include `starlark_lsp` for Language Server Protocol support and a WASM example for embedding in JavaScript. The architecture is a classic interpreter pipeline: source text is parsed into an AST (`AstModule`), compiled to bytecode (with optimizations like constant folding, speculative execution, and inlining), and executed by a stack-based bytecode VM. Values are managed on a two-tier heap (unfrozen mutable and frozen immutable) with a custom bump allocator and explicit freeze operations. The type system supports both runtime type checking and static analysis, including union types, callable signatures, and generic type matchers. External dependencies include the `tower-lsp` and `lsp-types` crates for the LSP server, and several internal Facebook crates (e.g., `buck2_core`, `buck2_data`) for pagable serialization and profiling. Key entry points are `starlark::eval::eval_module` for programmatic evaluation, `starlark_bin/bin/main.rs` for the CLI, and the `#[starlark_module]` and `#[starlark_value]` proc macros for extending the language with custom types and functions. The system is designed for embedding in build tools, with a focus on performance, determinism, and debuggability.

The Facebook FBOSS (Open Switching System) is a network operating system for data center switches. It provides a modular architecture with a central agent daemon that controls the switch hardware (via HALs like SAI and Broadcom), manages routing protocols (BGP, etc.), and offers telemetry via FSDB. The system includes a CLI for configuration, various services (QSFP, LED, fan, sensor), and extensive testing. Key entry points are the agent main (fboss/agent/Main.cpp), CLI main (fboss/cli/fboss2/Main.cpp), and service daemons. Data flows involve configuration pushing to hardware, telemetry publishing via FSDB, and packet processing by the ASIC.