Show HN: Copy-and-patch compiler for hard real-time Python
github.comI built Copapy as an experiment: Can Python be used for hard real-time systems?
Instead of an interpreter or JIT, Copapy builds a computation graph by tracing Python code and uses a custom copy-and-patch compiler. The result is very fast native code with no GC, no syscalls, and no memory allocations at runtime.
The copy-and-patch compiler currently supports x86_64 as well as 32- and 64-bit ARM. It comes as small Python package with no other dependencies - no cross-compiler, nothing except Python.
The current focus is on robotics and control systems in general. This project is early but already usable and easy to try out.
Would love your feedback!
THAT'S INSANE!
I always wondered if this could be possible. Like you fuzz a program, map out each possible allocation and deallocation and optimize the code with those hot paths and some statistics.
Very interesting project, would love some sort of write up on it.
Thanks for your comment, I'll give a full write up a try.
I think for deterministic control applications this concept has a sweet spot. While in conventional code the number of branch combinations can blow up easely, here you need to be able to guarantee worst case execution time which forces you anyway to be very carefull with branching.
On https://copapy.nonan.net/compiler.html is the how-it-works readme section extended with the generated machine code for stencils and a simple example.
Is this what you want? https://en.wikipedia.org/wiki/Profile-guided_optimization
This looks like it could become an excellent alternative in time to not just NumPy and Numba, but also Cython. I know that may be more ambitious than your original intentions, but that's absolutely what sprung to mind.
Impressive stuff but it would be polite to the potentially interested users if the line, "... this package is currently a proof of concept with limited direct use", had been put a little earlier. It's about nine or so dense paragraphs in.
It's fine that it is still in development but it just seems worth being upfront.
> The result is very fast native code with no GC, no syscalls, and no memory allocations at runtime.
I guess, that's only achievable for certain kind of code, already designed with hard real-time in mind. It would be good to have some information about the limitations of this approach.
Try using Nanobind . Even though Python C API is what you aim for Nanobind has smaller binary files than pybind11. It is a reputed project and is deployed in many new libraries. Including mine. Will it work?
How is this different to casadi ?
Casadi uses either an interpreter or emits c-code, where Copapy directly runs machine code. Would be very interesting to benchmark Copapy against compiled Casadi c-code – looking into it.