This repository implements the Go programming language: a complete compiler toolchain, runtime, and standard library. The compiler (`cmd/compile`) translates Go source into machine code through an SSA intermediate representation with architecture-specific backends. The `go` command (`cmd/go`) provides module management, build orchestration, testing, and toolchain version selection. The runtime (`src/runtime`) handles goroutines, GC, memory management, and platform abstractions. The standard library (e.g., `net`, `crypto`, `os`, `encoding`, `testing`) offers production-ready packages. The architecture is modular: clear separation between toolchain commands and library packages, heavy use of internal packages for shared low-level functionality (e.g., `internal/cpu`, `internal/poll`, `internal/bytealg`), and extensive platform-specific code via build tags. The codebase is exceptionally well-engineered, with comprehensive test coverage, fuzz testing, and a rigorous change control process. It is the reference implementation of the Go language and defines the ecosystem's standards.
MMTk (Memory Management Toolkit) is a high-performance, portable garbage collection framework written in Rust. It provides a library of reusable GC algorithms (plans) including generational, concurrent, mark-sweep, immix, reference-counting (LXR), and mark-compact variants. The system exposes a trait-based VM binding interface (VMBinding) that language runtimes implement to integrate MMTk as their garbage collector. The architecture is modular: a parallel work-stealing scheduler dispatches GC work packets, policy spaces encapsulate memory allocation strategies (bump, free-list, immix, large object, etc.), and a flexible metadata system supports both header-resident and side metadata. The crate is not a standalone application; it is consumed as an rlib by VM bindings such as OpenJDK, JikesRVM, V8, Julia, and Ruby. Extensive use of procedural macros (HasSpaces, PlanTraceObject) reduces boilerplate for adding new GC plans. The codebase includes performance tracing tools (eBPF, Perfetto) and a comprehensive test suite with mock VM support.
Nova is a custom ECMAScript (JavaScript) engine implemented in Rust, designed as a modular, embeddable runtime. It features a full bytecode compiler and virtual machine, a custom mark-compact garbage collector with typed arena allocation, and a shape-based (hidden class) object model for property access optimization. The engine closely follows the ECMAScript specification, implementing built-in objects (Promise, Array, Map, Set, Proxy, Temporal, etc.), module loading, and concurrent agents. Its architecture emphasizes data-oriented design and safe GC interaction through Rust-specific patterns like `GcScope`/`NoGcScope` and the `Bindable` trait. The project includes a standalone CLI (`nova_cli`) for running scripts and a test262 harness, currently passing approximately 80% of the official test suite. While actively developed, the engine has known limitations: many features are incomplete or behind feature flags (e.g., RegExp lacks full compliance, Temporal has placeholders, and several built-ins have `todo!()` stubs). The codebase exhibits high craftsmanship in its GC safety system, bytecode compiler, and object shape mechanics, but relies heavily on unsafe Rust and manual lifetime management. Nova is primarily a research-grade implementation aimed at embedding and exploration, not yet production-ready for general use.
Gravity is an embeddable, dynamically typed scripting language written in portable C99 with no external dependencies beyond the C standard library. The repository implements a full language toolchain: a multi-pass compiler (lexer, Pratt parser, AST, IR, optimizer, bytecode codegen) and a register-based virtual machine with mark-and-sweep garbage collection. It provides a CLI (`gravity` executable) for running scripts and a well-defined C embedding API. The architecture is modular, with clear separation between compiler (`src/compiler`), runtime (`src/runtime`), shared utilities (`src/shared`), and optional modules (Math, File, JSON, ENV). The codebase is extensively tested with unit tests (embedded `#unittest` blocks) and a large fuzzing corpus for crash resistance. Despite some monolithic files (`gravity_core.c` >4000 lines) and heavy macro usage, the implementation demonstrates strong software engineering craftsmanship, especially in the hash table, dynamic array macros, and Pratt parser. The project appears to be under active maintenance (last commit 2026-08-05, 34 open issues, 4.5k stars) but shows some technical drift such as outdated CI configurations, platform-specific ifdefs, and a fuzz corpus from 2017.
Bob is a Scheme language implementation consisting of a Python interpreter, compiler, and virtual machine (VM), plus an optional C++ VM implementation (BareVM). The system compiles Scheme source code to custom bytecode, which can be executed by either the Python VM or the C++ BareVM. It includes features like bytecode serialization/deserialization and WebAssembly compilation. The architecture is modular with clear separation of concerns: parser, compiler, bytecode handling, VM execution, built-in functions, expression representation, and environment management. Key entry points are in bob/cmd.py (command-line interface) and example scripts demonstrating interpretation, compilation, and execution workflows.