A C compiler written in pure Python.

import numpy as np
import cimo

k = cimo.compile(r"""
void blur(int h, int w, const float src[h][w], float dst[h][w]) {
    for (int i = 1; i < h - 1; i++)
        for (int j = 1; j < w - 1; j++)
            dst[i][j] = 0.2f * (src[i][j] + src[i-1][j] + src[i+1][j]
                                          + src[i][j-1] + src[i][j+1]);
}
""")

src = np.random.rand(4096, 4096).astype(np.float32)
dst = np.zeros_like(src)
k.blur(*src.shape, src, dst)   # native code, on your arrays in place

# numpy: the same result, bit for bit, 1.6x slower (Linux arm64)
ref = np.zeros_like(src)
ref[1:-1, 1:-1] = 0.2 * (src[1:-1, 1:-1] + src[:-2, 1:-1] + src[2:, 1:-1]
                              + src[1:-1, :-2] + src[1:-1, 2:])
assert np.array_equal(dst, ref)

import numpy as np, cimo

k = cimo.compile(r"""
void blur(int h, int w,
          const float src[h][w],
          float dst[h][w]) {
  for (int i = 1; i < h - 1; i++)
    for (int j = 1; j < w - 1; j++)
      dst[i][j] = 0.2f * (src[i][j]
        + src[i-1][j] + src[i+1][j]
        + src[i][j-1] + src[i][j+1]);
}
""")

src = np.random.rand(4096, 4096)
src = src.astype(np.float32)
dst = np.zeros_like(src)
k.blur(*src.shape, src, dst)  # in place

# numpy: same bits, 1.6x slower

import numpy as np, cimo
x = np.random.rand(1_000_000)
y = np.empty_like(x)

k = cimo.compile(r"""
void ema(int n, const double x[n], double y[n], double a) {
    y[0] = x[0];
    for (int i = 1; i < n; i++)
        y[i] = a * x[i] + (1 - a) * y[i-1];
}
""")

%timeit k.ema(len(x), x, y, 0.1)

3.43 ms ± 22.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

def ema_py(x, y, a):
    y[0] = x[0]
    for i in range(1, len(x)):
        y[i] = a * x[i] + (1 - a) * y[i-1]
%timeit ema_py(x, y, 0.1)

252 ms ± 2.36 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

import numpy as np, cimo
x = np.random.rand(1_000_000)
y = np.empty_like(x)

k = cimo.compile(r"""
void ema(int n, const double x[n],
         double y[n], double a) {
  y[0] = x[0];
  for (int i = 1; i < n; i++)
    y[i] = a*x[i] + (1-a)*y[i-1];
}
""")

%timeit k.ema(len(x), x, y, 0.1)

3.43 ms ± 22.7 µs per loop

def ema_py(x, y, a):
  y[0] = x[0]
  for i in range(1, len(x)):
    y[i] = a*x[i] + (1-a)*y[i-1]
%timeit ema_py(x, y, 0.1)

252 ms ± 2.36 ms per loop

Docs: your first kernel →

Native code at runtime, without a toolchain

Compute-graph engines, PDE solvers and symbolic code generators emit C at runtime and call the system compiler on the user's machine. Where there is none, they fail or fall back to slow paths. Numba avoids the compiler by bundling LLVM. cimo is a compiler written in Python: any machine that runs Python can compile and run C.

Close to gcc and clang at -O3

cimo has a loop optimizer and a full instruction-selecting backend rather than a one-pass code generator.

$ cimo report kernels.ckernels.c:12  loop j: optimized (unrolled x4, alias check src/dst)kernels.c:19  loop i,j: optimized (unroll-and-jam 2x4, scalar replacement)kernels.c:27  loop k: optimized (strength reduction, 3 loads hoisted)kernels.c:31  loop i: not optimized: base of `p` depends on a branchkernels.c:38  loop t: not optimized: y[t] depends on y[t-1]kernels.c:44  loop n: not optimized: calls `next_sample` (not inlined)3 of 6 loops optimized$ 

Docs: measuring and profiling your kernels →

C11 and a bundled C library

cimo ships its own libc, so kernels behave the same on every platform, including the browser.

k = cimo.compile(src, link=["libc"], host_headers=True)
k = cimo.compile(src, link=["libz.so.1"])
k = cimo.load("kernels.c")   # or keep kernels in a file

Docs: the C you can use →

Threads and error handling

from concurrent.futures import ThreadPoolExecutor

n = 16
with ThreadPoolExecutor() as pool:
    list(pool.map(lambda b: k.blur(b, n, h, w, src, dst), range(n)))

k.blur(*src.shape, src, dst)
cimo.BoundsError: blur: read of src[4096][1] is out of bounds (src is 4096 x 4096)
  at line 5

Docs: threads and the heap → · errors →

Train a network you draw

In Pyodide, JupyterLite and marimo, cimo compiles C to WebAssembly in the page and links it into Pyodide's memory. Here that runs a small deep-learning stack: draw a network, Python turns it into C for its forward and backward passes, cimo compiles the C, and it trains in your browser.

In a notebook: await micropip.install("cimo"), then cimo.compile(src) as anywhere else. The code generator is one Python file.

Docs: cimo in the browser →

Supported platforms

Kernels run with the full privileges of your Python process, like ctypes. There is no sandbox.

Docs: platforms and how code is loaded →

Architecture

One kernel through every stage of the compiler. This is cimo's real output for it, regenerated from the compiler.

cproc and QBE are ported to Python and checked against the originals by diffing their IR pass by pass. The loop optimizer and machine-code encoder are new. Every release is differential-tested against gcc and clang on generated random programs.