Rust on BlueberryPy

[PyCon China 2026] It's Time to Learn (Some) Rust — Starting from a Faster pip install

Zeyang Lin — Sat, 05 Sep 2026 07:10:00 GMT

It’s Time to Learn (Some) Rust — Starting from a Faster pip install

Hi everyone! This post is adapted from my lightning talk at PyCon China 2026, “It’s Time to Learn (Some) Rust — Starting from a Faster pip install”. What the subtitle means — I’ll get to that in a moment.

Whether you’ve noticed it or not, Rust is already part of your daily life as a Python developer. uv, ruff, and pyrefly — Meta’s open-source type checker — this new generation of Python tooling is all written in Rust. And plenty of Python libraries are bringing Rust in as well: pydantic v2 rewrote its validation core in Rust and got 17x faster; polars’ entire engine is Rust; cryptography uses it to harden its core. So Rust stopped being “the language next door” a long time ago — it’s hiding inside the dependencies of every pip install you run.

Even CPython’s own source code may soon include Rust. Look at the timeline: in November 2025, the pre-PEP discussion thread opened; in March 2026, the forked CPython project’s CI builds went green on all platforms; and at PyCon US 2026 in May, the working group unveiled zlib-py as the first planned pilot module — a drop-in alternative to the existing zlib module, with decompression running 3 to 6 times faster. If it lands, every pip install you run from then on will decompress faster. That’s where the subtitle comes from.

The bad news: the PEP originally planned for July has slipped. The good news: the reason is nothing external — the design details of the internal Rust API simply deserve to be worked through slowly and carefully. It’s a slip, not a stall. Their target is Python 3.16, in 2027.

So next, let’s see how simple getting started with Rust can be. It’s like the old joke about putting an elephant into a fridge — three steps in total.

Step one: install maturin with uv, then run maturin init — and a Rust project is initialized, ready to be packaged straight into a Python wheel.

Step two: in lib.rs, write a function that computes the n-th Fibonacci number. Only two macros in this code really matter: #[pyfunction] exposes the Rust function to Python, and #[pymodule] registers it as a Python module. The iterative logic in between is essentially the usual way you’d compute Fibonacci in Python — even with no Rust background, you can follow the gist.

Step three: maturin develop. That single command compiles the Rust package, builds a wheel, and installs it into your current Python virtual environment — building, packaging, and installation all in one go, an experience nearly identical to a pure-Python toolchain. Then it’s back to Python: import fibonacci_rs, call fibonacci(88), and the 88th Fibonacci number comes right out.

One sentence to sum it up: Python handles the orchestration; Rust does the computing.

Now, some of you may feel that computing Fibonacci numbers is a bit too simple — barely a step above Hello World.

So let’s look at a somewhat more involved example: the Julia set. In short: take every point in the complex plane, repeatedly apply z = z² + c (with c a fixed complex number), and see which points never fly off to infinity (modulus above a threshold).

In my concrete example, the canvas is 1000×1000 — one million points in total, each iterated at most 300 times. In the figure, the black areas are points that escaped quickly; the brighter the region, the more iterations it took to escape; and the white, snowflake-shaped region in the middle marks points that still hadn’t escaped after 300 iterations. This is a CPU-bound task — precisely the territory where Python is considered relatively weak.

We start with the pure-Python version: an honest, plain double loop. A run of line_profiler makes the picture stark: this one function devours 96.1% of the program’s total time, while the two list operations above it — each executed a million times — account for just 1.4% and 1.5% respectively.

Still using maturin, we write a Rust function, calculate_z_serial, that mirrors the pure-Python function roughly one-to-one in logic.

Once it’s written, the Python script needs exactly one added import line and one changed function name — that’s it. From the caller’s point of view, the function signature and behavior are completely unchanged.

Now we run line_profiler again: the function’s share of runtime drops from 96% straight down to 18% — the biggest time sinks are now Python’s for loops and list operations — and the script’s total runtime falls from 3.008 seconds to 0.144 seconds, a speedup of more than 20x. And that’s with a faithful serial port of the original; bring in Rayon for multithreaded parallelism, and the speedup tops 100x.

If, after these two examples, you’d like to try building something in Rust, it’s worth first understanding the four mindset hurdles that lie between writing Python and writing Rust.

First, from recommended explicitness to enforced explicitness: Python’s “explicit is better than implicit” is advice; Rust makes it law — mutating data requires declaring mut, match must be exhaustive, and if you don’t comply, it refuses to compile.

