RustPython · youknowone · Aug 24, 2026 · Aug 24, 2026 · Aug 24, 2026 · Aug 24, 2026
diff --git a/.cspell.dict/rust-more.txt b/.cspell.dict/rust-more.txt
@@ -20,6 +20,7 @@ cstring
 datelike
 deserializer
 deserializers
+fcmp
 fdiv
 flamescope
 flate2
@@ -28,6 +29,8 @@ getres
 hasher
 hexf
 hexversion
+iabs
+iconst
 idents
 illumos
 ilog
@@ -79,6 +82,7 @@ thiserror
 timelike
 timsort
 trai
+uextend
 ulonglong
 unic
 unistd

diff --git a/.cspell.json b/.cspell.json
@@ -82,6 +82,7 @@
     "deduped",
     "deoptimized",
     "deoptimize",
+    "deoptimizes",
     "emscripten",
     "excs",
     "fdigits",

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
@@ -147,6 +147,26 @@ jobs:
         run: cargo build --locked --no-default-features --features ssl-openssl-vendor
         if: runner.os == 'Linux'
 
+      # Automatic compilation must not change what a program does, so the
+      # snippet has to pass identically with it on and off.
+      - name: Test aot build
+        run: |
+          cargo build --locked --features aot
+          target/debug/rustpython -X aot=1 extra_tests/snippets/aot.py
+          target/debug/rustpython -X aot=0 extra_tests/snippets/aot.py
+          target/debug/rustpython -X aot=1 extra_tests/snippets/jit.py
+        if: runner.os == 'Linux'
+
+      # The snippets cover arithmetic. These cover the rest of what the
+      # automatic call path moves through: frames, tracebacks, tracing, and
+      # the threads that have to be able to leave a compiled loop.
+      - name: Test aot against the CPython suite
+        run: |
+          target/debug/rustpython -X aot=1 -m test \
+            test_sys test_traceback test_sys_settrace test_monitoring \
+            test_bdb test_trace test_exceptions test_generators test_threading
+        if: runner.os == 'Linux'
+
       # - name: Install tk-dev for tkinter build
       #   run: sudo apt-get update && sudo apt-get install -y tk-dev
       #   if: runner.os == 'Linux'

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -20,6 +20,7 @@ stdlib = ["rustpython-stdlib", "rustpython-pylib", "encodings"]
 flame-it = ["rustpython-vm/flame-it", "rustpython-stdlib/flame-it", "flame", "flamescope"]
 freeze-stdlib = ["stdlib", "rustpython-vm/freeze-stdlib", "rustpython-pylib?/freeze-stdlib"]
 jit = ["rustpython-vm/jit"]
+aot = ["rustpython-vm/aot"]
 threading = ["rustpython-vm/threading", "rustpython-stdlib/threading"]
 sqlite = ["rustpython-stdlib/sqlite"]
 ssl = ["host_env"]

diff --git a/README.md b/README.md
@@ -145,21 +145,70 @@ cargo build --release --target wasm32-wasip1 --features="freeze-stdlib"
 
 ### JIT (Just in time) compiler
 
-RustPython has a **very** experimental JIT compiler that compile python functions into native code.
+RustPython has a **very** experimental JIT compiler that compiles python functions into native code.
+It comes in two forms: an automatic one that compiles a function once it has been called
+often enough to be worth it, and an explicit `__jit__()` that compiles the one function
+it is called on.
 
 #### Building
 
-By default the JIT compiler isn't enabled, it's enabled with the `jit` cargo feature.
+Neither is built by default.
 
 ```bash
-cargo run --features jit
+cargo run --features aot   # automatic, and the explicit one with it
+cargo run --features jit   # explicit `__jit__()` alone
 ```
 
 This requires autoconf, automake, libtool, and clang to be installed.
 
-#### Using
+#### Using the automatic compiler
 
