Pillow-AllSIMD

Pillow 13, 6.3× as fast on x86-64 and 3.3× as fast on arm64, as the geometric mean of 111 operations on one thread (5.6× and 2.7× with Pillow's exact arithmetic). That is 3.0× as fast as Pillow-SIMD, and faster than OpenCV in 77 of the 104 operations both have on x86-64, 69 on arm64.

A drop-in replacement for Pillow 13.0.0: it installs the same PIL package, with the same API, built with SIMD kernels for x86-64 (SSE4.1, AVX2, AVX-VNNI) and arm64 (NEON). Your code doesn't change.

python3 -m pip uninstall -y pillow pillow-simd
python3 -m pip install pillow-allsimd

It is a fork of Pillow-SIMD, which brought SIMD to Pillow on x86:

	Pillow-AllSIMD	Pillow-SIMD 12.1.1
Based on	Pillow 13.0.0	Pillow 12.1.1
x86-64	SSE4.1, AVX2 and AVX-VNNI kernels, the best set chosen at import	SSE4 or AVX2, chosen when it is built
arm64	NEON kernels (Linux, macOS)	does not build (-msse4)
Other CPUs	portable C (riscv64, ppc64le, s390x, armv7)	does not build
Wheels on PyPI	Linux x86-64 and arm64, macOS arm64; CPython 3.11 to 3.15 and free-threaded	none: compiled when installed

How the speed was found, and what didn't work: Six times Pillow: notes from Pillow-AllSIMD.

For Pillow itself, please refer to its documentation, changelog and contribution guide.

Aim

• SIMD on every common CPU. Pillow-SIMD targets x86; Pillow-AllSIMD carries its kernels further on x86-64 (SSE4, AVX2, AVX-VNNI) and ports them to arm64 (NEON), with portable C that compilers vectorize elsewhere.
• Fast by default. Some operations use fast kernels whose results differ from Pillow's by a few documented levels at most, the same on every build and architecture.
• Pillow's results when asked. In exact mode the operations follow Pillow's arithmetic, or an integer form of it that rounds differently by a level or two in a few places, and every SIMD kernel is checked against the scalar code on every build.
• Following Pillow. Each Pillow release is merged, and changes that suit Pillow-SIMD are offered to it.

State

• Version 13.0.0.post4, on Pillow 13.0.0 (the simd/pillow-13 branch).
• Beta. On PyPI as wheels for Linux on x86-64 and arm64 and for macOS 11 or later on Apple silicon, and as a source package, compiled on installation, everywhere else (below).
• Tested on x86-64 (Intel Core Ultra 9 285H) and arm64 (NVIDIA Jetson Orin): Pillow's test suite on every build (scalar, SSE4, AVX2, NEON), the SIMD consistency tests and per-kernel output hashes that compare the builds (checks/simd_hashes.py). The portable build also passes the suite on riscv64, ppc64le, s390x, armv7 and 32-bit x86, under QEMU (OTHER_ARCHITECTURES.md).
• API documentation (Pillow's, with this fork's additions) and benchmarks against Pillow, Pillow-SIMD, OpenCV, libvips and ImageMagick.

Credits

Pillow-AllSIMD stands on the work of others, and keeps their copyright notices (LICENSE):

• PIL, the Python Imaging Library, by Fredrik Lundh and contributors (Secret Labs AB, 1995-2011).
• Pillow, the friendly PIL fork, by Jeffrey 'Alex' Clark and contributors (2010-): the library as a whole, its tests and its documentation, from which this fork's documentation is built.
• Pillow-SIMD, by Alexander Karpinsky and contributors, supported by Uploadcare, which has run it in production since 2015: the SIMD resampling, blur, filter, conversion and composition kernels for x86 that this fork starts from, and the idea of a drop-in SIMD build.

Pillow-AllSIMD's own changes are by Matteo Ferrabone and contributors. To cite it, see CITATION.cff, which also cites Pillow and Pillow-SIMD.

Why SIMD

(From Pillow-SIMD's readme, like the "why" sections further down.)

There are multiple ways to tweak image processing performance. To name a few, such ways can be: utilizing better algorithms, optimizing existing implementations, using more processing power and/or resources. One of the great examples of using a more efficient algorithm is replacing a convolution-based Gaussian blur with a sequential-box one.

Such examples are rather rare, though. It is also known, that certain processes might be optimized by using parallel processing to run the respective routines. But a more practical key to optimizations might be making things work faster using the resources at hand. For instance, SIMD computing might be the case.

This is the beginning of the README. Read the rest at the original. Read the full README ↗