Second, from referencing data to owning it: in Python, assignment is sticking a name tag on an object — share it freely, and the GC cleans up. In Rust, every value has exactly one owner, and whether it’s moved or borrowed is checked with total clarity at compile time.

Third, from EAFP to LBYL — from “easier to ask forgiveness than permission” to “look before you leap”: Rust writes “can this fail?” into the types. With Option and Result, you can’t touch the value without checking it first.

Fourth, from the GIL to real concurrency: data races become compile errors — if your program compiles, it is guaranteed free of data races.

Here’s a reference roadmap for learning Rust, in four stages.

Stage one, syntax bridging — with a Python foundation, you’ll get up to speed quickly.

Stage two is the climb: ownership, borrowing, error handling, traits, closures — possibly the most painful stretch of the entire journey, but push through it and the change is qualitative.

Stage three, concurrency. std::thread has you writing real multithreaded code; shared mutable state gets the standard Arc-plus-Mutex combo; and whether data may cross thread boundaries is policed by the compiler through Send/Sync. Want to keep it easy? Rayon turns a loop into data-parallel execution with one line; for I/O-bound concurrency, there’s tokio, the async runtime.

Last and most important: hands-on practice. Use maturin to rewrite a hot function from your own project — profile to locate it, test for parity, benchmark to compare — closing the loop.

As we all know, writing code while you learn is one of the most effective ways to surface problems and consolidate knowledge. These are the three tools I found most helpful as a beginner: Rustlings — around ninety bite-sized exercises straight from the official project, a few minutes each, running locally; and Codewars and LeetCode, which both let you solve problems in Rust directly. Re-solving problems you previously did in Python — this time in Rust — makes the differences between the two languages far easier to internalize.

So does this mean all your Python code should become Rust? Before you start, remember: profiling first — confirm the bottleneck before talking about a rewrite. Don’t go on a hunch.

Good candidates for a rewrite: CPU-bound modules with clear boundaries that process untrusted input; I/O-bound code and glue code can often stay as they are.

Before you dive in, also look at the alternatives: a better algorithm, a free-threaded build, an existing third-party library — or Cython, Numba, or GPU acceleration. Any of these may be the better deal.

Of course, real-world decisions are more complicated — team skills and migration cost come into play, among other factors. And remember this line: Rust is not a “press for speed” button — speed has always been the reward for choosing the right problem.

If you still feel Rust is too hard to learn, consider it from another angle: even if you never write production-grade Rust, the time is not wasted. Explicit types, ownership, explicit error handling, exhaustive matching — these habits of mind transfer back and make your Python more rigorous.

OK, to wrap up. Rust is not Python’s rival — it’s Python’s partner: Python for orchestration, Rust for speed and safety. And learning Rust is more than an investment in personal skills: judging by the progress of Rust for CPython, it may be your ticket to contributing to CPython. The next Rust for CPython contributor might well be you, reading this article right now.

Of course, this talk would not exist without the valuable material left behind by pioneers in the community — Microsoft’s Rust for Python Programmers course, plus several excellent talks and articles, all listed below. My thanks to all of them.

Microsoft — Rust for Python Programmers (open course)
Daroc Alden — “Eventual Rust in CPython”
Bob Belderbos — “Learning Rust Made Me a Better Python Developer”
Daniel Szoke — “Why You, a Python Developer, Should Learn Rust”
Emma Smith — “Rust for CPython: Making Python Safer and More Robust for Everyone”
Micha Gorelick & Ian Ozsvald — High Performance Python, 2nd Edition

That’s the whole talk. The demo code is on GitHub, and if you’re interested, you’re welcome to find me on any of these platforms to keep the conversation going. Thanks for reading!

UV is the latest attempt to rule All Python tools

Zeyang Lin — Wed, 21 Feb 2024 07:23:13 GMT

In short, uv is a command line tool written in Rust for Python developers, which aims to be “a comprehensive project and package manager that is extremely fast, reliable, and easy to use”.

If you are still interested, I hope you can spend a couple of minutes so that I can give you a quick tour of it.

Quick fact sheet

language: Rust

version: 0.1.13 (at the time of updating this post)

repo: github (6k stars)

pypi: pypi

docs: N/A

supported python versions: 3.8 through 3.12 (inclusive)

supported os: Windows, Linux, MacOS

Drop-in replacement for pip and more

uv is from the creator of ruff, Charlie Marsh and astralsh.

ruff, the linting and formating tool written is Rust as well, has already gain fame and popularity during the past year or so, and I believe many of Python developers have been using it for quite a while.

And uv is no doubt their next step in improving the Python toolchain eco.

