Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

awesome-compilers

An opinionated list of awesome compiler frameworks, libraries, software and resources.
https://github.com/hummanta/awesome-compilers

Last synced: about 17 hours ago
JSON representation

  • Python

    • Other dialects and variants

      • Awesome Python - python?tab=License-1-ov-file#readme)
      • pypy - A very fast and compliant implementation of the Python language.
      • Jupyter Notebook (IPython) - A rich toolkit to help you make the most out of using Python interactively.
      • micropython - A lean and efficient Python programming language implementation.
      • pudb - A full-screen, console-based Python debugger.
      • cpython - Default, most widely used implementation of the Python programming language written in C.
      • py-spy - A sampling profiler for Python programs. Written in Rust.
      • numba - Python JIT compiler to LLVM aimed at scientific Python.
      • flask-debugtoolbar - A port of the django-debug-toolbar to flask.
      • pyelftools - Parsing and analyzing ELF files and DWARF debugging information.
      • clpython - Implementation of the Python programming language written in Common Lisp.
      • RustPython - A Python Interpreter written in Rust.
      • ironpython - Implementation of the Python programming language written in C#.
      • cython - Optimizing Static Compiler for Python.
      • vprof - Visual Python profiler.
      • icecream - Inspect variables, expressions, and program execution with a single, simple function call.
      • python-hunter - A flexible code tracing toolkit.
      • peachpy - x86-64 assembler embedded in Python.
      • manhole - Debugging UNIX socket connections and present the stacktraces for all threads and an interactive prompt.
      • ipdb - IPython-enabled [pdb](https://docs.python.org/3/library/pdb.html).
      • bpython - A fancy interface to the Python interpreter.
      • django-debug-toolbar - Display various debug information for Django.
      • ptpython - Advanced Python REPL built on top of the [python-prompt-toolkit](https://github.com/jonathanslenders/python-prompt-toolkit).
      • pyston - A Python implementation using JIT techniques.

  • Rust

    • Other dialects and variants

      • Awesome Rust - 1.0 license](https://github.com/rust-unofficial/awesome-rust?tab=readme-ov-file#CC0-1.0-1-ov-file)
      • MoonBit - An end-to-end programming language toolchain for cloud and edge computing using WebAssembly.
      • gdbgui - Browser based frontend for gdb to debug C, C++, Rust, and go.
      • m2cgen - A CLI tool to transpile trained classic machine learning models into a native Rust code with zero dependencies.
      • Nom - parser combinator library.
      • Chomp - A fast monadic-style parser combinator.
      • Combine - parser combinator library.
      • Tree-Sitter - A parser generator tool and an incremental parsing library geared towards programming tools.
      • CodeLLDB - A native debugger extension for VSCode based on LLDB.
      • c2rust - C to Rust translator and cross checker built atop Clang/LLVM.
      • Corrode - A C to Rust translator written in Haskell.
      • rust-peg - Parsing Expression Grammar (PEG) parser generator.
      • LALRPOP - LR(1) parser generator.
      • Pest - The Elegant Parser.
      • Oak - A typed PEG parser generator (compiler plugin).
      • rust-analyzer - A Rust compiler front-end for IDEs.
      • Noir - A domain specific language for zero knowledge proofs.
      • verus - Verified Rust for low-level systems code
      • lady-deirdre - A framework for new programming languages and LSP servers.
      • Tracexec - Tracer for execve{,at} and pre-exec behavior, launcher for debuggers.
      • rust-playground - Allows you to experiment with Rust before you install it locally.
      • rustc_codegen_gcc - libgccjit AOT codegen for rustc, loaded by the existing rustc frontend, but benefits from GCC.
      • rustc_codegen_cranelift - create an alternative codegen backend for the rust compiler based on [Cranelift](https://github.com/bytecodealliance/wasmtime/blob/main/cranelift).
      • rust-lang/llvm-project - Rust-specific fork of LLVM.
      • rustc_codegen_c - This a C codegen backend for rustc, which lowers Rust MIR to C code and compiles it with a C compiler.
      • MIRAI - an abstract interpreter operating on Rust's mid-level intermediate representation (MIR)
      • rustc - Rust compiler.

  • C/C++

    • Awesome C++ - cpp?tab=readme-ov-file#compiler), for more details visit their project homepage. [MIT license](https://github.com/fffaraz/awesome-cpp#MIT-1-ov-file)
    • GCC - GNU Compiler Collection. Supports C++11/14/1z C11 and OpenMP.
    • Open WatCom - Watcom C, C++, and Fortran cross compilers and tools.
    • Oracle Solaris Studio - C, C++ and Fortran compiler for SPARC and x86. Supports C++11. Available on Linux and Solaris.
    • CodeChef - Online compiler supports multiple programming languages like Python, C++, C, JavaScript, Rust, Go, Kotlin, and many more.
    • Try It Online - TIO is a family of online interpreters for an evergrowing list of practical and recreational programming languages.
    • Wandbox - An online Clang/GCC compiler with Boost available.
    • paiza.io - An online C/C++ compiler with multiple files supporting feature, GitHub(gist) integration and collaborative editing.
    • Comparison of debuggers - A list of Debuggers from Wikipedia.
    • GDB - GNU Debugger.
    • AMD C++ Compiler - Developed by AMD.
    • OneCompiler - An online compiler supporting over 70 programming languages and database systems.
    • chibicc - chibicc is yet another small C compiler that implements most C11 features.
    • c - Compile and execute C "scripts" in one go!
    • 8cc - A Small C Compiler, It's intended to support all C11 language features while keeping the code as small and simple as possible.
    • lcc - The lcc retargetable ANSI C compiler.
    • PCC - A very old C compiler. Supports C99.
    • repl.it - A powerful yet simple tools and platforms for educators, learners, and developers.
    • Coliru - Online compiler/shell with support for various C++ compilers.
    • CompileOnline - Compile and Execute C++ online on Linux.
    • Microsoft Visual C++ - MSVC, developed by Microsoft.
    • Programiz - An online compiler for learners and developers.
    • InterviewBit - A simple and easy to use online C++ compiler.

  • TypeScript

    • Other dialects and variants

      • WebStorm Debugger - Advanced TypeScript debugging tools in WebStorm.
      • TypeScript Compiler (tsc) - The official TypeScript compiler that transpiles TS to JS with type checking.
      • AssemblyScript - A TypeScript-like language for WebAssembly.
      • ts-morph - TypeScript AST manipulation library based on the TypeScript Compiler API.
      • ReScript - ReScript is a robustly typed language that compiles to efficient and human-readable JavaScript.
      • TypeScript Go - A Go implementation of the TypeScript compiler.
      • TypeScript Compiler API - Official TypeScript AST and parsing tools.
      • VS Code Debugger - Built-in TypeScript debugging support in VS Code.

  • JavaScript

    • swc - A super fast JavaScript compiler written in Rust, significantly faster than Babel.
    • Flow - A static type checker by Meta, similar to TypeScript but with optional typing.
    • V8 - Google Chrome and Node.js JavaScript engine with JIT compilation.
    • Esprima - A widely used ECMAScript parser that generates ASTs.
    • Prettier - Code formatter that enforces a consistent style.
    • AST Explorer - An online tool to visualize JavaScript ASTs.
    • JavaScriptCore (JSC) - JavaScript engine for WebKit, used in Safari.
    • Cherow - A fast and spec-compliant ECMAScript parser.
    • CoffeeScript - A syntactic sugar layer over JavaScript, compiles to JS.
    • Duktape - Lightweight JavaScript interpreter for embedded systems.
    • Espruino - JavaScript interpreter designed for microcontrollers like ESP8266/ESP32.
    • Chrome DevTools - Built-in Chrome debugging tools with breakpoints and performance analysis.
    • esbuild - A high-speed JavaScript bundler and compiler with tree-shaking and minification.
    • traceur-compiler - Traceur is a JavaScript.next-to-JavaScript-of-today compiler.
    • Acorn - A lightweight ECMAScript parser that supports the latest ES standard.
    • QuickJS - Lightweight JavaScript engine supporting ES2020, suitable for embedded use.
    • sucrase - A fast JavaScript transpiler optimized for development.
    • Jerryscript - Ultra-lightweight JavaScript engine for IoT devices.
    • GraalJS - JavaScript engine in GraalVM, allowing interoperability with JVM.
    • ndb - Enhanced Node.js debugger based on Chrome DevTools.
    • Recast - JavaScript AST manipulation library for code transformation.
    • UglifyJS - JavaScript minifier, optimizer, and obfuscator.
    • Tree-sitter JavaScript - Incremental JavaScript parser, used in LSP and syntax analysis.
    • Escodegen - Converts JavaScript AST back to source code.
    • Node.js Inspector - `node --inspect` for debugging Node.js with Chrome DevTools.
    • MuJS - Minimal JavaScript interpreter with no dependencies.
    • Babel - Transpiles modern JavaScript into ES5 for compatibility.
    • Terser - Successor to UglifyJS, optimized for ES6+.
    • Deno - A modern JavaScript runtime, built on V8, with enhanced security.
    • Hermes - AOT JavaScript compiler by Meta, optimized for React Native.
    • SpiderMonkey - Mozilla’s JS engine, featuring Baseline and IonMonkey JIT.
    • Seafox - A minimal JavaScript parser with ES2020 support.
    • Firefox DevTools - Firefox’s debugging tools, similar to Chrome DevTools.
    • JScript - A deprecated JavaScript variant from Microsoft for older Internet Explorer versions.
    • LiveScript - A functional programming variant of CoffeeScript with pattern matching.
    • Nasal-Interpreter - Nasal is an ECMAscript-like language.

  • Lisp

    • Common Lisp

    • Scheme

      • Racket - A powerful Lisp variant, supporting JIT compilation and DSL creation.
      • Chicken Scheme - AOT compiler to C, suitable for embedded development.
      • Guile - The GNU Scheme interpreter and compiler, embeddable in C applications.
      • Gambit - Compiles Scheme to efficient C code.
      • Kawa - A Scheme implementation targeting the JVM.
      • Chez Scheme - A high-performance Scheme implementation supporting AOT and JIT.
      • Bigloo - A Scheme compiler that generates C, JVM, and .NET code.
      • Larceny - A Scheme compiler with multiple backend targets.

    • Emacs Lisp

    • Other dialects and variants

      • newLISP - A lightweight Lisp dialect suited for scripting and general programming tasks.
      • Carp - A statically typed Lisp for system programming, compiles to native code via AOT.
      • Janet - A lightweight Lisp supporting AOT and JIT compilation, suitable for embedded and scripting.
      • Hy - A Lisp that compiles directly to Python’s AST for seamless integration with Python.
      • Fennel - A Lisp variant based on Lua, compiling to Lua code, ideal for LuaJIT.
      • GOAL - A Lisp dialect developed by Naughty Dog for PlayStation 2 game development.
      • Calcit - Indentation-based ClojureScript dialect in Rust and compiling to JavaScript ES Modules.
      • Wasp Lisp - A Scheme-inspired language designed for WebAssembly and frontend development.
      • Arc - A Lisp dialect developed by Paul Graham, focused on simplicity and flexibility.
      • AutoLISP - A Lisp dialect integrated into AutoCAD for automating drawing tasks.
      • Clarity - A Lisp-like smart contract language for Stacks blockchain.
      • EuLisp - A European Lisp dialect aimed at unifying features of Common Lisp and Scheme.
      • Ferret - A Racket-style Scheme variant that supports WebAssembly.
      • Franz Lisp - An early Lisp implementation, historically significant but no longer maintained.
      • Interlisp - An early Lisp dialect with an integrated programming environment, mainly used in Xerox systems.
      • ISLISP - A standardized Lisp dialect focused on providing a small yet powerful core language.
      • LeLisp - A Lisp dialect developed in France, mainly used for AI research.
      • Maclisp - A Lisp dialect developed at MIT in the 1960s, influential in later Lisp dialects.
      • MDL - A Lisp dialect developed at MIT for AI and computer science research.
      • NIL - A Lisp implementation developed at MIT for VAX computers, no longer maintained.
      • PicoLisp - A minimal and efficient Lisp dialect suitable for embedded systems and application development.
      • PSL - A Lisp implementation designed to be portable across multiple hardware and OS platforms.
      • RPL - A Lisp dialect developed by Hewlett-Packard for its calculators, using Reverse Polish Notation.
      • SKILL - A Lisp dialect developed by Cadence Design Systems for electronic design automation (EDA).
      • Spice Lisp - A Lisp dialect historically used in the development of CMUCL.
      • T - A Scheme-derived Lisp dialect developed at Yale, designed for high-performance systems programming.
      • Zetalisp - A Lisp dialect developed for Lisp Machines, influencing the development of Common Lisp.

    • Clojure

      • Babashka - A GraalVM-based Clojure interpreter, optimized for scripting.
      • ClojureScript - Compiles to JavaScript, targeting browsers and Node.js.
      • Clojure - The official Clojure compiler, compiles to JVM bytecode.
      • Joker - A lightweight Clojure interpreter written in Go.
      • Arcadia - A Clojure implementation for Unity game development.

  • Golang

    • go/ast - Go's standard library for AST parsing, often used in conjunction with `go/parser`.
    • Delve - The official Go debugger, supports breakpoints, variable inspection, and Goroutine debugging.
    • Go Compiler - The official Go compiler, supports AOT compilation, based on Plan 9 assembly and partially on LLVM.
    • c4go - Transpile C code to Go code.
    • esp32 - Transpile Go into Arduino code.
    • f4go - Transpile FORTRAN 77 code to Go code.
    • GopherJS - Transpiles Go code to JavaScript, allowing Go code to run in the browser.
    • golangci-lint - A linter that uses multiple Go parsers to perform static analysis and code formatting checks.
    • Gop (Goplus) - A Go variant focused on engineering computation, with Python-like dynamic features and meta programming.
    • Yaegi - A Go interpreter that allows Go code to be transpiled into executable Go syntax trees.
    • pprof - A Go-built performance profiling tool, useful for CPU and memory analysis.
    • Vlang - A language with Go-like syntax but more concise, faster compilation speed, and memory safety mechanisms.
    • TinyGo - A lightweight Go compiler based on LLVM, suitable for embedded systems and WebAssembly.
    • Odin - A systems programming language influenced by Go, similar to Go + Rust.
    • Peg - A PEG parser generator for Go, supports grammar rule definitions.
    • Gno - A smart contract language developed in the Cosmos ecosystem, based on Go syntax, supporting persistent computation.
    • llgo - An older LLVM-based compiler for Go, now discontinued, but of historical value.
    • gocc - A Go-written LALR(1) parser generator, similar to YACC/Bison.
    • go2hx - Compiler from Go to Haxe to Javascript/C++/Java/C#.
    • tuqqu/go-parser - Golang parser written in PHP.
    • antlr4-go - The Go runtime for ANTLR, can be used to parse various languages, including Go.
    • go/parser - The official Go parsing library, parses Go code and generates an AST.
    • goyacc - YACC Implementation in Go. Standard LALR(1) parser generator.
    • gdb-go - GNU Debugger (GDB) support for Go, but with limited functionality; Delve is recommended.
    • GoTrace - Go runtime's built-in tracing tool, useful for concurrency analysis and performance tuning.
    • cell-script - A new designed language for smart-contract programming on UTXO chain.
    • Wa - A general-purpose programming language designed for for WebAssembly.

  • Solidity

    • Other dialects and variants

      • aderyn - Rust-based solidity smart contract static analyzer designed to help find vulnerabilities in Solidity code bases.
      • solidity-repl - Ethereum Solidity REPL.
      • solgraph - Visualize control flows for smart contract security analysis.
      • warp - Warp is a Solidity to Cairo Compiler, write/migrate Solidity to Cairo for easy onboarding into the StarkNet ecosystem.
      • Slither - Solidity static analysis framework, a suite of vulnerability detectors, prints visual information about contract details etc.
      • solhint - Solhint is an open-source project to provide a linting utility for Solidity code.
      • evmdis - EVM Disassembler that performs static analysis on the bytecode to provide a higher level of abstraction than raw EVM operations.
      • solidity - Official Compiler for the Solidity Smart Contracts Programming Language.
      • solana-solidity.js - Compile, deploy, and use Solidity contracts on Solana.
      • sol-repl - a REPL to provide instant feedback for Solidity snippets.
      • SIF - Solidity code instrumentation and analysis framework.
      • solc - Solidity compiler bindings for Deno.
      • solc-js - Javascript bindings for the Solidity compiler.
      • solidity-parser-antlr - A Solidity parser for JS built on top of a robust ANTLR4 grammar.
      • sulk - Solidity compilation without the tears.
      • Soltsice - Solidity & TypeScript Integration, Configuration and Examples.
      • solang - Solidity Compiler for Solana, Polkadot and Stellar.
      • solar - Blazingly fast, modular and contributor friendly Solidity compiler, written in Rust.
      • revive - Solidity compiler and YUL recompiler to LLVM, targetting RISC-V on PolkaVM.
      • pyrometer - A tool for analyzing the security and parameters of a solidity smart contract.
      • era-compiler-solidity - ZKsync Compiler Toolchain for Solidity and Yul.
      • charcoal - Charcoal is a Solidity-to-Sway translator written in Rust.
      • ethdebug - A standard debugging data format for smart contracts on Ethereum-compatible networks.
      • ocaml-solidity - Ocaml-solidity provides a Solidity parser and typechecker.
      • Remix - Online realtime compiler and runtime.
      • slang - A modular set of compiler APIs empowering the next generation of Solidity code analysis and developer tooling.
      • sol-to-o1js - Solidity Compiler & Transpiler for Mina.
      • sol2uml - Unified Modeling Language (UML) class diagram generator for Solidity contracts.
      • Solidity Parser for JavaScript - A Solidity parser for JS built on top of a robust ANTLR4 grammar.
      • solidity-rs - Solidity 0.8.X AST parsing and analysis in Rust.
      • SOLL - SOLL is a new compiler for generate Ewasm from solidity and yul.
      • surya - Utility tool for smart contract systems, offering a number of visual outputs and information about the contracts’ structure.
Programming Languages
Rust 31 Python 18 Go 18 JavaScript 14 C 10 TypeScript 9 Clojure 3 Common Lisp 3 C++ 3 Haskell 2
Categories
Lisp 48 JavaScript 36 Solidity 32 Golang 27 Rust 27 Python 24 C/C++ 23 TypeScript 8
Sub Categories
Other dialects and variants 118 Scheme 8 Common Lisp 6 Clojure 5 Emacs Lisp 2
Keywords
compiler 20 python 19 rust 16 solidity 15 golang 13 ethereum 12 javascript 11 go 10 language 9 c 8 programming-language 7 debugger 7 parser 6 cpp 5 lisp 5 interpreter 5 smart-contracts 5 debugging 5 wasm 4 typescript 4 transpiler 4 clojure 4 profiler 3 grammar 3 linter 3 nodejs 3 repl 3 parsing 3 debug 3 blockchain 3 ast 3 awesome 3 convert 2 evm 2 tracer 2 ipython 2 arduino 2 microcontroller 2 esp32 2 java 2 performance-analysis 2 parser-combinators 2 python3 2 jit 2 common-lisp 2 performance 2 peg 2 parser-generator 2 macros 2 llvm 2