What does HackerNews think of mypyc?

Compile type annotated Python to fast C extensions

#7 in Compiler
#24 in Python
#3 in TypeScript
Writing Python like it's Rust | May 2023
Expand Context ↕
That would be interesting! You might already be aware. But there's mypyc[0], which is an AOT compiler for Python code with type hints (that, IIRC, mypy uses to compile itself into a native extension).

Wanted to give you a head-start on the lit-review for your students I guess :)

[0] https://github.com/mypyc/mypyc
Codon: Python Compiler | May 2023
While we’re at it:

* Mypyc [0] “compiles Python modules to C extensions. It uses standard Python type hints to generate fast code. Mypyc uses mypy to perform type checking and type inference.

Mypyc can compile anything from one module to an entire codebase. The mypy project has been using mypyc to compile mypy since 2019, giving it a 4x performance boost over regular Python.”

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

The different uses of Python type hints | Apr 2023
Expand Context ↕
mypyc does that: https://github.com/mypyc/mypyc

> Mypyc compiles Python modules to C extensions. It uses standard Python type hints to generate fast code. Mypyc uses mypy to perform type checking and type inference.

> Mypyc can compile anything from one module to an entire codebase. The mypy project has been using mypyc to compile mypy since 2019, giving it a 4x performance boost over regular Python.

I have not experience a 4x boost, rather between 1.5x and 2x. I guess it depends on the code.
The Python Paradox | Jan 2023
Funny how emergence works with tools. Give a language too few tools but viral circumstances - the ecosystem diverges (Lisps, Javascript). Give it too long an iteration time but killer guarantees, you end up with committees. Python not falling into either of these traps should be understood as nothing short of magic in emergence.

I only recently discovered that python's reference typechecker, mypy, has a small side project for typed python to emit C [1], written entirely in python. Nowadays with python's rich specializer ecosystem (LLVM, CUDA, and just generally vectorized math), the value of writing a small program in anything else diminishes quickly.

Imagine reading the C++wg release notes in the same mood that you would the python release notes.

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

Codon: A high-performance Python compiler using LLVM | Dec 2022
What's the difference with mypyc [0] ? It also compiles Python to native code.

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

Python 3.11 vs 3.10 performance | Jul 2022
Expand Context ↕
https://github.com/mypyc/mypyc

> Mypyc compiles Python modules to C extensions. It uses standard Python type hints to generate fast code. Mypyc uses mypy to perform type checking and type inference.
Python compiler written in Python to make standalone executables | Jun 2021
Expand Context ↕
Speaking of speedup and program analysis, there's also mypyc[0] which relies on type annotations and also claims a performance boost:

> The mypy project has been using mypyc to compile mypy since 2019, giving it a 4x performance boost over regular Python.

Does anyone know how mypyc and Nuitka compare in practice?

[0]: https://github.com/mypyc/mypyc
Python at Scale: Strict Modules | Oct 2019
Expand Context ↕
Answered this below:

> I've been tracking nim, and would agree it's the most promising so far! I feel though that it's trying to be too flexible in many ways. Examples of this include allowing multiple different garbage collectors and encouraging heavy ast manipulation. I'm also afraid it is different enough to keep it from attracting a significant amount of developers from the Python community. Nonetheless, it's something I plan on using and contributing to, since it's the best option so far.

Though, now that another commenter pointed out mypyc: https://github.com/mypyc/mypyc I believe I'll invest my limited free-time in that project instead, as it will allow me to stay within the Python community and eco-system that I love so much.
Types will be part of Ruby 3 stdlib source | Apr 2019
Expand Context ↕
It's because PyPy relies on traced runtime statistics for optimizations via inlining. There's another approach where you translate your typed program into a lower-level target language and compile it into a native binary. See https://github.com/mypyc/mypyc and https://github.com/cython/cython/wiki/Python-Typing-Proposal
On Learning Rust and Go: Migrating Away from Python | Mar 2019
Expand Context ↕
As someone who works full time in Python and TypeScript, I find the typing experience quite similar in both languages. You can be "productive" in both languages "in medium-to-large-sized projects".

> Mypy mostly seems immature, buggy ...

That was my experience some time ago as well, but it's getting better from release to release. Look at the repo [0], it's continuously improving. I find Mypy deserves more recognition.

The same guys working on mypyc [1], which I think is very interesting too.

[0]: https://github.com/python/mypy/graphs/contributors [1]: https://github.com/mypyc/mypyc
On Learning Rust and Go: Migrating Away from Python | Mar 2019
Expand Context ↕
It's already being done: https://github.com/mypyc/mypyc
Outperforming everything with anything: Python? Sure, why not? | Jan 2019
Expand Context ↕
No, but there's also mypyc if you're interested in that area: https://github.com/mypyc/mypyc
Julia Language Co-Creators Win James H. Wilkinson Prize for Numerical Software | Jan 2019
Expand Context ↕
Pypy is basically abandoned project. Main version is Python2 and It has poor support for python 3. The latest version They are supporting is python3.5. Beside that even with Pypy they wouldn't be even close to nodejs. Julia is on par with Fortran or C. Reason behind Julia amazing performance is its type system. e.g multiple dispatch and value types. Python lakes both. Python also has parallelism problem with GIL. Mypy team currently works on compiler based on static type annotation: https://github.com/mypyc/mypyc I think they could gain much more performance than Pypy.