Fork me on GitHub

CPython Compiler Tools



PLY is an implementation of lex and yacc parsing tools for Python.


The pyparsing module is an alternative approach to creating and executing simple grammars, vs. the traditional lex/yacc approach, or the use of regular expressions. The pyparsing module provides a library of classes that client code uses to construct the grammar directly in Python code.


Parsimonious aims to be the fastest arbitrary-lookahead parser written in pure Python. It's based on parsing expression grammars (PEGs), which means you feed it a simplified sort of EBNF notation. Parsimonious was designed to undergird a MediaWiki parser that wouldn't take 5 seconds or a GB of RAM to do one page.


funcparserlib is a parser combinator library.


SPARK stands for the Scanning, Parsing, and Rewriting Kit. It formerly had no name, and was referred to as the "little language framework."


pgen2 is a pure Python implementation of the Python parser generator, pgen. It forms the basis for Mython, the extensible variant of the Python programming language.


Much like the parser module exposes the Python parser, this pgenmodule.c exposes the parser generator used to create the Python parser, pgen, to Python iteslf. Proposed in PEP 269.


ANTLR is a Java parser generator framework that can emit Python parsers.


Syntax Definition


The Zephyr Abstract Syntax Description Lanuguage (ASDL) is a language designed to describe the tree-like data structures in compilers. Its main goal is to provide a method for compiler components written in different languages to interoperate. ASDL makes it easier for applications written in a variety of programming languages to communicate complex recursive data structures.




Mython is an extensible variant of the Python programming language. Mython makes Python extensible by adding two things: parametric quotation statement, and compile-time metaprogramming. The parametric quote statement is simply syntactic sugar for saying "run some function on this embedded string". Compile-time metaprogramming allows you to evaluate that function on the embedded string at compile time. This gives you added choice, both in terms of what your code looks like, and when you want to evaluate that code.


Basil is a metaprogramming framework and playground for Python variants.


Cog is a Python source generation library. Cog transforms files in a very simple way: it finds chunks of Python code embedded in them, executes the Python code, and inserts its output back into the original file. The file can contain whatever text you like around the Python code.

Code Generation


llvmpy is a Python wrapper around the llvm C++ library which allows simple access to compiler tools.


llvm-cbuilder is a Python DSL for constructing higher level LLVM logic.


C/C++ source generation from an AST for CUDA and OpenCL.

C C++

CodePy is a C/C++ metaprogramming toolkit for Python. It handles two aspects of native-code metaprogramming, Generating C/C++ source code and Compiling this source code and dynamically loading it into the Python interpreter.

C C++



The Cython language is a superset of the Python language that additionally supports calling C functions and declaring C types on variables and class attributes. This allows the compiler to generate very efficient C code from Cython code. The C code is generated once and then compiles with all major C/C++ compilers.

Target: C

Theano is a Python library that allows you to define, optimize, and evaluate mathematical expressions involving multi-dimensional arrays efficiently and with transparent use of a GPU.

Target: C++ Target: CUDA

Numba is a NumPy aware dynamic compiler for Python. It creates LLVM bit-code from Python syntax and then creates a wrapper around that bitcode to call from Python.

Target: LLVM

NumbaPro is a proprietary Continuum Analytics product that compiles NumPy expressions to native code with support for parallel execution on multiple cores and GPU hardware. NumbaPro also comes with CUDA Python which supports CUDA programming with Python syntax.

Target: LLVM Target: CUDA PTX

Copperhead is a project to bring data parallelism to Python. Copperhead defines a small functional, data parallel subset of Python, which is then dynamically compiled and executed on parallel platforms. Currently, Copperhead targets NVIDIA GPUs, as well as multicore CPUs through OpenMP and Threading Building Blocks (TBB).

Target: C++

Shed Skin is an experimental compiler, that can translate pure, but implicitly statically typed Python programs into optimized C++. It can generate stand-alone programs or extension modules that can be imported and used in larger Python programs.

Target: C

Parakeet is a runtime compiler for numerical Python. It creates specialized versions of a function for distinct input types and translates array expressions and NumPy library calls into data parallel operators. The current backend uses LLVM but GPU support is in the works.

