Fusion Transpiler (fut) is a self-hosting, multi-target transpiler that translates code written in the Fusion language into C, C++, C#, D, Java, JavaScript, Python, Swift, TypeScript, and OpenCL C. The repository contains the complete compiler implementation written in Fusion itself, including a lexer, parser, semantic analyzer, and a family of code generators organized via a visitor pattern. It also includes a comprehensive test suite, command-line interfaces for multiple host languages (C++, C#, Java, Node.js), editor integrations (VS Code, Vim, Sublime, Visual Studio, LSP server), and packaging for Debian, Windows, and RPM. The architecture follows a classic compiler pipeline with a clear separation of concerns, and the self-hosting bootstrap ensures the compiler is exercised on its own code. This is a pure application project with no data processing or research components; it is a production-quality compiler toolchain.
vue-jsx-vapor is a high-performance Rust-based compiler and build toolchain that transforms JSX into optimized Vue 3 code, supporting both the traditional Virtual DOM and the experimental Vapor Mode (direct DOM manipulation). It provides a comprehensive set of developer tools including bundler plugins (Vite, Rollup, Webpack, esbuild, Nuxt, etc.), compile-time macros (defineComponent, defineModel, defineSlots, defineExpose, defineStyle), an ESLint plugin with custom rules, and a Volar integration for type-safe JSX. The compiler leverages the oxc parser in Rust to achieve 35-50x faster transformation compared to Babel-based alternatives. The repository is structured as a monorepo with packages for the Rust compiler, runtime helpers, macros, ESLint rules, and the main vue-jsx-vapor package that ties everything together. It includes extensive snapshot tests, benchmarks, ecosystem CI against popular UI libraries, and a documentation site with interactive tutorials.
XGo (formerly Go+) is a Go-superset programming language delivered as a complete compiler toolchain. The repository implements the full language pipeline: a custom scanner (scanner/), parser (parser/), extended AST (ast/), semantic compiler (cl/), and code generator that lowers XGo source to standard Go via the gogen code builder. The xgo CLI (cmd/xgo) exposes subcommands for build, run, test, fmt, go, install, mod, pack, serve, watch, and version, wrapping the Go toolchain after transpilation. The language extends Go with command-style calls, keyword arguments, tuples, list/map/select comprehensions, error-wrapping operators (expr!, expr?), overloaded functions and operators, enums, domain-text literals, and classfile frameworks for domain-specific applications (spx games, MCP servers, shell scripts). The architecture follows a classic compiler design: XGo source → scanner → parser → AST → cl semantic analysis/code generation → gogen → Go source → standard Go toolchain. The tool/ package orchestrates module loading, go.mod management, and delegation to go build/run/test. A language server (x/langserver) with a bundled JSON-RPC2 library (x/jsonrpc2) supports editor tooling. Two notable sub-systems ship alongside the compiler: DQL (dql/), a unified query language over HTML/XML/JSON/YAML/Go AST trees, and TPL (tpl/), a grammar-based DSL parser generator used for domain-text literals. Hundreds of golden-test pairs (in.xgo/out.go) validate compiler output across Go versions 1.18-1.27. External dependencies include github.com/goplus/gogen (code builder), github.com/goplus/mod (module handling), github.com/qiniu/x (errors/streams), and cobra for CLI construction. The codebase forks several Go standard library internals (scanner, printer, ast) to support extended syntax, creating ongoing maintenance burden as Go evolves. Some features remain incomplete (panic("TODO") in matrix literal compilation, fully commented-out ast/resolve.go), and legacy naming aliases (gop vs xgo, gop.mod vs gox.mod) coexist throughout.
Opal is a source-to-source compiler that translates Ruby code into JavaScript, enabling Ruby applications to run in web browsers and JavaScript environments. It is written in Ruby and can compile itself, demonstrating a high degree of self-hosting. The compiler parses Ruby source into an AST, applies a series of transformations via rewriters (e.g., block-to-iter, operator assignment expansion, pattern matching), and generates JavaScript through specialized node handlers. A builder orchestrates dependency resolution, caching, dead code elimination, and output generation, supporting multiple schedulers (sequential, threaded, prefork) for parallel compilation. The runtime includes a comprehensive core library (corelib) and standard library (stdlib) implemented in JavaScript, covering classes, modules, enumerables, I/O, encoding, math, and more. Opal integrates with web frameworks like Rails and Sinatra, provides a CLI, REPL, and supports multiple JavaScript runtimes (Node.js, Deno, Bun, QuickJS, GJS, browsers via CDP). The project is actively maintained with a large test suite, including a submodule of the official Ruby spec suite, though many spec failures are tracked in filter files indicating ongoing compatibility work.
Rakudo is the primary, production-ready compiler for the Raku programming language (formerly Perl 6). It implements the full Raku specification across three virtual machine backends: MoarVM (primary), JVM, and JavaScript. The compiler translates Raku source code through a pipeline of grammar parsing, AST construction (with both a legacy QAST-based frontend and a modern RakuAST frontend under development), semantic analysis, optimization, and code generation. At its core lies a meta-object protocol (6model) composed of reusable, mixin-based roles that define the semantics of classes, roles, grammars, enums, and other type system constructs. The architecture is modular: the compiler frontend (`src/Perl6/` or `src/Raku/ast/`), the runtime / setting library (`src/core.c/`, `src/core.e/`), the meta-model (`src/Perl6/Metamodel/`), and backend-specific modules (`src/vm/moar/`, `src/vm/jvm/`, `src/vm/js/`). Key entry points include the MoarVM C runner (`src/vm/moar/runner/main.c`), the main NQP entry (`src/main.nqp`), and the module loading chain (`CompUnit::Repository` hierarchy). The language supports multiple revisions (6.c, 6.d, 6.e.PREVIEW) gated by lexically scoped pragmas. Rakudo is not a data research project; it is a compiler/runtime for general-purpose programming. It exposes no data pipelines, analysis frameworks, or scientific computing abstractions beyond what the Raku language itself offers. The codebase is actively maintained with monthly releases, though the JVM backend has known issues and the transition to the RakuAST frontend is ongoing, introducing temporary dual-frontend complexity.
This is a monorepo for General Translation (GT), a comprehensive internationalization (i18n) and localization (l10n) platform. It provides runtime libraries for React, Next.js, Vue, React Native, Node.js, and Python frameworks, enabling developers to translate entire React components—not just strings—using a simple `<T>` wrapper. The platform includes a CLI for extracting translatable strings from source code, uploading them to a translation service, and downloading completed translations. A Babel/SWC compiler injects translation hashes at build time, and a Sanity CMS plugin manages document-level translations. The architecture is a multi-package monorepo with shared core types, a compiler pipeline, framework-specific adapters, and a cloud API client. The codebase demonstrates high craftsmanship with clean abstractions like condition stores, singleton caches, batch processing utilities, and a step-based workflow pattern. It is actively maintained with extensive test coverage and modern tooling (pnpm, Turborepo, TypeScript, Vitest).
This repository is the compiler and build toolchain for the Gren programming language, a functional language forked from Elm. It compiles Gren source code to JavaScript, targeting both Node.js and browser environments. The codebase is split into two parts: a Haskell backend that handles parsing, type inference, optimization, and code generation, and a Gren frontend that provides a CLI for building, running, package management, REPL, and documentation generation. The Gren frontend is self-hosting—compiled by the compiler itself. The architecture is modular, with clear separation of concerns across parsing, canonicalization, type checking, optimization, and JavaScript generation. The compiler features sophisticated error reporting with pedagogical hints, a custom type system with flexible type variables, and an efficient pattern matching compilation algorithm based on decision trees. The project also includes a builder for incremental compilation and dependency resolution, and a package manager that fetches packages from GitHub. While the codebase demonstrates high craftsmanship in many areas, it is a two-language project with self-hosting complexity and some very large modules.
GB Studio is a production-grade Electron desktop application for creating Game Boy and Game Boy Color games without writing code. It is a full visual IDE: scene and tilemap editors, sprite/metasprite editor, a music tracker with piano roll and instrument editing, a script event system (event definitions compile to GBVM bytecode), asset management for backgrounds/sprites/tilesets/fonts/sounds, and a debugger with ROM usage analysis. A separate web app (GBS Music) shares core music logic and offers a standalone browser-based tracker. The application is architecturally substantial: the Electron main process hosts multiple isolated renderer windows (splash, project, music, preferences, plugins), the renderer uses React 19 with Redux Toolkit for normalized entity state, Web Workers offload image processing and background scans, and a shared lib layer is reused across desktop and web builds.
libfsm is a C library and toolchain for constructing, manipulating, and compiling finite state machines (FSMs) from regular expressions. It supports multiple regex dialects (PCRE, glob, SQL LIKE, literal, native) and compiles them into deterministic finite automata (DFAs) that guarantee linear-time matching. The library provides a rich set of FSM operations: determinisation, minimisation, union, intersection, complement, reversal, trimming, and more. It also includes a lexer generator (lx) that produces C lexers from specification files, and a pattern matcher builder (rx) that merges many patterns into a single DFA with conflict detection. The architecture is modular: an abstract data type (ADT) layer provides reusable data structures (sets, hash tables, priority queues, edge sets, interned state sets); the libfsm core implements FSM algorithms; libre handles regex parsing and AST analysis; and multiple code generation backends emit C, Rust, Go, LLVM IR, x86 assembly, awk, shell, JSON, and a custom VM bytecode. The build system uses BSD make (bmake) and the project is extensively tested with unit tests, property-based fuzzing (theft), and a cross-implementation test runner (retest) that compiles and runs generated code via dlopen. Key entry points include the fsm CLI tool for interactive FSM operations, the re CLI for regex compilation and code generation, the lx CLI for lexer generation, and the rx CLI for building pattern matchers. The library is designed for embedding in other applications, with allocator hooks and a clean public API. It is particularly suited for high-performance pattern matching, protocol parsing, and any domain requiring deterministic automata with guaranteed worst-case performance.
Kopy is a Kotlin compiler plugin that generates an ergonomic DSL for immutable updates on data classes. It adds `copy`, `set`, `update`, and `updateEach` functions to data classes annotated with `@Kopy`, enabling deep nested property changes without manual `copy` chains. The plugin uses `kotlin.concurrent.atomics.AtomicReference` for thread-safe snapshots and integrates as a Gradle plugin. The codebase is a multi-module Gradle project with a compiler plugin module (`kopy-compiler`), a Gradle plugin module (`kopy-gradle-plugin`), a runtime annotations module (`kopy-runtime`), and a configuration enums module (`kopy-args`). It includes extensive test data for FIR and IR transformations, covering diagnostics, box tests, visibility, inheritance, serialization, and edge cases. The project is actively maintained, with a well-structured architecture and high test coverage.
Gatsby is a React-based static site generator (SSG) that also supports server-side rendering (SSR), deferred static generation (DSG), and client-side rendering. It uses a GraphQL data layer to source and transform content from various backends (CMSs, files, APIs) via a plugin system. The build pipeline compiles React components into static HTML, CSS, and JavaScript, with webpack bundling and Babel transpilation. The architecture is a monorepo containing the core framework (`packages/gatsby`), CLI (`gatsby-cli`), dozens of first-party plugins (source, transformer, utility), adapters for deployment (e.g., Netlify), and extensive testing infrastructure (e2e, integration, benchmarks). Key entry points are the CLI commands (`develop`, `build`, `serve`) and the plugin lifecycle hooks (`sourceNodes`, `createPages`, `onRenderBody`). External dependencies include React, GraphQL, webpack, Babel, Node.js, and various CMS SDKs. The codebase is well-structured with state machines (XState), a Redux store, and a modular plugin architecture, though it contains some deprecated packages and mixed JS/TS patterns.
ClojureScript is a compiler and toolchain that translates Clojure (a Lisp dialect) into JavaScript, targeting the Google Closure Compiler for advanced optimization. In production, it takes ClojureScript source files, analyzes them (macro expansion, type inference, namespace resolution), emits JavaScript, and optionally invokes the Closure Compiler for bundling, minification, and dead-code elimination. The system also provides a REPL (browser and Node.js), a self-hosted compiler (ClojureScript compiling ClojureScript), a full standard library (cljs.core, clojure.string, clojure.set, etc.), a testing framework (cljs.test), a specification system (cljs.spec.alpha), source-map support, and dependency management for npm/foreign JavaScript libraries. The architecture is a library/toolchain rather than a deployed service: it runs on the JVM via Clojure and can also self-host on JavaScript runtimes. Key entry points include the CLI (cljs.main), the build API (cljs.closure/build), the compiler API (cljs.compiler.api), and the analyzer API (cljs.analyzer.api). External dependencies include Clojure, Google Closure Compiler, Google Closure Library, tools.reader, Transit, and test.check. The codebase is large and mature, with extensive regression tests and a detailed changelog, though some samples and design documents are outdated.
AdaptiveCpp is a SYCL and C++ standard parallelism implementation targeting CPUs and GPUs from multiple vendors. It provides a complete heterogeneous computing stack including compiler infrastructure (LLVM-to-backend translators, optimization passes), runtime system (memory management, scheduling, event handling), and SYCL API headers. The project supports multiple backends (CUDA/HIP, OpenCL, Level Zero, Metal, Vulkan, OpenMP) and features compilation flows including LLVM JIT, source-level interop, and library-only modes. While primarily a production SYCL implementation, it contains research elements reflected in academic citations and experimental features like PCUDA and stdpar support. The codebase demonstrates strong modularity with clear separation between compiler, runtime, and API layers.
This repository is a developer toolchain for creating custom node graph logic in Genshin Impact's UGC mode (Miliastra Wonderland). It compiles a subset of TypeScript into a binary GIA format (protobuf) and injects it into game map files (.gil). The system includes a CLI (gsts) for build/inject/watch, a multi-stage compiler (TS → GS intermediate → IR JSON → GIA), an injector that patches save files, and a comprehensive set of custom ESLint rules enforcing the supported TypeScript subset. It supports both server-side and client-side node graphs with two modes (classic and beyond), and provides extensive type definitions, bilingual support (Chinese/English), and auto-generated tests covering thousands of node combinations. The codebase demonstrates strong engineering practices: rigorous testing, type safety, i18n, and modular architecture. However, it depends heavily on reverse-engineered game data (node IDs, pin records, protobuf schemas) that must be updated with each game patch, and some components are tightly coupled to internal definitions.
nocc is a distributed C++ compiler system designed to accelerate C++ compilation, particularly for large projects with frequent rebuilds. It consists of three main components: a lightweight C++ wrapper (`nocc`) that pipes compiler commands to a Go daemon (`nocc-daemon`), which in turn coordinates with Go-based compilation servers (`nocc-server`). The system uses remote source and object caching to avoid re-uploading unchanged files and recompiling unchanged code, features an own includes parser for faster dependency detection than invoking the C++ preprocessor, supports precompiled headers compiled remotely, and provides local fallback when remote servers are unavailable. The architecture maintains persistent gRPC connections between daemons and servers while client processes start and die per compilation job, making it well-suited for build systems like CMake or KPHP that launch many parallel compilation processes.
ExprTk is a header-only C++ library for runtime mathematical expression parsing and evaluation. It provides a complete system for defining mathematical expressions as strings, compiling them into an internal AST representation, and evaluating them with variable values. The library supports scalar, vector, and string types, arithmetic operations, trigonometric functions, logarithms, control structures (if, for, while, switch), user-defined functions, and assignment operations within expressions. It employs sophisticated parsing techniques including constant folding, strength reduction optimizations, and runtime safety checks for vector bounds and loop execution time. The architecture consists of three main components: symbol table (for variables/constants/functions), expression (holding the parsed AST), and parser (compiling expression strings).
llvm-cbe is a resurrected LLVM C backend that converts LLVM Intermediate Representation (IR) into compilable C code. It operates as both a library (implementing an LLVM target machine) and a command-line tool (llvm-cbe) that reads LLVM bitcode or IR and outputs C source files. The core is the CWriter pass, which handles type lowering, instruction translation, and generation of C-compatible code including structs, arrays, vectors, and intrinsics. It supports a wide range of LLVM features such as atomic operations, vector instructions, and various calling conventions, and includes extensive test suites (C, C++, and LLVM IR tests) to verify correctness across multiple optimization levels and compilers (GCC, Clang, MSVC). The project is actively maintained, targeting LLVM 22, and is used primarily in scenarios where C code generation is needed from LLVM IR, such as cross-compilation or embedding.
Melange is an OCaml-to-JavaScript compiler that compiles a large subset of OCaml (including the standard library and the Belt data structures library) to readable JavaScript. It is a fork of ReScript (formerly BuckleScript) with a focus on OCaml ecosystem compatibility, integration with Dune build system, and support for OCaml's module system (including first-class modules and virtual libraries). The compiler features a multi-pass lambda IR transformation pipeline, a PPX rewriter for Melange-specific attributes (e.g., [@mel.module], [@mel.send]), and extensive runtime support for JavaScript interop, including bindings for Node.js, DOM APIs, and ES module systems. The codebase is structured as a monorepo with several components: the compiler core (jscomp/core/), the PPX preprocessor (ppx/), the standard library fork (jscomp/stdlib/), the Belt library (belt/), runtime libraries (jscomp/runtime/), and a test suite with both unit tests (via the Mt framework) and blackbox tests (.t files). The build system uses Dune and opam, with an optional Nix flake for reproducible builds. The repository demonstrates strong craftsmanship in its compiler passes (alpha conversion, dead code elimination, arity analysis, constant folding) and in the design of JavaScript runtime primitives. However, there is some technical debt: several FIXME and TODO comments, conditional compilation for OCaml version compatibility, a few vendored components (Flow parser) that may drift from upstream, and some generated files that require regeneration when source definitions change.
Scallop is a differentiable probabilistic Datalog engine implemented in Rust with Python bindings (scallopy). It compiles Scallop programs (a Datalog variant with provenance annotations) through a three-stage compiler (front AST → back normalized Datalog → RAM relational algebra) to a runtime that executes with configurable provenance semirings (unit, boolean, tropical, probabilistic, differentiable, etc.). The system supports neuro-symbolic AI by integrating with PyTorch for gradient-based learning, and provides plugins for LLMs (GPT, Gemini) and vision models (CLIP, OWL-ViT, SAM). The architecture is a monolithic Rust library (core) with multiple sub-crates for CLI tools (scli, sclc, sclrepl), Python bindings via PyO3, and a plugin system for extending with foreign functions, predicates, and attributes. Key data flows: user-provided Scallop source or facts are parsed, analyzed (type inference, boundness), transformed, and compiled into a relational algebra plan that is executed with provenance-aware dataflow operators, producing output collections. The codebase is well-structured with clear separation between compiler, runtime, and provenance layers, and includes several reusable components such as copy-on-write containers, galloping search, dual numbers for AD, batch streaming abstractions, and a self-contained SDD library for weighted model counting. While the code demonstrates strong engineering and research-grade sophistication, there is some code duplication across provenance variants and experimental/legacy directories that lower the overall quality score. The repository is actively maintained with recent commits, CI workflows, and a growing plugin ecosystem.
KernelScript is a domain-specific language and compiler (OCaml) for developing eBPF-centric programs. The compiler translates a single `.ks` source file into multiple C outputs: idiomatic eBPF C code (for kernel execution via XDP, TC, kprobe, tracepoint, perf_event, struct_ops), userspace loader C code (managing maps, ring buffers, tail calls, and program lifetime), and optionally kernel module C code (for `@kfunc` functions). The compiler pipeline includes lexing, parsing, symbol table construction, type checking (including context-specific rules for eBPF program types), IR generation with control-flow and data-flow analysis, loop analysis (bound detection, bpf_loop optimization), tail-call detection and automatic progarry management, map assignment optimization, safety checking (null pointer, bounds, overflow), and multi-program optimization (map type changes, batching). It also supports BTF introspection for kernel type and kfunc extraction, a Python bridge, and a compile-time evaluator. The architecture is modular with pluggable context code generators per program type. The project includes an extensive test suite covering the full pipeline from parse to C output and specific features like perf_event attach, ring buffer dispatch, struct_ops, and multi-program scenario.