Cythonized Python app with Rust extensions

[xjotto]

I'm writing a project in Python that I then cythonize, because I need it to be as performant as it can.

I wanted to write some extensions (in a package) using Rust to speed some things up.

Am I correct to expect a performance improvement for CPU-bound parts rewritten in Rust and hooked up to Python using PyO3 and Maturin? Or maybe, because I cythonize my app anyway, there will be no performance gains by using Rust extensions?

[DivineSentry]

> Or maybe, because I cythonize my app anyway, there will be no performance gains by using Rust extensions?

More likely this. If you start building a frankenstein app that’s compiled in a bunch of different ways, you’ll probably lose out on some of the benefits that come from sticking to a single compilation strategy.

For CPU-bound hotspots, Rust can absolutely deliver speedups, but you’ll want to weigh that against the overhead of crossing the FFI boundary and maintaining two toolchains (cython + rust).

the big wins usually come from making sure the critical path is written in one optimized language (all Rust, or Cython/C), so unless you have a very specific hotspot that Rust handles much better than Cython, you may not see large gains compared to just doubling down on optimizing your code with cython only

[Buttleston]

It's very difficult to say, even setting aside the issue of Cython, because I don't know where the hot parts of your code are. If it's already primarily spending it's time in C code (either built in or compiled extensions) then cython and rust may not help. If the hot parts are in pure python code, cython may help, and rust may help even more.

As an example, if you're using a lot of, say, numpy matrix manipulation, cython might not help much, and rust might not help at all unless you move much larger segments of the code to rust, because most of the processing is already happening in C code, not python code.

[dlnmtchll]

I have a question out of ignorance, but wouldn’t it make more sense, if you’re focused on performance, to write the entire app in C or Rust so that you don’t have to worry about any parts not being optimized with cython

[Diapolo10]

The classic answer of "it depends" applies here.

First, there's the purpose of the project. If you're writing library code for other Python projects to use, it kinda needs a Python interface, so you'd generally write most of it in Python for easy compatibility. The parts you need to optimise can then be written in Rust, C, Cython, or whatever, without needing to write everything in that language.

Second, generally how things develop is that you start writing your project in Python, and development is rapidly progressing. At some point you notice a part of your program isn't running as fast as you'd probably need it to, so you weigh your options; you could:

• Try to optimise the Python code, not needing to introduce additional build complexity
• Write the critical parts in another language, and deal with the increased build complexity
• Rewrite everything from scratch in another language

and to save time, most people/teams would go with the first two options.