codon VS Nuitka

https://github.com/exaloop/codon/blob/develop/LICENSE

Here are some others: https://github.com/search?q=%22Business+Source+License%22+%2...

I found at least one project that managed to compile python AOT to LLVM https://github.com/exaloop/codon. Even if LLVM is more expressive than Dart Kernel, that should at least be some evidence that this might not be too impractical.

Repo for more details: https://github.com/exaloop/codon

> What is Codon?

> Codon is a high-performance Python compiler that compiles Python code to native machine code without any runtime overhead. Typical speedups over Python are on the order of 10-100x or more, on a single thread. Codon's performance is typically on par with (and sometimes better than) that of C/C++. Unlike Python, Codon supports native multithreading, which can lead to speedups many times higher still. Codon grew out of the Seq project.

> What isn't Codon?

> While Codon supports nearly all of Python's syntax, it is not a drop-in replacement, and large codebases might require modifications to be run through the Codon compiler. For example, some of Python's modules are not yet implemented within Codon, and a few of Python's dynamic features are disallowed. The Codon compiler produces detailed error messages to help identify and resolve any incompatibilities.

> Codon can be used within larger Python codebases via the @codon.jit decorator. Plain Python functions and libraries can also be called from within Codon via Python interoperability.

Their fannkuch benchmark seems to be a bit dishonest. They claim an enormous perf delta on https://exaloop.io/benchmarks.html but fannkuch uses factorial a lot and they define factorial with a very small (n=20) table: https://github.com/exaloop/codon/blob/fb461371613049539654c1...

Disclaimer: I've worked on several Python runtimes and compilers, but I'm not by any means out to get Codon. Just happened across this by accident while looking at their inline LLVM, which is neat.

Another "Python with high-performance compiled builds" would be https://github.com/exaloop/codon.

Try Codon? https://github.com/exaloop/codon

nit: 'Python-based' would imply to me that it's written in Python, but it looks like it's mostly C++ & LLVM:

https://github.com/exaloop/codon/tree/develop/codon

This is a good place to mention https://nuitka.net/ which aims to compile python programs into standalone binaries.

For Python, you could make a proper deployment binary using Nuitka (in standalone mode – avoid onefile mode for this). I'm not pretending it's as easy as building a Go executable: you may have to do some manual hacking for more unusual unusual packages, and I don't think you can cross compile. I think a key element you're getting at is that Go executables have very few dependencies on OS packages, but with Python (once you've sorted the actual Python dependencies) you only need the packages used for manylinux [2], which is not too onerous.

[1] https://nuitka.net/

[2] https://peps.python.org/pep-0599/#the-manylinux2014-policy

glee is rich in blogging features but has some drawbacks. One of the main drawbacks is its compatibility with multiple operating systems and system architectures. We lost one potential customer due to glee incompatibility in macOS. Another major issue is the deployment time. We built the first version of glee entirely in Python and used nuitka, nuitka compiles Python programs into a single executable binary file. We need to create three separate stages for creating executable binaries for Windows, Mac, and Linux in deployment, and it takes around 20 minutes to complete.

There is already an AOT compiler for Python: Nuitka[0]. But I don't think it's much faster.

And then there is mypyc[1] which uses mypy's static type annotations but is only slightly faster.

And various other compilers like Numba and Cython that work with specialized dialects of Python to achieve better results, but then it's not quite Python anymore.

[0] https://nuitka.net/

[1] https://github.com/python/mypy/tree/master/mypyc

Nuitka deals pretty well with those in general: https://nuitka.net/

That's more of cultural problem in the Python community.

If I provide an end user software to my client written an Python (so not a backend, not a lib...), I will compile it with nuitka (https://github.com/Nuitka/Nuitka) and hide the stack trace (https://www.bitecode.dev/p/why-and-how-to-hide-the-python-st...) to provide a stand alone executable.

This means the users don't have to know it's made with Python or install anything, and it just works.

However, Python is not like Go or Rust, and providing such an installer requires more than work, so a huge part of the user base (which have a lot of non professional coders) don't have the skill, time or resources to do it.

And few people make the promotion of it.

I should write an article on that because really, nobody wants to setup python just to use a tool.

> Your comment would make sense if Python code could be compiled into x86 or ARM assembly in the first place.

It can actually be compiled (or transpiled) into C code [1] with few limitations, so I can't see why not.

[1] https://github.com/Nuitka/Nuitka

Just for reference,

* Nuitka[0] "is a Python compiler written in Python. It's fully compatible with Python 2.6, 2.7, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10, and 3.11."

* Pypy[1] "is a replacement for CPython" with builtin optimizations such as on the fly JIT compiles.

* Cython[2] "is an optimising static compiler for both the Python programming language and the extended Cython programming language... makes writing C extensions for Python as easy as Python itself."

* Numba[3] "is an open source JIT compiler that translates a subset of Python and NumPy code into fast machine code."

* Pyston[4] "is a performance-optimizing JIT for Python, and is drop-in compatible with ... CPython 3.8.12"

[0] https://github.com/Nuitka/Nuitka

[1] https://www.pypy.org/

[2] https://cython.org/

[3] https://numba.pydata.org/

[4] https://github.com/pyston/pyston