On another note, I'm working on a (big) PEP for python, and looking for maintainers and sponsors (as per python's rules). Do someone know where I could find such amazing persons? (I already have the code, works in cython,graalVM and pypy, and it's kind of a big change but I believe it will help a lot the language)

There are times that it generates faster code than Cython! Of course with Cython you can tweak it and push its limits with various optimizations and other techniques, but for using your existing code as it is and gain massive performance improvements, mypyc it's a must!

Code sample:

    import time

    def fib(n: int) -> int:
        if n <= 1:
            return n
        else:
            return fib(n-2) + fib(n-1)


    startTime = time.time()
    fib(35)
    duration = time.time() - startTime
    msduration = duration * 1000.0
    uduration = msduration * 1000.0
    print(f'{duration:.6f} seconds, {msduration:.2f} ms, {uduration:.2f} μs')


    $ python3 mypyfib.py 
    1.452477 seconds, 1452.48 ms, 1452477.22 μs

    $ # the same code compiled with `mypyc mypyfib.py` produces the following:
    $ python3 -c "import mypyfib"
    0.063701 seconds, 63.70 ms, 63700.91 μs

       95.61% reduction in time
     2180.15% increase in performance
       22.80x faster

  https://github.com/py2many/py2many
  https://github.com/adsharma/fquery/blob/main/tests/django_example_model.py

Objective-Smalltalk runs on the Objective-C runtime, so Objective-Smalltalk methods look like Objective-C methods accessed via objc_msgSend() to the entire rest of the system, including to other Objective-Smalltalk code.

That means it doesn't really matter to the rest of the system if any particular method is interpreted, AOT-compiled or JIT-compiled. They can't tell, except for execution speed.

And of course the execution model includes machine primitives, which the interpreter also deals with but doesn't make faster, but the native compilers do.