Target: LLVM

The primary goal of the llpython package is to provide a Python dialect/subset that maps directly to LLVM code.

Target: LLVM

Right now Nuitka is a good replacement for the Python interpreter and compiles every construct that CPython 2.6 and 2.7 offer. It translates the Python into a C++ program that then uses "libpython" to execute in the same way as CPython does, in a very compatible way.

Target: C++

ocl is a minimalist library that dynamically (at run time) converts decorated Python functions into C99, OpenCL, or JavaScript. In the C99 case, it also uses distutils to compile the functions to machine language and allow you to run the compiled ones instead of the interpreted ones. In the OpenCL case you can run the compiled ones using pyOpenCL.

Target: C Target: Javascript

Pythran is a python to c++ compiler for a subset of the python language. It takes a python module annotated with a few interface description and turns it into a native python module with the same interface, but (hopefully) faster.

Target: C++11



The mypy programming language is an experimental Python variant that aims to combine the benefits of dynamic (or "duck") typing and static typing.

VM: Alore

PyPy is a fast, compliant alternative implementation of the Python language supporting a variety of language extensions and code generation paths.

VM: PyPy runtime

TinyPy is a minimalist implementation of python in 64k of code.

VM: Custom



Byterun is a pure-Python implementation of a Python bytecode execution virtual machine.


Falcon is an extension module for Python which implements a optimized, register machine based interpreter, inside of your interpreter.


GPU Interfaces


PyOpenCL lets you access the OpenCL parallel computation API from Python


PyCUDA lets you access Nvidia‘s CUDA parallel computation API from Python.


Bytecode Utilities


BytecodeAssembler is a simple bytecode assembler module that handles most low-level bytecode generation details like jump offsets, stack size tracking, line number table generation, constant and variable name index tracking, etc. That way, you can focus your attention on the desired semantics of your bytecode instead of on these mechanical issues.


Byteplay lets you convert Python code objects into equivalent objects which are easy to play with, and lets you convert those objects back into living Python code objects. It's useful for applying crazy transformations on Python functions, and is also useful in learning Python byte code intricacies.


Unwind provides a universal disassembler that is able to disassemble *.pyc files from both Python 2 and Python 3.


Maynard is a Python bytecode dissasembler/assembler as well as a variety of utilities for working with python by

AST Utilities is a small script to translate Python AST to Python source.


A Pure Python module containing a framework to manipulate and analyze python ast's and bytecode.


astoptimizer is an optimizer for Python code working on the Abstract Syntax Tree (AST, high-level representration). It does as much work as possible at compile time.

Type Utilities


RPython is a restricted subset of Python that is amenable to static analysis. RPython is a core part of the PyPy compiler infastructure.


Python-typelanguage provides a type language for communicating about Python programs and values. Humans communicating to other humans, humans communicating to the computer, and even the computer communicating to humans (via type inference and run-time contract checking).

Ad-hoc Local

Python-type-inference is a Hindley-Milner type inference engine for Python with an OCaml implementation.

Hindley-Milner Global Local

Optimization and Rewriting


Pyrewrite aims to be a small term rewrite library written in pure Python, it is heavily inspired by the StrategoXT project and intended for rewriting ATerm like expression grammars.

Strategic Combinators

Strategies is a library for control flow programming with higher order functions that loosely resembles the Stratego language.

Strategic Combinators

Control Flow

LLPython has 0-CFA analysis for a subset of Python bytecode.


Static Analysis


Pylint is a Python static checker.

Language Tools


Bitey is a LLVM import tool and ctypes wrapper.


nobitey is a tool to load LLVM compiled bitcode and autogenerate a ctypes binding.


PyCParser is a C99 compatable parser written in pure Python, capable of parsing C source files and C header files.


Six is a Python 2-3 compatability layer that offers a variety of compatability mappings for language level features including AST ,parsing, and bytecode.

Other Language Implementations


Lispy is a Scheme Interpreter in Python

Bob Scheme

Bob is a suite of implementations of the Scheme language in Python.


Mini-C is a compiler for a subset of the C programming language written in Python.


Retro is a concatenative, stack based language with roots in Forth