Package: maturin
Maturinformerly pyo3-packBuild and publish crates with pyo3, rust-cpython, cffi and uniffi bindings as well as rust binaries as python packages.This project is meant as a zero configuration replacement forsetuptools-rustandmilksnake.
It supports building wheels for python 3.7+ on windows, linux, mac and freebsd, can upload them topypiand has basic pypy and graalpy support.Check out theUser Guide!UsageYou can either download binaries from thelatest releaseor install it withpipx:pipxinstallmaturinNotepip install maturinshould also work if you don't want to use pipx.There are four main commands:maturin newcreates a new cargo project with maturin configured.maturin publishbuilds the crate into python packages and publishes them to pypi.maturin buildbuilds the wheels and stores them in a folder (target/wheelsby default), but doesn't upload them. It's possible to upload those withtwineormaturin upload.maturin developbuilds the crate and installs it as a python module directly in the current virtualenv. Note that whilematurin developis faster, it doesn't support all the feature that runningpip installaftermaturin buildsupports.pyo3andrust-cpythonbindings are automatically detected. For cffi or binaries, you need to pass-b cffior-b bin.
maturin doesn't need extra configuration files and doesn't clash with an existing setuptools-rust or milksnake configuration.
You can even integrate it with testing tools such astox.
There are examples for the different bindings in thetest-cratesfolder.The name of the package will be the name of the cargo project, i.e. the name field in the[package]section ofCargo.toml.
The name of the module, which you are using when importing, will be thenamevalue in the[lib]section (which defaults to the name of the package). For binaries, it's simply the name of the binary generated by cargo.Python packaging basicsPython packages come in two formats:
A built form called wheel and source distributions (sdist), both of which are archives.
A wheel can be compatible with any python version, interpreter (cpython and pypy, mainly), operating system and hardware architecture (for pure python wheels),
can be limited to a specific platform and architecture (e.g. when using ctypes or cffi) or to a specific python interpreter and version on a specific architecture and operating system (e.g. with pyo3 and rust-cpython).When usingpip installon a package, pip tries to find a matching wheel and install that. If it doesn't find one, it downloads the source distribution and builds a wheel for the current platform,
which requires the right compilers to be installed. Installing a wheel is much faster than installing a source distribution as building wheels is generally slow.When you publish a package to be installable withpip install, you upload it topypi, the official package repository.
For testing, you can usetest pypiinstead, which you can use withpip install --index-url https://test.pypi.org/simple/.
Note that for publishing for linux,you need to use the manylinux docker container, while for publishing from your repository you can use thePyO3/maturin-action github action.pyo3 and rust-cpythonFor pyo3 and rust-cpython, maturin can only build packages for installed python versions. On linux and mac, all python versions inPATHare used.
If you don't set your own interpreters with-i, a heuristic is used to search for python installations.
On windows all versions from the python launcher (which is installed by default by the python.org installer) and all conda environments except base are used. You can check which versions are picked up with thelist-pythonsubcommand.pyo3 will set the used python interpreter in the environment variablePYTHON_SYS_EXECUTABLE, which can be used from custom build scripts. Maturin can build and upload wheels for pypy with pyo3, even though only pypy3.7-7.3 on linux is tested.CffiCffi wheels are compatible with all python versions including pypy. Ifcffiisn't installed and python is running inside a virtualenv, maturin will install it, otherwise you have to install it yourself (pip install cffi).maturin uses cbindgen to generate a header file, which can be customized by configuring cbindgen through acbindgen.tomlfile inside your project root. Alternatively you can use a build script that writes a header file to$PROJECT_ROOT/target/header.h.Based on the header file maturin generates a module which exports anffiand alibobject.Example of a custom build scriptusecbindgen;usestd::env;usestd::path::Path;fnmain(){letcrate_dir=env::var("CARGO_MANIFEST_DIR").unwrap();letbindings=cbindgen::Builder::new().with_no_includes().with_language(cbindgen::Language::C).with_crate(crate_dir).generate().unwrap();bindings.write_to_file(Path::new("target").join("header.h"));}uniffiuniffi bindings useuniffi-rsto generate Pythonctypesbindings
from an interface definition file. uniffi wheels are compatible with all python versions including pypy.Mixed rust/python projectsTo create a mixed rust/python project, create a folder with your module name (i.e.lib.namein Cargo.toml) next to your Cargo.toml and add your python sources there:my-project
├── Cargo.toml
├── my_project
│   ├── __init__.py
│   └── bar.py
├── pyproject.toml
├── README.md
└── src
    └── lib.rsYou can specify a different python source directory inpyproject.tomlby settingtool.maturin.python-source, for examplepyproject.toml[tool.maturin]python-source="python"module-name="my_project._lib_name"then the project structure would look like this:my-project
├── Cargo.toml
├── python
│   └── my_project
│       ├── __init__.py
│       └── bar.py
├── pyproject.toml
├── README.md
└── src
    └── lib.rsNoteThis structure is recommended to avoida commonImportErrorpitfallmaturin will add the native extension as a module in your python folder. When using develop, maturin will copy the native library and for cffi also the glue code to your python folder. You should add those files to your gitignore.With cffi you can dofrom .my_project import liband then uselib.my_native_function, with pyo3/rust-cpython you can directlyfrom .my_project import my_native_function.Example layout with pyo3 aftermaturin develop:my-project
├── Cargo.toml
├── my_project
│   ├── __init__.py
│   ├── bar.py
│   └── _lib_name.cpython-36m-x86_64-linux-gnu.so
├── README.md
└── src
    └── lib.rsWhen doing this also be sure to set the module name in your code to match the last part ofmodule-name(don't include the package path):#[pymodule]#[pyo3(name="_lib_name")]fnmy_lib_name(_py:Python<'_>,m:&PyModule)->PyResult<()>{m.add_class::<MyPythonRustClass>()?;Ok(())}Python metadatamaturin supportsPEP 621, you can specify python package metadata inpyproject.toml.
