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.

여기까지가 README 앞부분입니다. 나머지는 원문에서 읽을 수 있습니다. README 전문 보기 ↗