Although you can easily install uv using pip or pipx just like any other Python tool, essentially it does not rely on your Python interpreter to be installed.

It provides just the binary executable and you can get it easily by running the quick script following the insructions in its git repo. And that’s it, no Python or Rust runtime required till this point.

Creating a virtual environment is now as easy as uv venv, though you now need at least one Python interpreter ready to make it work.

The virtual env it creates is just a standard Python venv, except it does not include pip by default (however if you need pip, you can let it be included by using an extra flag, or you could install it manually anytime after).

Some of your daily commands can then be like (but faster):

uv pip install -r requirements.txt
uv pip install black==24.2.0
uv pip compile pyprojects.toml -o requirements.txt

Fast in deed

Just like ruff is known as being an extremely fast linter, uv’s speed is also impressive.

Here is a short requirements.txt from one of my repos:

fastapi==0.109.2
pydantic[email]==2.6.1
python-multipart==0.0.9
uvicorn[standard]==0.27.1

coverage>=7.4.0
httpx>=0.26.0
memray>=1.11.0
pytest>=8.0.0

And I gave uv a try using github actions. The result on ubuntu-latest with Python 3.12 looks like this

> Run uv pip install -r requirements.dev.txt
Resolved 40 packages in 185ms
Downloaded 40 packages in 268ms
Installed 40 packages in 24ms
 + annotated-types==0.6.0
 + anyio==4.3.0
 + certifi==2024.2.2
 + click==8.1.7
 + coverage==7.4.2
 + dnspython==2.6.1
 + email-validator==2.1.0.post1
 + fastapi==0.109.2
 + h11==0.14.0
 + httpcore==1.0.3
 + httptools==0.6.1
 + httpx==0.26.0
 + idna==3.6
 + iniconfig==2.0.0
 + jinja2==3.1.3
 + linkify-it-py==2.0.3
 + markdown-it-py==3.0.0
 + markupsafe==2.1.5
 + mdit-py-plugins==0.4.0
 + mdurl==0.1.2
 + memray==1.11.0
 + packaging==23.2
 + pluggy==1.4.0
 + pydantic==2.6.1
 + pydantic-core==2.16.2
 + pygments==2.17.2
 + pytest==8.0.1
 + python-dotenv==1.0.1
 + python-multipart==0.0.9
 + pyyaml==6.0.1
 + rich==13.7.0
 + sniffio==1.3.0
 + starlette==0.36.3
 + textual==0.52.1
 + typing-extensions==4.9.0
 + uc-micro-py==1.0.3
 + uvicorn==0.27.1
 + uvloop==0.19.0
 + watchfiles==0.21.0
 + websockets==12.0

As you can see, this process, including solving the dependencies, downloading them and installing them, took just less than half a second!

Features in need

uv’s vision, according to the blog, is

a single binary that bootstraps your Python installation and gives you everything you need to be productive with Python, bundling not only pip, pip-tools, and virtualenv, but also pipx, tox, poetry, pyenv, ruff, and more.

And appearantly at the current point, it is still quite far away from that.

The only two major top-level sub-commands the cli currently supports are

venv
pip
cache

It thus can only create a virtual environment, install dependencies into it and outputs a “lock” file, etc.

I want it to list installed packages, or run commands using the interpreter inside the virtual env, just like what poetry is capable of right now.

Not to mention that it cannot run tests, switch virtual environments or lint source files.

But it’s still in its early age, and the pace is like one patch version every couple of days, isn’t it?

What about Rye

The ambitions of uv share a lot with those from Rye, a tool (which happens to be written in Rust as well) created by Armin Ronacher, the creator of Flask.

What’s more, the team behind uv, astralsh, is actually taking over the dev work of Rye according to their blog, and ultimately going to migrate Rye to uv in the future.

We saw this as a rare opportunity to team up, and to avoid fragmenting the Python ecosystem. As such, in collaboration with Armin, we’re excited to be taking over Rye. Our goal is to evolve uv into a production-ready “Cargo for Python”, and to provide a smooth migration path from Rye to uv when the time is right.

Some thoughts

The name uv seems not relevant to libuv, uvloop or uvicorn.

Maybe it’s short for “universal/ultimate/unified virtualenv manager”?

The dedicated docs pages of uv are not present at the time of writing, which is a pitty.

References

[one-liner] Install Rust (Rustup)

Zeyang Lin — Tue, 16 May 2023 14:24:06 GMT

One-Liner series: Rustup

source: rust-lang.org

Install on Ubuntu

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Update on Ubuntu

rustup update