Scala.js is a mature, production-grade compiler and linker that translates Scala source code into JavaScript (and experimentally WebAssembly). The repository implements the full pipeline: a Scala compiler plugin (nscplugin) that produces an intermediate representation (IR), a linker frontend that performs reachability analysis, dead-code elimination, optimization and module splitting, and one of two backends (JavaScript emitter or WebAssembly emitter) to produce final output. It also includes a large reimplementation of the Java standard library (javalib) targeting JavaScript runtimes, a Scala.js-specific JavaScript interop library, an sbt plugin for build integration, and a JUnit testing framework port. The architecture is multi-module and cross-version (Scala 2.12/2.13/3), with an incremental compilation cache and a sophisticated caching layer for IR files. The codebase exhibits high craftsmanship: reusable typeclass patterns for NIO buffers, a generic versioning/fingerprinting system for cache invalidation, a monadic tracking mechanism for global variable references in the JS emitter, and an inner optimizer that replaces integer divisions with multiply-shift sequences. However, it also carries some technical drift from deprecated APIs (Closure Compiler, old linker interfaces) and dual implementations for old vs new Scala collections.
This repository is the compiler toolchain for the Carbon Language, an experimental successor to C++ focused on performance, C++ interoperability, and memory safety. The codebase implements a full compilation pipeline from lexing and parsing through semantic analysis (SemIR) to LLVM IR code generation, along with a language server (LSP), a formatting tool, and C++ interop via Clang integration. The architecture follows a phased compiler design with distinct modules for lex, parse, check, sem_ir, lower, and driver, all orchestrated through a Bazel build system. Key entry points include the main driver binary (`toolchain/driver/`) with subcommands like `compile`, `link`, `build`, `format`, and `language-server`, and the semantic checker (`toolchain/check/`) which handles type checking, generics, and impl resolution. The toolchain also features a robust diagnostics system, a custom high-performance hashtable, and an extensive file-based testing framework with automatic CHECK-line updates. The codebase is actively developed with frequent commits, extensive test coverage, and fuzz testing, though it remains experimental and subject to breaking changes.
This repository is a Go reimplementation of the TypeScript compiler, including a full type checker, emitter, parser, and language server (LSP). It provides a CLI tool `tsgo` for compilation, watch mode, and build mode, and a native-preview npm package that wraps the Go binary for Node.js integration. The architecture is a monolith with well-organized internal packages (e.g., `internal/compiler`, `internal/checker`, `internal/ast`, `internal/lsp`). The codebase demonstrates high craftsmanship with clean abstractions, generic utilities, and extensive test coverage using a custom fourslash testing framework. It is actively maintained but explicitly slated for permanent archiving in September 2026, as development will continue in the main TypeScript repository. The repo is a staging ground for the TypeScript 7.0 native port and is not yet feature-complete (language service is in progress).
This is the Angular framework monorepo, the source code for the Angular web application platform. It contains the core framework packages (@angular/core, @angular/common, @angular/router, @angular/forms, @angular/animations, etc.), the compiler and compiler-cli (Ivy), the Angular CLI schematics, the Angular DevTools browser extension, the angular.dev documentation site (adev), the language service for IDEs, zone.js, and numerous integration tests and benchmarks. The architecture is modular, with packages built using Bazel and dependencies managed via pnpm workspaces. Key entry points include the core runtime (packages/core), the template compiler (packages/compiler-cli), and the HTTP client (packages/common/http). Data flows center on the compilation pipeline: TypeScript source is compiled by the Angular compiler into JavaScript with Ivy instructions, which are then executed in the browser with runtime support for change detection, dependency injection, signals, and hydration. External dependencies include TypeScript, RxJS, zone.js, and various build tools. The repository also includes a large set of compliance tests that verify compiler output against golden files, ensuring correctness across many template constructs.
marked is a high-performance Markdown parser and compiler written in TypeScript, designed for speed and extensibility. It converts Markdown text into HTML, supporting the CommonMark specification and GitHub Flavored Markdown (GFM) extensions such as tables, task lists, strikethrough, and autolinks. The library is used both as a Node.js package (ESM and UMD builds) and as a command-line tool (bin/marked). Its architecture is modular, consisting of a Lexer (tokenization), Parser (AST construction), Renderer (HTML output), and an extension system via Hooks and custom tokenizers. The core entry point is the `marked()` function, which accepts a Markdown string and options, and returns HTML. The library also exposes a `Marked` class for more control, including async parsing, token walking, and plugin integration. marked does not sanitize output HTML, leaving XSS prevention to downstream consumers. The project includes an extensive test suite with over 600 CommonMark spec examples, GFM spec tests, and custom regression/performance tests (including ReDoS mitigation). The CLI supports stdin, file input, and config files, making it suitable for scripting and build pipelines.
This repository is the PureScript compiler, a strongly typed functional programming language that compiles to JavaScript. The compiler is written in Haskell and provides a command-line tool (`purs`) with subcommands for compilation, documentation generation (HTML/Markdown), module graph analysis, type class hierarchy visualization, an IDE server (psc-ide), package publishing, and an interactive REPL (PSCi). The architecture follows a traditional compiler pipeline: source text is lexed and parsed into a Concrete Syntax Tree (CST), converted to an Abstract Syntax Tree (AST), desugared into CoreFn (a typed intermediate representation), optimized into CoreImp, and finally emitted as JavaScript (with optional source maps). The type checker supports advanced features including kind polymorphism, functional dependencies, type-level arithmetic, Coercible constraints, and generic deriving. The IDE server provides completions, type queries, import management, and rebuild capabilities over a JSON-over-TCP protocol. The project is mature, actively maintained, and has a large test suite covering compiler passes, IDE functionality, documentation generation, and regression tests. It is not a hybrid project; it is purely a compiler application with no data research components.
Civet is a full-featured compiler and language server for a CoffeeScript-like language that transpiles to TypeScript/JavaScript. It provides a CLI, bundler plugins (Vite, Webpack, esbuild, Rollup, etc.), Babel plugin, ESLint plugin, ESM loader, and browser script runner. The core compiler implements advanced features like pattern matching, pipe operators, JSX enhancements, and compile-time evaluation. The language server (LSP) delivers IDE features including diagnostics, completions, go-to-definition, hover, and rename across VS Code, Sublime Text, Zed, and Monaco. The repository is structured as a monorepo with the compiler in `source/`, a standalone LSP server in `lsp/server/`, editor extensions, tree-sitter grammars, and a documentation site at civet.dev. Notable architecture includes a PEG grammar parser (Hera), source map composition utilities, an in-memory TypeScript service host, and a worker pool for parallel compilation. The test suite enforces 100% coverage gates, ensuring high reliability. Civet demonstrates strong engineering practices: self-hosting compiler, comprehensive golden tests, CI/CD pipelines, and a modular plugin system for bundlers. While complexity arises from supporting many editor integrations and bundler adapters, the core compiler and LSP are cleanly separated. The project is actively maintained with frequent releases and community contributions.
This repository is the primary implementation of the Sway programming language and its toolchain, targeting the Fuel blockchain. It contains a full compiler pipeline (lexer, parser, AST, semantic analysis, IR with optimization passes, and code generation for the FuelVM), a package manager CLI (`forc`), a language server (`sway-lsp`), a code formatter (`swayfmt`), a debugger (`forc-debug`), a documentation generator (`forc-doc`), and a migration tool (`forc-migrate`). The standard library (`sway-lib-std`) provides essential blockchain primitives (assets, storage, crypto, etc.). The architecture is modular, with separate crates for the AST (`sway-ast`), IR (`sway-ir`), parsing (`sway-parse`), core compiler logic (`sway-core`), and error handling (`sway-error`). In production, developers use `forc` to build, test, and deploy Sway smart contracts, scripts, and predicates to the Fuel network. The LSP provides IDE features like completions, go-to-definition, and inlay hints. The formatter ensures consistent code style. The debugger enables step-through debugging of on-chain logic. The compiler supports multiple backends (FuelVM primary, EVM experimental) and includes advanced optimizations such as constant folding, dead code elimination, common subexpression elimination, and register allocation. Key entry points include `forc/src/main.rs` (CLI dispatcher), `sway-core/src/lib.rs` (compiler core), `sway-lsp/src/server.rs` (LSP server), and `swayfmt/src/lib.rs` (formatter). External dependencies include the Fuel protocol libraries (`fuel-core`, `fuel-vm`, `fuels-rs`), IPFS for package resolution, and standard Rust ecosystem crates. The repository is production-grade with extensive end-to-end tests, benchmarking infrastructure, and CI workflows.
Parcel is a zero-configuration web application bundler designed for speed and simplicity. In production, it parses entry points (HTML, JS, CSS, etc.), resolves dependencies via a plugin system, transforms assets using Rust-based processors (SWC for JS, Lightning CSS for CSS, custom HTML/SVG), optimizes and minifies output, and writes bundles with content hashing. It supports code splitting, tree shaking, CSS modules, TypeScript, and multiple output formats (ESM, CommonJS, global). The architecture is a monorepo with a core orchestrator (`@parcel/core`) that coordinates a pipeline of plugins (transformers, resolvers, packagers, optimizers, compressors, reporters). Performance-critical work is offloaded to Rust crates (e.g., JS transformer, resolver, image optimization) exposed via NAPI bindings. Key entry points include the CLI (`parcel serve`/`watch`/`build`), the `Parcel` API, and the dev server with HMR. The data flow is request-driven: entry resolution → asset graph construction → transformation → bundling → packaging → writing. Parcel relies on Node.js, SWC, Lightning CSS, and various language-specific libraries (PostCSS, Babel, etc.). It is a production-grade tool used by thousands of projects and is actively maintained with frequent releases.
esbuild is a JavaScript/TypeScript/CSS bundler and minifier written in Go. It provides both a CLI and programmatic API for bundling web assets with features like tree shaking, minification, source maps, code splitting, and a development server. The architecture follows a layered design: CLI/API → parsing → dependency resolution → bundling → transformation → code generation. The tool is known for its exceptional performance, achieved through aggressive optimizations, parallel processing, and avoidance of unnecessary caching. It supports modern JavaScript/TypeScript features while being able to target older browsers through syntax lowering.
vue-macros is a monorepo of compile-time macros and syntax sugar for Vue 3, distributed as a set of npm packages that integrate with Vite, Rollup, esbuild, Webpack, Rspack, Rolldown, Nuxt, and Astro. In production it acts as a build-time transformer: it parses Vue SFCs and TS/TSX files, identifies macro calls (defineProps, defineModels, defineOptions, shortVmodel, JSX directives, reactivity transform, etc.), and rewrites them into standard Vue compiler-compatible code using Babel AST manipulation and MagicString. The main entry point is packages/macros, which combines roughly 25 feature plugins via unplugin; each feature package exposes per-bundler entry shims (vite.ts, rollup.ts, etc.) generated by monoman. It also ships a Volar plugin for IDE support, a devtools plugin, and a config loader that reads vue-macros.config.* files.
This repository is the official compiler, standard library, and toolchain for the V programming language. It is a self-hosting, multi-backend compiler (primarily targeting C, with experimental JS and WASM backends) that produces highly optimized native executables. The standard library is exceptionally comprehensive, offering built-in support for cryptography (AES, SHA3, Ed25519, TLS via mbedtls), compression (gzip, zstd, lz4, snappy), database connectivity (SQLite, MySQL, PostgreSQL, MSSQL, Redis), a full web framework (veb), graphics (gg, sokol), and CLI development tools. The architecture is a monolithic compiler with a modular standard library. The compiler pipeline involves scanning, parsing, type-checking, and code generation. The build system uses a multi-stage bootstrap process. The codebase demonstrates extremely high craftsmanship, with clean abstractions, extensive test coverage, and reusable components. It is actively maintained with a large community. Key reusable components include the pure-V implementations of cryptographic primitives (Ed25519, SHA-3), compression algorithms (LZ77, Snappy), data structures (lock-free ring buffer, FSM), and the CLI framework. These modules are isolated, well-tested, and could be extracted for use in other projects with minimal modification.
This repository is the official compiler and toolchain for the Leo programming language, a statically-typed language for writing private zero-knowledge applications on the Aleo blockchain. The codebase implements a full compilation pipeline from Leo source to Aleo bytecode, including parsing (with a lossless rowan-based parser), type checking, static analysis, multiple optimization passes (constant propagation, loop unrolling, dead code elimination, common subexpression elimination, SSA formation, function inlining, flattening, destructuring, storage lowering, option lowering, peephole optimization), and code generation targeting snarkVM. Beyond the compiler, it provides a complete development environment: a CLI with commands for building, testing, deploying, executing, and querying the Aleo network; a Language Server Protocol (LSP) implementation with diagnostics, goto-definition, references, rename, and semantic tokens; a standalone formatter; a package manager supporting local, git, network, and workspace dependencies with lock files; and an ABI generation and compatibility checker. The architecture is a multi-crate Rust workspace with clear separation of concerns, extensive test coverage (unit, integration, and expectation-based compiler tests), and CI/CD pipelines. The codebase demonstrates high craftsmanship with reusable patterns such as a generic directed graph with cycle detection, a canonicalization trait for structural equality, an intern-based type system, and a pass-based compiler architecture.
Scala Native is an optimizing ahead-of-time compiler and lightweight managed runtime for Scala, enabling compilation of Scala code to native executables. The repository implements the full toolchain: a Scala compiler plugin (nscplugin) that emits an intermediate representation (NIR), a linker and optimizer (tools) that perform reachability analysis, inlining, and code generation targeting LLVM, and a native runtime (nativelib) with multiple garbage collectors (immix, commix, Boehm), memory management (zones, unsafe pointers), and platform abstractions. It also provides extensive reimplementations of the Java standard library (javalib), POSIX and Windows bindings (posixlib, windowslib), and a JUnit test framework adapted for native execution. The project is highly modular, with over 3500 files spanning compiler internals, runtime C code, and library ports. It is actively maintained with frequent commits and a large test suite covering JDK compatibility, concurrency, and platform-specific behavior. Notable technical depth includes a custom NIR serialization format, graph-coloring for trait dispatch, polymorphic inline caching, and concurrent garbage collection algorithms.
This repository is the official compiler for the Cairo programming language, a Turing-complete language designed for provable computation (zero-knowledge proofs). It compiles Cairo source through a multi-stage pipeline: parsing (via LALRPOP), semantic analysis with type inference and trait resolution, lowering to a control-flow graph with extensive optimizations (CSE, constant folding, inlining, match optimization, gas redeposit), generation of the Sierra intermediate representation (a safe, bounded subset for ZK provability), and final compilation to CASM (Cairo Assembly) for execution on the Cairo VM. The compiler uses the Salsa incremental computation framework for query-based caching and is split into 40+ crates organized by compiler phase (parser, semantic, lowering, sierra-generator, sierra-to-casm, etc.). It also includes a full toolchain for Starknet smart contract development, with plugins for contracts, storage, events, and ABI generation. CLI tools (cairo-compile, cairo-run, sierra-compile, starknet-compile, cairo-test, cairo-format) provide end-to-end functionality. The standard library ('corelib'), written in Cairo, provides fundamental types, collections, hash functions, and Starknet-specific primitives. The codebase demonstrates high craftsmanship with clean abstractions, a generic dataflow analysis framework, deterministic hash map utilities, and a reusable graph algorithm library. It is actively maintained with extensive CI, benchmarks, and a golden-file test infrastructure.
hcc is a compiler for the HolyC language, a derivative of TempleOS HolyC. It supports both ahead-of-time (AOT) compilation to x86_64 and AArch64 assembly and just-in-time (JIT) compilation for in-memory execution. The system includes a full front-end (lexer, parser, AST, SSA-based IR), optimization passes, register allocation, and backends for x86_64 and AArch64. Additionally, it provides a REPL, a Language Server Protocol (LSP) server, an inline assembler (TempleOS-style), a disassembler, and a control-flow graph visualizer. The standard library is written in HolyC and offers data structures (lists, vectors, hash maps, red-black trees), JSON/CSV parsers, SQLite bindings, networking, threading, coroutines, and system call wrappers. The project is a self-contained, well-structured compiler toolchain with extensive tests and active development.
Master CSS is a comprehensive CSS framework and toolchain that enables writing CSS directly in class attributes using a concise utility syntax. The system supports multiple rendering modes: a runtime engine that dynamically generates and injects CSS in the browser, a static build-time compilation mode for zero-runtime production output, and progressive hybrid modes that pre-generate critical CSS and hydrate on the client. It includes a fully modular architecture with over 30 packages covering a core engine, compiler, scanner for class extraction, validator, language server, ESLint plugin, CLI, MCP server, and first-class integration plugins for Vite, Next.js, Nuxt, Astro, Svelte, Webpack, and more. The codebase is production-grade with extensive unit and e2e tests, a dedicated benchmarking suite measuring CSS output sizes, build timings, and browser lifecycle performance, and a documentation site with interactive playground. While primarily a JavaScript/TypeScript application library, it also contains benchmark infrastructure that produces analytical metrics. The architecture is strongly layered with well-defined schema contracts (manifest JSON) enabling loose coupling between packages.
Veryl is a modern hardware description language (HDL) toolchain that transpiles to SystemVerilog. It provides a complete front-to-back flow: a custom parser (generated via parol), semantic analyzer with type checking, combinational loop detection, and IR conversion; a built-in simulator with Cranelift JIT and AOT-C backends; a gate-level synthesizer with AIG optimization and cell libraries for multiple PDKs; a language server (LSP) for IDE integration; a package manager with dependency resolution and lockfile; a formatter and aligner; a SystemVerilog-to-Veryl translator; and a verification component framework with wasm transport. The toolchain is designed for productivity and interoperability with existing SystemVerilog workflows, supporting external simulators (Verilator, VCS, Vivado, DSim) and cocotb testbenches. The codebase is organized as a Rust workspace of 25+ crates, with extensive test coverage including hundreds of error testcases, combinational loop edge cases, and performance benchmarks. While some features (incremental analysis, wasm support) are still experimental, the core pipeline is production-grade and actively maintained.
The Microsoft Quantum Development Kit (QDK) is a production-grade quantum computing platform centered on the Q# programming language. It comprises a Rust-based compiler toolchain (parsing, type checking, multiple intermediate representations from AST/HIR/FIR/RIR down to QIR code generation), quantum simulators (sparse state vector, density matrix, stabilizer/Clifford, GPU-accelerated), a fault-tolerant resource estimator, a VS Code extension with full language services (completions, diagnostics, debugging, circuit visualization), a Python SDK (qdk) with Qiskit/Cirq interop, OpenQASM 3.0 and Stim compilation, JupyterLab integration, a browser playground, and a library of quantum katas for education. Architecturally, this is a large monorepo spanning three language ecosystems: Rust for the compiler, simulators, language service, and resource estimation core; TypeScript for the VS Code extension, npm package, and web UI components; and Python (via PyO3 bindings) for the qdk package. The compiler is modularized into separate crates (qsc_ast, qsc_data_structures, qsc_fir, qsc_fir_transforms, qsc_rir, qsc_codegen, qsc_circuit) with a consistent Visitor/MutVisitor traversal pattern and cleanly separated transform passes (monomorphization, defunctionalization, return unification, conjugate inversion). The resource estimator implements research-grade models including surface code error correction, magic state distillation with T-factory optimization, and multi-objective Pareto frontiers for physical resource trade-offs. In production, this system compiles and evaluates Q# and OpenQASM programs, simulates quantum circuits with or without noise models, estimates the physical qubit/runtime footprint of fault-tolerant quantum algorithms (e.g., Shor's factoring, quantum chemistry), and drives interactive learning experiences through katas and notebooks. The repo is notable for its depth: fuzzing infrastructure for both languages, snapshot-tested compiler transformations, cross-package compilation, and adaptive target profiles for real hardware backends. Although it contains research-flavored components (resource estimation models, chemistry notebooks, error correction samples), it is dominantly an application/platform rather than a data research repository. Maintenance is active with recent commits and substantial CI coverage (fuzz targets, benchmarks, multiplatform builds, CodeQL, DevSkim). Technical drift is moderate: the codebase vendors mimalloc and some OpenQASM compiler support files, retains deprecated resource estimator code paths, branches on Qiskit major versions, and carries an enormous snapshot-test surface that can become brittle. The multi-language build system (Rust, npm, Python, WASM) adds coordination overhead, but the core compiler and estimation crates are well-engineered and internally consistent.
CoBRA is a C++ library and CLI tool for simplifying mixed Boolean-arithmetic (MBA) expressions, commonly used in software obfuscation. It ingests expressions combining arithmetic (+, -, *) with bitwise (&, |, ^, ~) and shift operators and outputs a simplified equivalent form. The core engine uses a worklist orchestrator that coordinates 36+ passes, including signature-based transforms (CoB butterfly, ANF recovery), semilinear normalization with bit partitioning, decomposition (product, polynomial, template cores), ghost residual solving, and pattern matching. An optional Z3 verifier proves full-width equivalence. The tool can be used as a standalone CLI (`cobra-cli`), as an LLVM pass for automatic deobfuscation during compilation, or as a library (`cobra::Simplify()`). The codebase is well-structured with extensive test coverage (1195+ tests) and benchmark datasets from multiple research projects. While the core is tightly coupled internally, several generic utilities (Result type, profiling stubs, math helpers) are reusable independently.