Breaking the Speed Barrier: Integrating Rust into Your Python Projects

Python is beloved for its simplicity and readability, but when performance becomes critical, developers often find themselves reaching out for alternatives or even thinking about ground up rewrites.

Tap into the world of Rust - a system programming language designed for speed, memory safety, and concurrency.

In this post, we’ll explore how to get the best of both worlds: Python’s ease of use combined with Rust’s blazing speed. You don’t need to rewrite your entire application - instead, you can strategically accelerate the performance-critical parts by calling Rust functions directly from your python code.

We’ll walk through a simple but practical example: implementing a Fibonacci calculator in Rust and calling it from Python. You’ll see firsthand how this hybrid approach can yield impressive performance improvements (often 20x or more) with relatively little code.

Prerequisites

Make sure you have following installed:

• Rust (with cargo )

• Python 3.8 or later

• pip

PyO3 + Maturin

The primary way to integrate Rust and Python is the PyO3 Framework.

This framework enables us to

• call Python code from Rust

• call Rust code from Python ( Explained in this blog )

Py03 wraps your Rust code into native python module which is callable by python runtime.

The tricky part is code’s packaging when building mixed Python and native code projects (Python + [Rust, Go, C, C++]). Python code is distributed without compilation and is platform independent; installing the wheels creates .pyc files on the fly (Python bytecode). But our Rust code needs to be compiled and distributed as shared library.

A tool that can help you with the this purpose is Maturin. Maturin manages creating, building, packaging, and distributing a mixed Python/Rust project.

Project setup

creating virtualenv

We will start of by creating and activating the virtual environment.

virtualenv venv
. venv/bin/activate

installing dependencies

Install maturin

pip3 install maturin

It consists of binary called maturin , a command line interface.

We can take look at basic help menu

$ maturin --help
Build and publish crates with pyo3, cffi and uniffi bindings as well as rust binaries as python packages

Usage: maturin [OPTIONS] <COMMAND>

Commands:
  build        Build the crate into python packages
  publish      Build and publish the crate as python packages to pypi
  list-python  Search and list the available python installations
  develop      Install the crate as module in the current virtualenv
  sdist        Build only a source distribution (sdist) without compiling
  init         Create a new cargo project in an existing directory
  new          Create a new cargo project
  generate-ci  Generate CI configuration
  upload       Upload python packages to pypi
  help         Print this message or the help of the given subcommand(s)

Maturin provides several subcommands. We will be focusing on build and develop subcommand.

creating project

Intialize project using maturin new command

$ maturin new --help
Create a new cargo project

Options:
      --name <NAME>
          Set the resulting package name, defaults to the directory name

--[snip]--

      --mixed
          Use mixed Rust/Python project layout

      --src
          Use Python first src layout for mixed Rust/Python project

  -b, --bindings <BINDINGS>
          Which kind of bindings to use

          [possible values: pyo3, cffi, uniffi, bin]

  -h, --help
          Print help (see a summary with '-h')

For our project, we will be using the mixed Rust/Python project layout with Py03 bindings.

$ maturin new --bindings pyo3 --mixed pyo3_fibonacci
 ✨ Done! New project created pyo3_fibonacci

Looking at generated project skeleton

$ tree pyo3_fibonacci/
pyo3_fibonacci/
├── Cargo.toml               <----- Rust dependency and build management
├── pyproject.toml           <----- Python dependency and build management
├── python                   <------ Add your python code
│   ├── pyo3_fibonacci
│   │   └── __init__.py
│   └── tests                
│       └── test_all.py
└── src                       <----- Add your Rust code
    └── lib.rs

Wrapping Rust code with PyO3

Erase all the defaults in pyo3_fibonacci/src/lib.rs

We will start by creating a module using #[pymodule] Rust macro.

Make sure name of the function matches the module name (Here in my case, “pyo3_fibonacci”)

// pyo3_fibonacci/src/lib.rs
use pyo3::prelude::*;                // 1. 

// {{ define functions }}            // 2.

#[pymodule]
fn pyo3_fibonacci(m: &Bound<'_, PyModule>) -> PyResult<()> {
    // {{ function declarations }}   // 3.
    Ok(())
}

// {{ tests }}                       //4.

A simple function

Let’s start with the simple function for our {{ define functions }} block. Our function is fibonacci which calculates the nth fibonacci number.

// {{ define functions }}

/// calculate the nth Fibonacci number
#[pyfunction]                                // 1.
fn fibonacci(n: u64) -> PyResult<u64> {
    if n <= 1 {
        return Ok(n);
    }

    let (mut a, mut b) = (0u64, 1u64);

    for _ in 1..n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    Ok(b)
}

