maturin

I've moved much of my vibe-coded projects from Python to Rust. That lets me vibe code an Android port as well - only the UI needs porting. If the app has a desktop GUI, that's still in Python with Qt. Maturin creates Python packages from Rust. It's terrific. https://github.com/pyo3/maturin

There is basic GraalPy support in Maturin[0] and PyO3[1], the problem is often that packages require older Maturin/PyO3 versions and/or they use CPython-isms, semi-public APIs, etc., but it is getting better, for example [2]. It is fair to say that large projects with a huge set of dependencies will likely face some compatibility issues, but we're working on ironing this out. There is GraalPy support in setup-python GitHub action. GraalPy is supported in the manylinux image [3]. Hopefully soon also in cibuildwheel [4]. [0] https://github.com/PyO3/maturin/pull/1645 (merged) [1] https://github.com/PyO3/pyo3/pull/3247 (merged) [2] https://github.com/pydantic/jiter/pull/135 (merged) [3] https://github.com/pypa/manylinux/pull/1520 (merged) [4] https://github.com/pypa/cibuildwheel/pull/1538

I agree, you can also use Rust with PyO3[0] and Maturin[1]. It's far easier than what the author is doing is the article. [0] -- https://github.com/PyO3/pyo3 [1] -- https://github.com/PyO3/maturin

My new favorite way to write very fast libraries for Python is to just use Rust and Maturin: https://github.com/PyO3/maturin It basically automates everything for you. If you use it with Github actions, it will compile wheels for you on each release for every platform and python version you want, and even upload them to PyPi (pip) for you. Everything feels very modern and well thought out. People really care about good tooling in the Rust world.

It's relatively easy to extend Python with project like Py03[0] and Maturin[1]. Polars[2] is the perfect example of that. It's not easy to push coworkers/companies to use an unfamiliar language. Rust isn't fast to learn. You need very good arguments and a good usecase to make it works. I doubt that learning Rust will help you more that learning more about the data engineers tools, so this isn't really "worth" your time. [0] -- https://pyo3.rs/v0.18.3/ [1] -- https://github.com/PyO3/maturin [2] -- https://www.pola.rs/

I'm a huge fan of maturin but that might be a bit meta. It's a python build tool for wrapping rust projects. There github page has a list of projects using it and you might find more of what you are looking for: https://github.com/PyO3/maturin#examples

I like how this is a Rust project without any Python, that publishes a package to PyPI. It uses Maturin (https://github.com/PyO3/maturin) for this, which I've never heard of but sounds really useful.

There's an entire ecosystem built up to support this. PyO3 [1] connects Rust to Python, Maturin [2] is a build tool to package Python wheels easily, with a host of popular examples using Maturn + PyO3 [3]. There's even extensions to bind easily to numpy and asyncio [4][5]. [1]: https://github.com/PyO3/pyo3 [2]: https://github.com/PyO3/maturin [3]: https://github.com/PyO3/maturin#examples [4]: https://github.com/PyO3/rust-numpy [5]: https://github.com/awestlake87/pyo3-asyncio

1. The Python code calling the Rust code raises a runtime-related exception, but it doesn't crash the process. 2. Building Python extensions out of PyO3 code is easy with maturin: https://github.com/PyO3/maturin

Between pyodide, pyo3, rust-cpython, and rustpython, I think Pyo3 is the best way to drop in rust in a python project for a speed up, if that is your goal. Some of the demos show using python from rust, but to me the biggest feature is without a doubt compiling rust code to native python modules. I'm using it to speed up image manipulation backed by numpy arrays. There’s a setuptools rust [0] extension package that can be used to hook the compilation of the rust into the wheel building or install from source. Maturin [1] seems to be regarded as the new and improved solution for this, but I found that it’s angled toward the using python from rust. There’s also the rust numpy [2] package by the same org which is fantastic in that it lets you pass a numpy matrix to a native method written in rust and convert it to the rust equivalent data st

With PyO3, I built the library to parse datetimes 10x faster than `datetime.strptime` in just a few lines of code: https://github.com/gukoff/dtparse It just calls the Rust's chrono library that does the parsing and wraps the result in a Python object. You can do it for any Rust library, it's very, very easy! The only slightly complicated part is the distribution. You need to use https://github.com/PyO3/maturin or https://github.com/PyO3/setuptools-rust, and of course, you need to have Rust installed on the wheel-building machine. Feel free to use this repo as a reference if you want to build a similar thing. The code is commented, and there's a working GitHub action that builds the wheels for all platforms and uploads them to PyPi: https://github.com/gukoff/dtparse/tree/master/.github/workfl...

If you're interested in publishing Rust libraries as Python packages (or integrating Rust code into an existing Python package), check out https://github.com/PyO3/maturin and https://github.com/PyO3/setuptools-rust.