To help you get started, we've collected the most common ways that llvmlite is being used within popular public projects.

diana-hep / oamap / oamap / compiler.py View on Github

def arrayitem(context, builder, idx, ptrs, lens, at, dtype):
        offset = builder.mul(idx, literal_int64(numba.types.intp.bitwidth // 8))

        ptrposition = builder.inttoptr(
            builder.add(builder.ptrtoint(ptrs, llvmlite.llvmpy.core.Type.int(numba.types.intp.bitwidth)), offset),
            llvmlite.llvmpy.core.Type.pointer(context.get_value_type(numba.types.intp)))

        lenposition = builder.inttoptr(
            builder.add(builder.ptrtoint(lens, llvmlite.llvmpy.core.Type.int(numba.types.intp.bitwidth)), offset),
            llvmlite.llvmpy.core.Type.pointer(context.get_value_type(numba.types.intp)))

        ptr = numba.targets.arrayobj.load_item(context, builder, numba.types.intp[:], ptrposition)
        len = numba.targets.arrayobj.load_item(context, builder, numba.types.intp[:], lenposition)

        raise_exception(context, builder, builder.icmp_unsigned(">=", at, len), RuntimeError("array index out of range"))

        finalptr = builder.inttoptr(
            builder.add(ptr, builder.mul(at, literal_int64(dtype.itemsize))),
            llvmlite.llvmpy.core.Type.pointer(context.get_value_type(numba.from_dtype(dtype))))

        return numba.targets.arrayobj.load_item(context, builder, numba.from_dtype(dtype)[:], finalptr)

View more ways to use llvmlite

llvmlite

A Lightweight LLVM Python Binding for Writing JIT Compilers

llvmlite is a project originally tailored for Numba's needs, using the following approach:

• A small C wrapper around the parts of the LLVM C++ API we need that are not already exposed by the LLVM C API.
• A ctypes Python wrapper around the C API.
• A pure Python implementation of the subset of the LLVM IR builder that we need for Numba.

Why llvmlite

The old llvmpy binding exposes a lot of LLVM APIs but the mapping of C++-style memory management to Python is error prone. Numba and many JIT compilers do not need a full LLVM API. Only the IR builder, optimizer, and JIT compiler APIs are necessary.

Key Benefits

• The IR builder is pure Python code and decoupled from LLVM's frequently-changing C++ APIs.
• Materializing a LLVM module calls LLVM's IR parser which provides better error messages than step-by-step IR building through the C++ API (no more segfaults or process aborts).
• Most of llvmlite uses the LLVM C API which is small but very stable (low maintenance when changing LLVM version).
• The binding is not a Python C-extension, but a plain DLL accessed using ctypes (no need to wrestle with Python's compiler requirements and C++ 11 compatibility).
• The Python binding layer has sane memory management.
• llvmlite is faster than llvmpy thanks to a much simpler architecture (the Numba test suite is twice faster than it was).

Compatibility

llvmlite has been tested with Python 3.10 -- 3.13 and is likely to work with greater versions.

As of version 0.45.0, llvmlite requires LLVM 20.x.x on all architectures

Historical compatibility table:

Documentation

You'll find the documentation at

Pre-built binaries

We recommend you use the binaries provided by the Numba team for the Conda package manager. You can find them in Numba's anaconda.org channel. For example:

$ conda install --channel=numba llvmlite

(or, simply, the official llvmlite package provided in the Anaconda distribution)

Other build methods

If you don't want to use our pre-built packages, you can compile and install llvmlite yourself. The documentation will teach you how: