Python is a popular programming language known for its simplicity and versatility. However, it can sometimes be slow because it’s an interpreted language. Just-in-time (JIT) compilation is a technique that can make Python programs run faster by translating code into machine language on the fly. Recently, Python has started to include its own native JIT compiler, which is a big step forward for performance improvements.

Getting Started with Python’s Built-in JIT

Until now, using JIT with Python meant relying on third-party tools like Numba or switching to alternative interpreters such as PyPy. But with the latest versions, specifically Python 3.15, a native JIT compiler has been added directly into the language. Early on, it didn’t offer much speed boost, but recent updates show promising results, especially in certain types of programs.

The performance gains from the JIT vary depending on what the code is doing. Some programs see dramatic improvements, while others might not notice much difference. Still, the effort to develop this feature is paying off, and users willing to experiment can start to benefit from faster execution times.

Enabling the Python JIT

Since the native JIT is still considered experimental, it’s not enabled by default. To turn it on, you need to set an environment variable called PYTHON_JIT. This can be done temporarily for a shell session or permanently in your system’s environment settings. When you start Python, it checks if PYTHON_JIT is set to 1. If it is, the JIT is activated; if not, it remains disabled.

Most users probably shouldn’t enable the JIT permanently, especially since it’s still experimental. Instead, it’s better to toggle it as needed, maybe within a script or a specific session to test performance. This way, you can compare run times with and without the JIT and see if it’s helping your code.

Checking if the JIT is Working

In Python 3.13 and newer, the standard library includes a new module called sys._jit. This module provides three simple functions to check the status of the JIT. The first, sys._jit.is_available(), tells you if your Python build includes the JIT feature—most binary distributions do, except some special builds without the Global Interpreter Lock (GIL).

The second function, sys._jit.is_enabled(), shows whether the JIT is currently turned on. However, it doesn’t confirm if code is actually being compiled with the JIT at any moment. The third, sys._jit.is_active(), indicates if the top part of the code is currently running JIT-compiled code. But this isn’t the most reliable way to measure JIT usage, so performance testing is recommended.

Overall, the most useful check is sys._jit.is_enabled(). It helps you confirm whether the JIT is available and active, making it easier to experiment and optimize your Python programs.

While the native JIT in Python is still evolving, it shows great potential for speeding up Python code. By enabling it thoughtfully and testing performance, developers can take advantage of these new capabilities and write faster programs in the future.

Inspired by

• https://www.infoworld.com/article/4110565/get-started-with-pythons-new-native-jit.html

Sources

• python.org
• python.org