maturin merges metadata fromCargo.tomlandpyproject.toml,pyproject.tomltakes precedence overCargo.toml.To specify python dependencies, add a listdependenciesin a[project]section in thepyproject.toml. This list is equivalent toinstall_requiresin setuptools:[project]name="my-project"dependencies=["flask~=1.1.0","toml==0.10.0"]Pip allows adding so called console scripts, which are shell commands that execute some function in your program. You can add console scripts in a section[project.scripts].
The keys are the script names while the values are the path to the function in the formatsome.module.path:class.function, where theclasspart is optional. The function is called with no arguments. Example:[project.scripts]get_42="my_project:DummyClass.get_42"You can also specifytrove classifiersin yourpyproject.tomlunderproject.classifiers:[project]name="my-project"classifiers=["Programming Language :: Python"]Source distributionmaturin supports building throughpyproject.toml. To use it, create apyproject.tomlnext to yourCargo.tomlwith the following content:[build-system]requires=["maturin>=1.0,<2.0"]build-backend="maturin"If apyproject.tomlwith a[build-system]entry is present, maturin can build a source distribution of your package when--sdistis specified.
The source distribution will contain the same files ascargo package. To only build a source distribution, pass--interpreterwithout any values.You can then e.g. install your package withpip install .. Withpip install . -vyou can see the output of cargo and maturin.You can use the optionscompatibility,skip-auditwheel,bindings,stripand common Cargo build options such asfeaturesunder[tool.maturin]the same way you would when running maturin directly.
Thebindingskey is required for cffi and bin projects as those can't be automatically detected. Currently, all builds are in release mode (seethis threadfor details).For a non-manylinux build with cffi bindings you could use the following:[build-system]requires=["maturin>=1.0,<2.0"]build-backend="maturin"[tool.maturin]bindings="cffi"compatibility="linux"manylinuxoption is also accepted as an alias ofcompatibilityfor backward compatibility with old version of maturin.To include arbitrary files in the sdist for use during compilation specifyincludeas an array ofpathglobs withformatset tosdist:[tool.maturin]include=[{path="path/**/*",format="sdist"}]There's amaturin sdistcommand for only building a source distribution as workaround forpypa/pip#6041.Manylinux and auditwheelFor portability reasons, native python modules on linux must only dynamically link a set of very few libraries which are installed basically everywhere, hence the name manylinux.
The pypa offers special docker images and a tool calledauditwheelto ensure compliance with themanylinux rules.
If you want to publish widely usable wheels for linux pypi,you need to use a manylinux docker image.The Rust compiler since version 1.64requires at least glibc 2.17, so you need to use at least manylinux2014.
For publishing, we recommend enforcing the same manylinux version as the image with the manylinux flag, e.g. use--manylinux 2014if you are building inquay.io/pypa/manylinux2014_x86_64.
ThePyO3/maturin-actiongithub action already takes care of this if you set e.g.manylinux: 2014.maturin contains a reimplementation of auditwheel automatically checks the generated library and gives the wheel the proper.
If your system's glibc is too new or you link other shared libraries, it will assign thelinuxtag.
You can also manually disable those checks and directly use native linux target with--manylinux off.For full manylinux compliance you need to compile in a CentOS docker container. Thepyo3/maturinimage is based on the manylinux2014 image,
and passes arguments to thematurinbinary. You can use it like this:docker run --rm -v $(pwd):/io ghcr.io/pyo3/maturin build --release  # or other maturin argumentsNote that this image is very basic and only contains python, maturin and stable rust. If you need additional tools, you can run commands inside the manylinux container.
Seekonstin/complex-manylinux-maturin-dockerfor a small educational example ornanoporetech/fast-ctc-decodefor a real world setup.maturin itself is manylinux compliant when compiled for the musl target.Examplesballista-python- A Python library that binds to Apache Arrow distributed query engine Ballistachardetng-py- Python binding for the chardetng character encoding detector.connector-x- ConnectorX enables you to load data from databases into Python in the fastest and most memory efficient waydatafusion-python- a Python library that binds to Apache Arrow in-memory query engine DataFusiondeltalake-python- Native Delta Lake Python binding based on delta-rs with Pandas integrationopendal- OpenDAL Python Binding to access data freelyorjson- A fast, correct JSON library for Pythonpolars- Fast multi-threaded DataFrame library in Rust | Python | Node.jspydantic-core- Core validation logic for pydantic written in Rustpyrus-cramjam- Thin Python wrapper to de/compression algorithms in Rustpyxel- A retro game engine for Pythonroapi- ROAPI automatically spins up read-only APIs for static datasets without requiring you to write a single line of coderobyn-  A fast and extensible async python web server with a Rust runtimeruff- An extremely fast Python linter, written in Rusttantivy-py- Python bindings for Tantivywatchfiles- Simple, modern and high performance file watching and code reload in pythonwonnx- Wonnx is a GPU-accelerated ONNX inference run-time written 100% in RustContributingEveryone is welcomed to contribute to maturin! There are many ways to support the project, such as:help maturin users with issues on GitHub and Gitterimprove documentationwrite features and bugfixespublish blogs and examples of how to use maturinOurcontributing noteshave more resources if you wish to volunteer time for maturin and are searching where to start.If you don't have time to contribute yourself but still wish to support the project's future success, some of our maintainers have GitHub sponsorship pages:messenseLicenseLicensed under either of:Apache License, Version 2.0, (LICENSE-APACHEorhttp://www.apache.org/licenses/LICENSE-2.0)MIT license (LICENSE-MITorhttp://opensource.org/licenses/MIT)at your option.