Compiler Implementation Relationships

These relationships document what programming language each compiler is written in. For example, GCC (the GNU Compiler Collection) is written in C.

All 78 Relationships

FromToConfidenceNotes
Haskell GHC 99% GHC is written in Haskell (self-hosting since 1989 rewrite by Hall, Partain, and Peyton Jones)
Haskell Haskell 98% GHC is self-hosting, written in Haskell
C Go 98% Original Go compiler in C, rewritten in Go in 1.5 (2015)
C++ LLVM 98% LLVM infrastructure written in C++
C++ Clang 98% Clang frontend written in C++
C++ mrustc 98% mrustc alternative Rust compiler in C++
OCaml OCaml 98% OCaml compiler is self-hosting
Rust Rust 98% rustc is self-hosting since ~2011
Go Go 98% Go compiler rewritten in Go in version 1.5
TypeScript TypeScript 98% tsc is self-hosting, written in TypeScript
C# Roslyn 98% Roslyn is self-hosting C# compiler platform
Haskell Elm 95% Elm compiler written in Haskell
Haskell PureScript 95% PureScript compiler written in Haskell
C GCC 95% GCC originally written in C, switched to C++ in 2012
C++ C++ 95% GCC and Clang (C++ compilers) written in C++
C++ GCC 95% GCC switched from C to C++ in 2012
C++ Swift 95% Swift compiler primarily in C++
C++ Zig 95% Zig originally written in C++ before self-hosting
OCaml Rust 95% Original Rust compiler (rustboot) written in OCaml
Java Java 95% javac compiler is self-hosting
Java Clojure 95% Clojure compiler written in Java by design
Erlang Erlang 95% Erlang compiler is self-hosting
Kotlin Kotlin 95% Kotlin compiler became self-hosting; K2 frontend in 2024
C# C# 95% C# Roslyn compiler written in C# (self-hosting)
Crystal Crystal 95% Crystal compiler is self-hosting
Nim Nim 95% Nim compiler self-hosting from first release year
Zig Zig 95% Zig became self-hosting in 2022, dropped C++ compiler
Scala Scala 95% Scala 3 (Dotty) compiler bootstrapped itself
LLVM Swift 95% Swift uses LLVM as compiler backend
LLVM Rust 95% rustc uses LLVM as backend
Common Lisp Common Lisp 95% SBCL is self-hosting Common Lisp implementation
Assembly Lisp 95% Original Lisp interpreter written in IBM 704 assembly by Steve Russell
C++ Objective-C 95% Clang (written in C++) is the primary Objective-C compiler
Haskell Agda 95% Agda proof assistant and compiler written in Haskell
Python mypy 95% mypy type checker written in Python
TypeScript Angular 95% Angular framework and AOT compiler written in TypeScript
Rust Gleam 95% Gleam compiler written in Rust
F# F# 92% F# compiler became self-hosting
Elixir Elixir 92% Elixir compiler is self-hosting
LLVM Crystal 92% Crystal compiler uses LLVM backend
LLVM Zig 92% Early Zig used LLVM, now has own backend option
LLVM Mojo 92% Mojo uses MLIR/LLVM backend
Fortran Prolog 91% First Prolog interpreter (1972) written in Fortran by Gerard Battani and Henri Meloni at Aix-Marseille
Standard ML Standard ML 90% SML/NJ is self-hosting
C++ Carbon 90% Carbon toolchain written in C++
C++ Mojo 90% Mojo toolchain written in C++
Pascal Pascal 90% Pascal P-compiler bootstrapped itself
Java Kotlin 90% Early Kotlin compiler written in Java before self-hosting
Java Groovy 90% Groovy compiler written in Java (intentional)
C# Visual Basic .NET 90% Roslyn handles both C# and VB.NET
Swift Swift 90% Swift compiler increasingly written in Swift
D D 90% DMD reference compiler bootstrapped to D
Racket Racket 90% Racket compiler is self-hosting
Ada Ada 90% GNAT (GCC Ada) is self-hosting
CoffeeScript CoffeeScript 90% CoffeeScript compiler is self-hosting
Ruby Crystal 90% Crystal compiler bootstrapped from Ruby initially
Assembly FLOW-MATIC 90% FLOW-MATIC compiler written in assembly for UNIVAC I
Assembly ALGOL 90% Early ALGOL 60 compilers written in assembly
Assembly COBOL 90% Early COBOL compilers written in assembly; GnuCOBOL later written in C
ALGOL Simula 90% Simula 67 compiler implemented in ALGOL
C Icon 90% Icon compiler and runtime written in C
Pascal Modula-2 90% Early Modula-2 compilers written in Pascal
C Miranda 90% Miranda compiler written in C
C Modula-3 90% Modula-3 compiler (m3cg) written in C
Oberon Oberon-2 90% Oberon-2 compiler derived from Oberon compiler
C Limbo 90% Limbo compiler written in C as part of Plan 9
C Fortran 95 90% GNU Fortran (gfortran) compiler written in C as part of GCC
C Cyclone 90% Cyclone compiler written in C at Cornell/AT&T
C Rust 85% Early Rust had C components before OCaml bootstrap compiler
C Swift 85% Early Swift compiler had significant C components
Julia Julia 85% Julia increasingly self-hosting, parser moving from FemtoLisp
Fortran Fortran 85% Modern Fortran compilers (gfortran) are self-hosting
Assembly COMTRAN 85% COMTRAN compiler written in assembly for IBM 702
Assembly PL/I 85% Early PL/I compilers for IBM System/360 written in assembly
Assembly ALGOL 68 85% Early ALGOL 68 compilers written in assembly
Assembly CLU 85% CLU compiler at MIT written in assembly and PDP-10 machine code
C Newsqueak 85% Newsqueak compiler written in C at Bell Labs
C Alef 85% Alef compiler written in C at Bell Labs
Explore in Graph →