PyPy - Python That Doesn't Suck at Performance

PyPy is a Python interpreter that compiles your code while it runs. Instead of interpreting bytecode like CPython, it watches for hot loops and compiles them to machine code. The result is usually about 3x faster execution.

PyPy 7.3.20 came out in July 2025 and finally supports Python 3.11. It also still supports Python 2.7 because some legacy code just won't die. Python isn't inherently slow - CPython is just designed for simplicity over speed.

How PyPy Actually Works

The JIT compiler runs alongside your Python code. It profiles execution to find hot spots - code that runs repeatedly. Those hot paths get compiled to native machine code, which runs much faster than interpreted bytecode.

You'll see about 3x speedup on CPU-bound pure Python code. Loops, math, and algorithmic work benefit the most. Web applications speed up too if they're doing actual computation rather than just database calls.

The Memory Trade-off

PyPy eats 40% more RAM than CPython. The JIT needs space to store compiled machine code, and the garbage collector works differently. Your monitoring alerts will freak out because memory usage is spiky instead of the smooth slopes you get with CPython's reference counting.

I'm running PyPy on our API servers. Memory usage looks like a broken heart monitor - these weird spikes that look like memory leaks but aren't. Our ops team panicked until we explained the GC patterns. Took three meetings and a lot of coffee.

C Extension Compatibility Hell

This is where PyPy becomes a pain in the ass. Most Python packages with C extensions will break spectacularly. numpy, pandas, lxml, psycopg2 - anything that uses native code will probably fail to install or crash at runtime.

pip install numpy might work, might not. You'll spend hours figuring out why your deployment suddenly breaks on a package that's worked fine for years. Took us 2 weeks to replace all the C extensions in our stack. PyPy has CFFI as a replacement, but that means finding or writing CFFI versions of everything you need.

When PyPy Actually Helps

PyPy works well for:

• Long-running web services where the JIT has time to optimize hot paths
• CPU-intensive pure Python code that runs for more than a few seconds
• Algorithmic work, simulations, and computational tasks
• Backend services that do actual computation rather than just database queries

Skip PyPy for:

• Scripts that run and exit quickly (JIT warmup overhead kills any gains)
• Data science workloads heavy on numpy/pandas (you lose the performance benefits)
• Anything that depends heavily on C extensions you can't replace

The JIT compiler analyzes your code at runtime and optimizes the hot paths. You get better performance the longer your application runs. Perfect for long-running services, useless for short scripts.

How does PyPy actually stack up against other Python implementations? The benchmarks look great, but reality is messier.

Basic Installation

Installing PyPy itself is easy. The dependency nightmare comes later:

## macOS 
brew install pypy3

## Ubuntu/Debian
sudo apt-get install pypy3

## Arch Linux  
sudo pacman -S pypy3

## Windows
choco install pypy3

You can also download binaries from pypy.org or use Docker with pypy:3.11-slim. The installation guide works fine - it's when you try to install packages that things go sideways.

Package Installation Reality

This is where PyPy becomes a pain in the ass:

Package installation with PyPy frequently fails because most packages with C extensions aren't designed for PyPy's different architecture.

## This will definitely break
pip install numpy pandas scikit-learn
## Building wheel for numpy... failed
## Building wheel for pandas... failed
## Error: Microsoft Visual C++ 14.0 is required

## This might work, probably won't
pip install lxml
## Segmentation fault (core dumped)

## What actually works
pip install psycopg2-cffi  # The CFFI version that doesn't hate PyPy

Create a separate virtual environment for PyPy and test every single dependency before you commit to this path. Half your packages won't install, and the other half will install but crash at runtime.

Spent a weekend checking our entire stack. 23 packages needed replacement or removal. Budget time for dependency archaeology (and therapy sessions).

Production Deployment Gotchas

Companies like PortaOne use PyPy in production, but they had to solve these problems:

Docker Containers Get Bigger:

PyPy Docker images are typically 2x larger than equivalent CPython images due to the additional JIT compiler and runtime components.

## Your old Dockerfile
FROM python:3.11-slim

## PyPy version - 2x larger images
FROM pypy:3.11-slim
COPY requirements.txt .
RUN pip install -r requirements.txt  # Pray to the dependency gods

Memory Monitoring Goes Haywire:

PyPy's memory usage shows characteristic spike patterns due to its generational garbage collector, which can trigger false alarms in monitoring systems expecting CPython's smoother memory curves.

Your ops team will panic because PyPy's memory usage looks like a memory leak. The garbage collector creates spiky patterns instead of the smooth curves you get with CPython. Your monitoring alerts will fire constantly until you adjust the thresholds.

Package Replacement Hell:

• psycopg2 breaks → use psycopg2-cffi
• lxml crashes → find a pure Python XML library or write your own
• pycrypto is deprecated → use cryptography library
• pillow might work, might not → test thoroughly before deploying

JIT Warmup Kills Development Velocity:
Dev server restarts take 30-60 seconds longer because PyPy needs to recompile hot paths. The first few requests after restart will be slow as shit while the JIT figures out what to optimize.

Real Deployment War Stories

PortaOne migrated to PyPy and shared their experience:

• Got 60x speedup on pure Python numerical code, 20x on mixed workloads
• Memory usage increased 40% but CPU savings made larger instances worthwhile
• Spent 3 months rewriting and replacing C extension dependencies
• Had to retrain the operations team on new memory usage patterns

Bottom line: PyPy can significantly speed up pure Python code, but the migration cost is high. Budget 2-6 months for dependency replacement work and team training. Only consider it if you're CPU-bound on pure Python code and can't solve the problem by throwing more hardware at it.

If you're still considering PyPy after reading about the installation and deployment challenges, you probably have specific questions about how to handle the common problems everyone runs into.