-To compile a function, call `__jit__()` on it.
+A build that has it still has to be switched on, with `-X aot=1`, `RUSTPYTHON_AOT=1`
+or `PYTHON_JIT=1`; `-X aot=0` and `=0` switch it back off. A function is then counted
+as it is called and offered to the compiler once it has been called enough times to
+repay one. The attempt happens once, so a function it turns down costs that one
+attempt and is interpreted from then on; a function called only a handful of times
+is never offered at all.
+
+`sys._jit.is_available()` reports whether the compiler was built in, `is_enabled()`
+whether it is switched on, and `_stats()` returns `(compiled, rejected, deoptimized)`
+for the functions it has looked at so far — a RustPython extension.
+
+#### What it compiles
+
+Scalar functions, and nothing else. The two forms differ in where the types come
+from: `__jit__()` reads them off the annotations, and turns down a function without
+them; the automatic path takes them from the arguments of the call that made the
+function warm, so an unannotated function compiles as readily as an annotated one.
+Nothing about that reads a `__annotations__` or runs an `__annotate__`.
+
+A guess about types is a guess: a later call whose arguments do not fit the compiled
+signature is run by the interpreter instead.
+
+Taken: `int`, `float` and `bool` arguments, locals and return values; arithmetic,
+comparison and boolean operators; `if`, `while`, and the assignments between them.
+
+Turned down: arguments of any other type, `*args`/`**kwargs`, closures, generators
+and coroutines, `try`/`except`, attributes and methods, containers, `for`, calls to
+anything but the function itself, and expressions that merge with an operand still
+on the stack, such as a conditional expression. A call a function makes to itself
+is compiled only by `__jit__()`; the automatic path turns those down too, because
+the global it goes through can be rebound between one call and the next.
+
+Where a machine word runs out — an overflow, a division by zero, a shift past the
+width, a power with no real answer — the compiled code hands the frame back at the
+instruction it could not do, with the values it had, and the interpreter carries on
+from there. The native code is dropped at that point, and the function is
+interpreted afterwards.
+
+Compiled code runs with no python frame. That is why `sys._jit.is_active()` is
+always `False`, why such a call reports no line and no return to `sys.settrace` or
+`sys.monitoring`, and why a call is interpreted, and left uncompiled, while either
+of those is installed.
+
+#### Using `__jit__()`
+
+To compile a single function, call `__jit__()` on it. This needs only the `jit` feature.
 
 ```python
 def foo():

diff --git a/crates/capi/src/pyframe.rs b/crates/capi/src/pyframe.rs
@@ -14,8 +14,8 @@ pub unsafe extern "C" fn PyFrame_GetCode(frame: *mut PyFrameObject) -> *mut PyCo
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn PyFrame_GetLineNumber(frame: *mut PyFrameObject) -> c_int {
-    with_vm(|_vm| {
-        let lineno = unsafe { &*frame }.f_lineno();
+    with_vm(|vm| {
+        let lineno = unsafe { &*frame }.f_lineno(vm);
         Ok(lineno.try_into().unwrap_or(c_int::MAX))
     })
 }
diff --git a/crates/common/src/int.rs b/crates/common/src/int.rs
@@ -5,6 +5,13 @@ use num_traits::{One, ToPrimitive, Zero};
 
 #[must_use]
 pub fn true_div(numerator: &BigInt, denominator: &BigInt) -> f64 {
+    // A rational carries no signed zero, so `0 / -1` would round to `0.0`. A
+    // quotient of two differently signed operands is negative down to and
+    // including its zero, and only an exactly zero numerator loses that here:
+    // a quotient too small to represent still rounds to `-0.0` on its own.
+    if numerator.is_zero() && denominator.sign() == Sign::Minus {
+        return -0.0;
+    }
     let rational = Rational::from_integers_ref(numerator.into(), denominator.into());
     match rational.rounding_into(RoundingMode::Nearest) {
         // returned value is $t::MAX but still less than the original

diff --git a/crates/jit/Cargo.toml b/crates/jit/Cargo.toml
@@ -15,7 +15,6 @@ rustpython-compiler-core = { workspace = true }
 
 num-traits = { workspace = true }
 thiserror = { workspace = true }
-libffi = { workspace = true }
 
 cranelift = { workspace = true }
 cranelift-jit = { workspace = true }