Accelerating Python with Numba: JIT Compilation, Decorators, and GPU Support

Numba is a just‑in‑time (JIT) compiler for Python that transforms functions into optimized machine code, allowing them to run at native speed and supporting NumPy and many standard library functions.

Choosing Numba over other compilers like Cython or PyPy lets you stay within pure Python code, simply adding a @jit decorator to functions without rewriting or typing them.

Basic usage involves importing the decorator and applying it to a function:

<code>from numba import jit
@jit

def function(x):
    # your loop or numerically intensive computations
    return x
</code>

For best performance, use nopython=True or the shortcut @njit , which forces compilation without the Python interpreter.

Numba also offers additional decorators such as @vectorize, @guvectorize, @stencil, @jitclass, @cfunc, and @overload, enabling features like NumPy ufuncs, GPU execution, and custom overloads.

When targeting GPUs, import cuda from Numba and define kernel functions with @cuda.jit . Kernel functions must declare their thread and block dimensions and operate on device arrays.

<code>from numba import cuda
@cuda.jit
def func(a, result):
    # GPU‑related computation
    pass
</code>

Launch kernels by specifying grid and block sizes, e.g., threadsperblock = 32 , blockspergrid = (array.size + (threadsperblock - 1)) // threadsperblock , then call func[blockspergrid, threadsperblock](array) .

Numba provides utilities like numba.cuda.device_array , device_array_like , and to_device to minimize data transfer overhead between host and device.

Other advanced features include support for CFFI and ctypes in nopython mode, atomic operations, random number generators, and shared memory on the GPU.

Overall, Numba enables rapid acceleration of Python code on both CPUs and GPUs with minimal code changes, offering caching, parallel execution, and a rich set of decorators for scientific and performance‑critical workloads.