// Rest of  pymodule as is below...

Sr. No	Remark
1.	The Rust macro #[pyfunction] generates code for Python binding.

Adding Rust function to python module

In the {{ function declarations }} block, we add our function to our exported module.

// fibonacci function definition as is... 

#[pymodule]
fn pyo3_fibonacci(m: &Bound<'_, PyModule>) -> PyResult<()> {
    // {{ function declarations }} 
    m.add_function(wrap_pyfunction!(fibonacci, m)?)?;    // <-------- 
    Ok(())
}

Writing Rust unit tests

In {{ tests }} block, we add a few simple unit tests

// {{ tests }}
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_simple_run() {
        assert!(fibonacci(0).is_ok());
        assert_eq!(fibonacci(0).unwrap(), 0);
        assert!(fibonacci(1).is_ok());
        assert_eq!(fibonacci(1).unwrap(), 0);
        assert!(fibonacci(2).is_ok());
        assert_eq!(fibonacci(2).unwrap(), 0);
    }

    #[test]
    fn test_long_run() {
        assert!(fibonacci(50).is_ok());
        assert_eq!(fibonacci(50).unwrap(), 12586269025);

    }
}

Build and run your Python module

With Maturin, with one line you can build Rust module and export it in python interpreter

$ cd pyo3_fibonacci/
$ maturin develop

🍹 Building a mixed python/rust project
🔗 Found pyo3 bindings
🐍 Found CPython 3.10 at /tmp/x/venv/bin/python
📡 Using build options features from pyproject.toml
--[snip]--
📦 Built wheel for CPython 3.10 to /tmp/.tmpBBnoQe/pyo3_fibonacci-0.1.0-cp310-cp310-linux_x86_64.whl
✏️ Setting installed package as editable
🛠 Installed pyo3_fibonacci-0.1.0

Behind the scene, Maturin

• Compile Rust code with cargo into the share library (.so or .dylib depending on OS) and is copied in local python module folder

$ pwd
/tmp/x/pyo3_fibonacci

$ find python -name '*.so'
python/pyo3_fibonacci/pyo3_fibonacci.cpython-310-x86_64-linux-gnu.so

• Editable installs the python module (i.e. pip3 install -e . ) in current virtual environment.

$ pip3 list

Package        Version Editable project location
-------------- ------- -------------------------
maturin        1.8.3
pip            25.0.1
pyo3_fibonacci 0.1.0   /tmp/x/pyo3_fibonacci           <---------
setuptools     75.8.2
tomli          2.2.1
wheel          0.45.1

Now using the python interpreter, we can load our module and call function

$ python3
Python 3.10.12 (main, Feb  4 2025, 14:57:36) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import pyo3_fibonacci
>>>
>>> pyo3_fibonacci.fibonacci(3)
2
>>> pyo3_fibonacci.fibonacci(10)
55

Using the Extensions in python

Create the python script under python/pyo3_fibonacci folder to test extension

# python/pyo3_fibonacci/speedup.py
import time

from pyo3_fibonacci import fibonacci as rust_fibonacci

def python_fibonacci(n: int) -> int:
    """Pure Python implementation of Fibonacci"""
    if n <= 1:
        return n

    a, b = 0, 1
    for _ in range(1, n):
        a, b = b, a + b

    return b


def main():
    start_time = time.monotonic()
    rust_result = rust_fibonacci(40)
    rust_time = time.monotonic() - start_time
    print(f'Rust fibonacci(40) = {rust_result}, took {rust_time:.6f} seconds')

    start_time = time.monotonic()
    python_result = python_fibonacci(40)
    python_time = time.monotonic() - start_time
    print(f'Python fibonacci(40) = {python_result}, took {python_time:.6f} seconds')

    speedup = python_time / rust_time
    print(f'Rust is {speedup:.2f}x faster than Python for this calculation')
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Performance comparison

When you run the Python script, you should see output similar to

$ python3 python/pyo3_fibonacci/speedup.py
Rust fibonacci(40) = 102334155, took 0.000013 seconds
Python fibonacci(40) = 102334155, took 0.000267 seconds
Rust is 20.54x faster than Python for this calculation

The exact performance difference will vary based on your system, but you should see a significant speedup with Rust implementation.

Wrap up

That’s it !! Your mixed Python/Rust module is ready to be used, deployed and published. 🎉🎉

Maturin provides several commands to help compile and distribute your mixed Rust/Python package.

For computationally intensive tasks, this approach can provide substantial performance improvements while maintaining the flexibility and ease of use of Python.

In future posts, we can explore more complex examples, such as parallel processing, working with NumPy arrays, or interfacing with external libraries from Rust.