Pillow

Pillow is the actively maintained fork of the original Python Imaging Library (PIL), giving Python programs the ability to open, manipulate, and save images across dozens of file formats. It exposes an efficient internal pixel representation backed by a C extension (_imaging), so common operations like resizing, cropping, filtering, and color-space conversion run fast even on large images.

Beyond the core Image object, Pillow ships drawing primitives, font rendering, color management (ICC profiles), and format-specific plugins for everything from PNG and JPEG to less common formats like TIFF, WebP, AVIF, and FITS. It has been the de facto standard for image I/O in Python for over a decade and is a dependency of most Python web frameworks, data science stacks, and ML pipelines that touch images.

What You Get

• A unified Image.open()/Image.save() API that reads and writes 30+ image formats (PNG, JPEG, GIF, BMP, TIFF, WebP, AVIF, ICO, PPM, and more) through a plugin architecture
• Pixel-level and region-level operations: crop, resize, rotate, paste, composite, and per-pixel access via load()
• A drawing and typography toolkit (ImageDraw, ImageFont) for rendering shapes and TrueType/OpenType text onto images
• A filter and enhancement pipeline (ImageFilter, ImageEnhance, ImageOps) for blurring, sharpening, contrast, and color adjustments
• ICC color-management support (ImageCms) and color-space conversions (RGB, CMYK, LAB, grayscale, palette)
• A C-accelerated core (libImaging) so hot-path operations like decode/resize/composite avoid pure-Python overhead

Common Use Cases

• Generating and resizing thumbnails or responsive image variants in a Django/Flask web app
• Preprocessing images (resize, normalize, convert to arrays) before feeding them into a PyTorch or scikit-learn pipeline
• Batch format conversion and metadata (EXIF) extraction for a photo-management or asset pipeline
• Server-side generation of OG images, watermarks, or dynamically composed graphics
• Reading and validating uploaded images (format sniffing, decompression-bomb protection) in an API backend

Under The Hood

Architecture — Pillow’s design centers on the Image class in src/PIL/Image.py (roughly 4,300 lines), which acts as a thin, lazily-evaluating Python wrapper around a C-level image buffer. File-format support is implemented as a plugin system: each of the ~90 *ImagePlugin.py modules registers itself with the core Image module and provides format-specific decode/encode logic, so adding or excluding a format is a matter of importing (or not) that plugin. The performance-critical inner loop — pixel decoding, resampling, geometric transforms, compositing — lives in src/libImaging/ (roughly 90 C source/header files) and src/_imaging.c, exposed to Python via a hand-written C extension rather than a wrapper generator like SWIG or Cython. Optional native codecs (AVIF, WebP, FreeType-based font rendering, LittleCMS color management, morphology) are separate C extension modules (_avif.c, _webp.c, _imagingft.c, _imagingcms.c, _imagingmorph.c) built conditionally depending on which system libraries are available at install time.

Tech Stack — The Python surface targets 3.11+ and is built with a custom PEP 517 backend (_custom_build/backend.py) on top of setuptools, because Pillow needs to detect and link against system imaging libraries (libjpeg, zlib, libtiff, libwebp, OpenJPEG, LittleCMS, FreeType, raqm) at build time rather than relying on pure-Python packaging. Wheels are built via cibuildwheel across Linux/macOS/Windows with vendored or system dependencies depending on platform, which is why pip install pillow works without a local C toolchain. pybind11 is used for parts of the extension glue.

Code Quality — The Tests/ directory contains 175+ test files exercising individual format plugins, drawing operations, color conversions, and known CVE regressions (e.g. test_decompression_bomb.py), run via pytest with coverage tracking (pytest-cov) and parallelization (pytest-xdist). The project enforces mypy --strict-style settings (disallow_untyped_defs, disallow_any_generics) on the Python layer, ruff and black for linting/formatting, and bandit for security scanning of src/, all wired into pre-commit hooks. Fuzz testing against OSS-Fuzz (Tests/oss-fuzz/) is used to catch memory-safety issues in the C decoders, which is notable given the historical CVE surface of image-parsing libraries.

API Design — The library optimizes for a low-boilerplate happy path — Image.open(path) followed by chained method calls (.resize().convert().save()) — while still surfacing format-specific metadata (EXIF, ICC profiles, animation frames) through consistent attribute and method names across otherwise very different file formats. Method and module naming is stable across more than a decade of releases, which is part of why Pillow remains a safe default dependency: code written against PIL/Pillow in the 2.x era largely still runs.