Skip to content
Go to file


nemesys is a just-in-time (JIT) compiler for the Python programming language.

This project is what happens when someone who has never written a compiler or
taken a computer languages or compilers class writes a compiler. The goals of
this project are fun and learning, not necessarily to contribute anything of
value to the world. If you're a student looking for an example of well-designed
compiler, this is not such an example.

See notes/ for specifics on how the compiler is implemented and its
various behavioral quirks.

Here's what nemesys does:
- Function calls and control flow statements like if, for, while, etc.
- Fast integer math.
- Floating-point math.
- Strings, lists, and tuples.
- Classes and basic inheritance (no multiple inheritance yet).
- Refcounted garbage collection.
- Custom class destructors (__del__).
- Exceptions.
- Lambdas and non-closure private functions.
- Function polymorphism.
- Dicts, kind of (a lot of features don't work).

Here's what nemesys doesn't do yet, but will in the future:
- Sets.
- Variadic functions.
- Recursion.
- Multiple inheritance.
- Decorators.
- Most built-in functions.
- Generators and coroutines.
- Magic methods on classes (except __init__ and __del__, which are implemented).

Here's what nemesys doesn't do yet, but could in the future:
- Interactive shell interface.
- Closures.
- Return statements inside finally blocks.
- Support the CPython C API.
- Optimize its generated assembly code.
- Build and run on architectures other than AMD64.

Here's what nemesys will probably never be able to do:
- Assign arbitrary attributes to objects after construction time.
- Polymorphic variables within a scope (except to/from None).
- Metaclasses.
- Negative exponents for integer bases. Just do 1/(a**b) instead.

Have fun. If you try this and something doesn't work, feel free to complain at
me unless it's already mentioned in the above lists.


Experimental Python JIT compiler




No releases published


No packages published