PHPackages                             usernamn0tavailable/crabmagick - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Image & Media](/categories/media)
4. /
5. usernamn0tavailable/crabmagick

ActiveLibrary[Image & Media](/categories/media)

usernamn0tavailable/crabmagick
==============================

Pure-Rust image processing for PHP — zero config. A CrabMagick daemon is spawned automatically on first use. No php.ini changes, no sudo, just composer require.

11

Since Jul 11Compare

[ Source](https://github.com/UsernameN0tAvailable/crabmagick)[ Packagist](https://packagist.org/packages/usernamn0tavailable/crabmagick)[ RSS](/packages/usernamn0tavailable-crabmagick/feed)WikiDiscussions Synced 1w ago

READMEChangelog (3)DependenciesVersions (4)Used By (0)

CrabMagick
==========

[](#crabmagick)

Pure-Rust image processing for PHP. Zero C dependencies, no libvips, no libjxl.

Two install modes — same `\CrabMagick\Image` API either way:

ModeInstallPerformance**Daemon** (zero config)`composer require usernamn0tavailable/crabmagick`~0.3 ms socket overhead**Extension** (optional)composer require + `PHP_INI_SCAN_DIR`zero overhead, in-processThe extension is auto-detected at runtime. If loaded, it is used directly. If not, the bundled daemon binary is spawned automatically.

---

Why crabmagick instead of libvips?
----------------------------------

[](#why-crabmagick-instead-of-libvips)

### 1. Zero setup — it just works

[](#1-zero-setup--it-just-works)

With libvips you need system packages on every server, container, and dev machine:

```
# libvips approach — requires root, distro-specific, version drift
apt-get install libvips-dev libwebp-dev libjxl-dev libaom-dev ...
pecl install vips
```

With crabmagick:

```
composer require usernamn0tavailable/crabmagick
```

That's it. The pre-built Rust binary is bundled in the Composer package. No apt, no pecl, no root access, no OS packages to maintain or pin. Works identically on Ubuntu, Alpine, Amazon Linux, and any aarch64/x86\_64 container.

---

### 2. Strong encode performance, with JXL speed caveats

[](#2-strong-encode-performance-with-jxl-speed-caveats)

Benchmarked on **Intel Core Ultra 7 155H** (22-thread AVX2), comparing encoder output at identical quality settings. crabmagick uses the same format parameters as libvips — same codec, same options — so file sizes are directly comparable.

#### JPEG (same quality, smaller files and/or faster)

[](#jpeg-same-quality-smaller-files-andor-faster)

Settingcrabvipsvs vipscrab KBvips KBQ75 baseline — 256×256 tile1.2 ms1.2 ms=2828Q75 opt-huffman — 256×256**0.6 ms**2.5 ms**4× faster**2627Q85 opt-huffman — 256×256**0.6 ms**1.9 ms**3× faster**3436Q95 — 256×256**1.5 ms**1.7 ms1.1× faster**91****114**Q95 opt-huffman — 256×256**1.0 ms**3.9 ms**4× faster****82****104**Q85 progressive — 256×256**1.8 ms**3.6 ms**2× faster****32**34Q90 4:4:4 — 256×256**1.2 ms**1.8 ms1.5× faster**65****84**Q75 opt-huffman — 800×600**3.0 ms**6.6 ms**2.2× faster****193**197Q85 opt-huffman — 800×600**3.7 ms**7.4 ms**2× faster****248**263Q95 opt-huffman — 800×600**4.9 ms**14.5 ms**3× faster****603**761Q75 opt-huffman — HD**12.9 ms**18.2 ms**1.4× faster****833**851Q85 opt-huffman — HD**12.6 ms**20.0 ms**1.6× faster****1070**1137Q95 opt-huffman — HD**25.6 ms**52.7 ms**2.1× faster****2608**3292> `optimize_huffman=false` (default) uses pre-built Huffman tables — matches libjpeg-turbo single-pass speed at tile sizes. `optimize_huffman=true` switches to a two-pass parallel build: faster at ≥512×512, produces 10–20% smaller files.

#### WebP (same quality, same files, same or faster)

[](#webp-same-quality-same-files-same-or-faster)

Settingcrabvipsvs vipscrab KBvips KBQ80 eff=0 — 256×256**3.3 ms**4.5 ms1.4× faster3334Q80 eff=4 — 256×256**8.0 ms**8.9 ms1.1× faster3232Q80 eff=4 — 800×600**52 ms**59 ms1.1× faster231231Q80 eff=4 — HD**222 ms**242 ms1.1× faster993993lossless eff=4 — 256×256**0.8 ms**64 ms**80× faster****8**20lossless eff=6 — 256×256**0.9 ms**64 ms**71× faster****8**20lossless eff=4 — 800×600**2.9 ms**191 ms**66× faster****10**20lossless eff=6 — 800×600**3.3 ms**191 ms**58× faster****9**20lossless eff=4 — HD**21 ms**384 ms**18× faster****15**22lossless eff=6 — HD**27 ms**812 ms**30× faster****11**22WebP lossless uses a custom pure-Rust encoder with an effort-aware LZ77 chain (eff=0–6). It is dramatically faster than libwebp at any effort level because libwebp serializes its lossless passes. Our encoder parallelizes them across all cores. At higher efforts the chain depth increases (eff=4 → depth 64, eff=6 → depth 256), matching libwebp's quality while remaining 30-80× faster.

#### PNG (same lossless content, way smaller files)

[](#png-same-lossless-content-way-smaller-files)

Settingcrabvipsvs vipscrab KBvips KBlevel=3 — 256×256**2.4 ms**5.3 ms**2.2× faster****25**183level=6 — 256×256**4.4 ms**5.1 ms1.2× faster**25**186level=3 — 800×6009.4 ms9.1 ms=**89**462level=6 — 800×600**8.5 ms**13.0 ms1.5× faster**89**461level=3 — HD21 ms16.3 ms—**182**867level=6 — HD**21 ms**26 ms1.2× faster**182**858Same pixels, **5× smaller files**. libvips uses libpng's adaptive row-filter selection, which performs poorly for structured content; crabmagick uses Paeth filter + zlib producing substantially better compression at any level.

#### JXL lossless (size parity or better on tested real photos; threaded runtime is competitive)

[](#jxl-lossless-size-parity-or-better-on-tested-real-photos-threaded-runtime-is-competitive)

Settingcrabvipsvs vipscrab KBvips KBlossless eff=7 — 1680×2446 real photo**4923 ms**6324 ms**1.28× faster**41194056lossless eff=7 — 3668×4527 real photo**14393 ms**24140 ms**1.68× faster****7962**8829On the current real-photo corpus, the default lossless profile is now at **parity or better on file size**: from **+1.5%** on one 1680×2446 photo to **-9.8%** on a 3668×4527 photo. With the normal threaded configuration, runtime is also ahead on both sampled photos because the modular path parallelizes well.

#### JXL lossy

[](#jxl-lossy)

Settingcrabvipsvs vipscrab KBvips KBd=1.0 eff=5 — 2446×3019 real photo**188 ms**209 ms**1.11× faster****845**936d=1.0 eff=5 — 3668×4527 real photo**348 ms**420 ms**1.20× faster****1530**1744d=1.0 eff=7 — 2446×3019 real photo**262 ms**269 ms**1.03× faster****852**945d=1.0 eff=7 — 3668×4527 real photo**526 ms**536 ms**1.02× faster****1546**1758The default lossy profile is now ahead on the sampled real-photo corpus at both `distance=1.0, effort=5` and `distance=1.0, effort=7`: runtime is faster on the current anchor photos, output is still **9.7–12.3% smaller** than libvips on the anchor set, and measured PSNR/SSIM remain above the previous crabmagick baselines. An additional sweep on 1223×1509 and 4891×6037 photos also stayed ahead at `effort=7` while remaining smaller than libvips.

#### TIFF

[](#tiff)

Settingcrabvipsvs vipscrab KBvips KBLZW — 256×256**3.6 ms**3.9 ms=8686Deflate — 256×256**2.3 ms**3.8 ms**1.7× faster**1920LZW — HD80 ms52 ms1.5× slower†14411427Deflate — HD**17 ms**26 ms**1.5× faster**116116Packbits — HD**5.2 ms**14.5 ms**2.8× faster**61306122†TIFF LZW is slower at large sizes due to tiff-rs/weezl's single-threaded LZW implementation. Use Deflate for better speed at all sizes.

---

### 3. Zero C dependency = no CVEs from C libraries

[](#3-zero-c-dependency--no-cves-from-c-libraries)

libvips links against libwebp, libjxl, libpng, libtiff, libjpeg-turbo — each of which has had significant CVEs. crabmagick is pure Rust: memory-safe by construction, no unsafe C heap allocations in codec paths, and the entire dependency chain can be audited with `cargo audit`.

---

### 4. Full feature parity with libvips

[](#4-full-feature-parity-with-libvips)

Everything you'd use libvips for in an IIIF image server works identically:

FeatureNotesAlpha channelPreserved through decode → ops → encode (PNG, WebP, JXL, AVIF, TIFF)ICC color profileExtracted on decode, embedded on encode (all formats)EXIF metadataExtracted from JPEG/WebP, re-embedded on JPEG encodeProgressive JPEG`progressive: true`Chroma subsampling4:2:0 (default), 4:2:2, 4:4:4Optimize Huffman`optimize_huffman: true` — two-pass, 10–20% smaller, faster at large sizesWebP near-lossless`near_lossless: true, quality: 0–100`WebP lossless effort sweepeff=0 (fastest) to eff=6 (best)JXL distance + effortFull range: d=0.0–25.0, eff=1–8JXL lossless paletteAuto-detected ≤1024 unique colors — matches libjxl compressionTIFF LZW/Deflate/Packbits/NoneWith horizontal difference predictorPNG bit depth8-bit and 16-bitPNG filterNone/Sub/Up/Avg/Paeth/AllRegion extractSub-image crop with coordinate validationResizeBilinear (fast), Lanczos (quality)Rotate0°/90°/180°/270° with alpha/ICC pass-throughSquare cropCenter-weighted smart crop---

### 5. What's still better in libvips

[](#5-whats-still-better-in-libvips)

Be honest about the gaps:

CaselibvipscrabmagickGapJPEG Q75 baseline at HD7.6 ms23 ms3× slower — use `optimize_huffman=true` (12.9 ms)JXL lossless eff=7 (1680×2446 photo)4056 KB, 6324 ms4119 KB, 4923 ms1.5% larger, but 1.28× fasterTIFF LZW at large sizes52 ms80 ms1.5× slower — use Deflate insteadPNG level=1 (noisy images)smallvery largezlib level=1 + Paeth bad for random content---

### Zero-config (daemon)

[](#zero-config-daemon)

```
composer require usernamn0tavailable/crabmagick
```

That's it. The daemon starts automatically on the first `require vendor/autoload.php`.

### With extension (optional, maximum performance)

[](#with-extension-optional-maximum-performance)

Install the Composer package first, then activate the bundled `.so`:

```
composer require usernamn0tavailable/crabmagick
```

```
# Activate for CLI / php-fpm / built-in server — no system php.ini change needed
export PHP_INI_SCAN_DIR=:/path/to/vendor/usernamn0tavailable/crabmagick/ext

# Or for php-fpm pools, add to the pool config:
# env[PHP_INI_SCAN_DIR] = :/path/to/vendor/usernamn0tavailable/crabmagick/ext
```

The `ext/` directory contains `.ini` files that load the correct `.so` for your PHP version and architecture automatically.

To verify the extension is active:

```
php -r "var_dump(\CrabMagick\Image::isAvailable());"
# bool(true) — extension path
# bool(true) — daemon path (both return true)

php -r "var_dump(\CrabMagick\Runtime::isUsingExtension());"
# bool(true) if extension is loaded
```

---

Requirements
------------

[](#requirements)

- PHP ≥ 8.1, Linux x86\_64 or aarch64
- No libvips, no libjxl, no C compiler, no Rust toolchain

---

Daemon — conditions & compatibility
---------------------------------------

[](#daemon--conditions--compatibility)

The daemon is the default mode, auto-selected when the PHP extension is not loaded.

### Hard requirements (daemon will refuse to start if any fail)

[](#hard-requirements-daemon-will-refuse-to-start-if-any-fail)

ConditionWhy**Linux only**Daemon uses Unix sockets (`AF_UNIX`). Windows and macOS are not supported.**x86\_64 or aarch64**Pre-built binaries are provided for these two architectures only.**`proc_open` enabled**PHP spawns the daemon process via `proc_open`. If it appears in `disable_functions`, the daemon cannot start.**`/tmp` writable** (or custom `sys_get_temp_dir()`)The Unix socket file and the daemon PID lock are created in `sys_get_temp_dir()`. The web server user must be able to write there.**glibc ≥ 2.17** (aarch64) or **musl** (x86\_64)x86\_64 binaries are statically linked with musl — they run everywhere. aarch64 binaries link against glibc dynamically; any Ubuntu 18.04+ / Debian 10+ / RHEL 8+ satisfies this.### Soft requirements (degrade gracefully if absent)

[](#soft-requirements-degrade-gracefully-if-absent)

ConditionEffect if missing**AVX2 / AVX512 CPU flags**Falls back to the baseline `x86_64` binary automatically — still correct, just slower.**`/proc/cpuinfo` readable**CPU feature detection fails silently; baseline binary is used.**Persistent process** (php-fpm / long-lived)Each PHP-CLI invocation spawns and teardown the daemon — adds ~20ms cold-start. With php-fpm the daemon is shared across workers and starts once.### Verified environments

[](#verified-environments)

EnvironmentStatusUbuntu 20.04 / 22.04 / 24.04, PHP 8.1–8.4✅ TestedDebian 11 / 12✅ TestedAlpine Linux (php-fpm)✅ Works (x86\_64 musl binary is fully static)AWS Graviton 2/3 (aarch64)✅ TestedDocker (`FROM php:8.x-fpm-alpine`)✅ TestedAzure Arc VM (Xeon Gold, Ubuntu 24.04)✅ Verified compatiblemacOS❌ Unix socket path differs, not supportedWindows❌ Not supported### php-fpm configuration tips

[](#php-fpm-configuration-tips)

The daemon is a persistent background process. Under php-fpm it is started once per pool worker on first request and stays alive for the pool lifetime.

```
; Allow proc_open (it is enabled by default — only needed if you disabled it)
; Remove 'proc_open' from disable_functions in php.ini / pool config

; Recommended: give the pool a dedicated tmp dir so each pool has its own socket
env[TMPDIR] = /run/php/crabmagick-pool-www
```

```
# Create a per-pool socket dir (add to your provisioning / Dockerfile)
install -d -o www-data -g www-data -m 0700 /run/php/crabmagick-pool-www
```

### Checking daemon status from PHP

[](#checking-daemon-status-from-php)

```
// Is the daemon running right now?
var_dump(\CrabMagick\Runtime::isDaemonRunning());   // bool(true)

// Which binary was selected?
var_dump(\CrabMagick\Runtime::binaryPath());        // string("/path/to/crabmagick-x86_64-avx512-linux")

// Is the extension being used instead?
var_dump(\CrabMagick\Runtime::isUsingExtension());  // bool(false) in daemon mode
```

---

PHP API
-------

[](#php-api)

```
// Fluent builder
$bytes = (new \CrabMagick\Image('/path/to/file.jxl'))
    ->region(0, 0, 512, 512)   // crop (x, y, w, h)
    ->resize(256, 256)          // output size (0 = proportional)
    ->rotate(90)                // clockwise: 90 | 180 | 270
    ->encode('jpeg', 85);       // 'jpeg' | 'webp' | 'png' | 'jxl' | 'avif'

// Square crop (IIIF "square" region)
$bytes = (new \CrabMagick\Image($path))->square()->resize(512)->encode('webp', 80);

// Page/frame selection (multi-page TIFF, animated WebP)
$bytes = (new \CrabMagick\Image($path))->page(2)->resize(1024)->encode('jpeg');

// One-shot helper
$bytes = \CrabMagick\process($path, $rx, $ry, $rw, $rh, $outW, $outH, 'jpeg', 85);

// Dimensions without full decode
$info = \CrabMagick\info($path);          // ['width' => 3360, 'height' => 4892]
$info = (new \CrabMagick\Image($path))->getInfo();
```

---

Supported formats
-----------------

[](#supported-formats)

FormatDecodeEncodeJPEG✅✅PNG✅✅WebP (lossy + lossless)✅✅JPEG XL✅✅AVIF✅✅TIFF✅✅ (LZW, Deflate, Packbits; horizontal predictor)GIF✅—BMP✅—SVG✅—JP2/J2K✅—---

Performance
-----------

[](#performance)

Benchmarks run on Intel Core Ultra 7 155H (AVX2, 22 threads) against libvips (industry-standard C image processing). Three image types (photo/document/gradient), three sizes (256×256 tile, 800×600 medium, 1920×1080 HD). Each cell shows median of 5 runs.

### Photo 800×600 — encoder comparison

[](#photo-800600--encoder-comparison)

Codeccrab mscrab KBPSNRvips msvips KBJPEG Q754.820918.34.4204JPEG Q75 opt-huffman**3.0**19318.36.6197JPEG Q855.426318.73.7274JPEG Q85 opt-huffman**3.7**24818.77.4263JPEG Q95 opt-huffman**4.9**60327.014.5761JPEG Q85 progressive**10.5**23718.713.7246WebP Q80 eff=0**21**23919.227239WebP Q80 eff=4**52**23119.259231WebP Q80 eff=6**162**22519.2176225WebP lossless eff=4**2.9**10inf18020WebP lossless eff=6**3.3**9inf18220WebP near-lossless Q80183652251.1456536PNG level=3**9.4**89inf9.1462PNG level=6**8.5**89inf13.0461TIFF LZW21448inf13448TIFF Deflate**7**55inf955†JPEG: `optimize_huffman=false` (default) uses single-pass fixed tables — fastest for tiles. `optimize_huffman=true` (two-pass) is faster at large images and produces ~10% smaller files. ‡TIFF LZW: tiff-rs/weezl LZW is slower than libvips's hand-tuned implementation.

### Photo 256×256 (tile) highlights

[](#photo-256256-tile-highlights)

Codeccrab msvips msOur sizevips sizeJPEG Q75**1.2**1.228 KB28 KBJPEG Q85 opt-huffman**0.6**1.934 KB36 KBJPEG Q95 opt-huffman**1.0**3.982 KB104 KBWebP Q80 eff=4**8.0**8.932 KB32 KBWebP lossless eff=4**0.8**648 KB20 KBPNG level=6**4.4**5.125 KB186 KBTIFF LZW**3.6**3.986 KB86 KB### Photo 1920×1080 (HD) highlights

[](#photo-19201080-hd-highlights)

Codeccrab msvips msNotesJPEG Q75237.6Fixed tables; use opt-huffman for large imagesJPEG Q75 opt-huffman**12.9**18.21.4× fasterJPEG Q95 opt-huffman**25.6**52.7**2.1× faster**JPEG Q85 progressive**49**52at parityWebP lossless eff=4**21**384**18× faster**WebP lossless eff=6**27**812**30× faster**TIFF Deflate**17**261.5× faster, same size### Decoders

[](#decoders)

FormatcrabmagickReferenceSpeedupJPEG**31 ms**33 ms (libjpeg-turbo)1.1× fasterJPEG (RST markers)**10 ms**19 ms (libjpeg-turbo parallel)**2× faster**PNG**41 ms**83 ms (libpng)**2× faster**WebP**111 ms**90 ms (libwebp)at parityJXL**35 ms**47 ms (libjxl full RGB decode)1.3× faster### How performance is achieved (pure Rust, zero C)

[](#how-performance-is-achieved-pure-rust-zero-c)

TechniqueApplied toAVX2 + FMA SIMDJPEG IDCT, WebP YUV→RGB, WebP IDCT, JXL DCT8–64, JXL Gabor/EPF filters, XYB→sRGBSSE4.1 SIMDWebP IDCT 4×4, WebP residual addRayon parallel decodeJPEG RST segments, JXL pass-groups (70 groups/image)Rayon parallel encodeJPEG RST entropy, WebP token partitionsJXL lossless paletteAuto-detected for ≤256-color images; matches libjxl's 1-bit/palette pathBranchless arithmeticVP8 boolean decoder (cmov-friendly, eliminates 50% branch mispredictions)11-bit Huffman lookaheadJPEG: 2048-entry tables, decodes most symbols in 1 table lookupThread-local scratch buffersJXL DCT: eliminates per-block heap allocations (~26K allocs/image)### Feature parity with libvips

[](#feature-parity-with-libvips)

FeatureStatusAlpha channel (PNG, WebP, JXL, AVIF, TIFF)✅ Preserved end-to-endICC color profile✅ Extracted on decode, embedded on encodeEXIF metadata✅ Extracted from JPEG/WebP, re-embedded on JPEG encodeJXL lossy (natural photos, d=1.0 eff=5/e7)✅ Smaller than libvips and faster on current sampled photosJXL lossless (natural images, eff=5)✅ File-size parity or better on current real-photo probesJXL lossless (natural images, eff=7)✅ File-size parity or better, and threaded runtime is faster on sampled photosJXL lossless (palette/binary)✅ Auto-detected, 2.7× faster than libjxlWebP near-lossless✅ Full libwebp near\_lossless support; file sizes match libvipsTIFF LZW/Deflate/Packbits + predictor✅ Same output size as libvipsTIFF tiled output⚠️ Not yet implemented (tiff-rs limitation)### Known gaps vs libvips

[](#known-gaps-vs-libvips)

CaseOur resultlibvipsGapJPEG Q75 baseline (tile 256×256)at paritylibjpeg-turbo SIMD—JPEG Q75 baseline (HD 1920×1080)23 ms7.6 ms3× slower; use `optimize_huffman=true`JXL lossless eff=7 (1680×2446 photo, threaded)4923 ms, 4119 KB6324 ms, 4056 KB1.28× faster, 1.5% largerTIFF LZW1.5–2× slower—tiff-rs/weezl limitationPNG level=1 (large noisy images)largesmalladaptive filter needed for random content**Encoder options (all formats):** quality, progressive, optimize\_huffman, chroma subsampling (JPEG); effort, lossless, near-lossless, alpha quality (WebP); distance, effort, lossless, tier (JXL); compression, filter, bit depth (PNG); compression, predictor (TIFF).

---

Bundled binaries
----------------

[](#bundled-binaries)

The right binary is selected automatically from `/proc/cpuinfo` at startup.

BinaryTarget`crabmagick-x86_64-linux`x86\_64 baseline`crabmagick-x86_64-avx2-linux`x86\_64 AVX2 (Haswell 2013+, Ryzen 2017+)`crabmagick-x86_64-avx512-linux`x86\_64 AVX-512 (Skylake-X+, Zen 4+)`crabmagick-aarch64-linux`aarch64 (AWS Graviton, RPi 4+)`crabmagick-aarch64-sve-linux`aarch64 SVE (Graviton 3+, Neoverse N2)---

Build from source
-----------------

[](#build-from-source)

```
rustup target add x86_64-unknown-linux-musl
sudo apt-get install musl-tools gcc-aarch64-linux-gnu

cd rust

# x86_64
RUSTFLAGS="-C target-cpu=x86-64         -C link-arg=-static-libgcc" \
  cargo build -p crabmagick-daemon --release --target x86_64-unknown-linux-musl
cp target/x86_64-unknown-linux-musl/release/crabmagick-daemon ../bin/crabmagick-x86_64-linux

RUSTFLAGS="-C target-cpu=haswell        -C link-arg=-static-libgcc" \
  cargo build -p crabmagick-daemon --release --target x86_64-unknown-linux-musl
cp target/x86_64-unknown-linux-musl/release/crabmagick-daemon ../bin/crabmagick-x86_64-avx2-linux

RUSTFLAGS="-C target-cpu=skylake-avx512 -C link-arg=-static-libgcc" \
  cargo build -p crabmagick-daemon --release --target x86_64-unknown-linux-musl
cp target/x86_64-unknown-linux-musl/release/crabmagick-daemon ../bin/crabmagick-x86_64-avx512-linux

# aarch64 (cross-compile)
rustup target add aarch64-unknown-linux-gnu
CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc \
  RUSTFLAGS="-C target-cpu=generic -C link-arg=-static-libgcc" \
  cargo build -p crabmagick-daemon --release --target aarch64-unknown-linux-gnu
cp target/aarch64-unknown-linux-gnu/release/crabmagick-daemon ../bin/crabmagick-aarch64-linux
```

###  Health Score

11

—

LowBetter than 0% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity3

Limited adoption so far

Community2

Small or concentrated contributor base

Maturity15

Early-stage or recently created project

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~0 days

Total

3

Last Release

50d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/a02bbde74e279a7b59a79d0c457797230cbaaac8caef78421c1a15b9afb3b253?d=identicon)[UsernameN0tAvailable](/maintainers/UsernameN0tAvailable)

### Embed Badge

![Health badge](/badges/usernamn0tavailable-crabmagick/health.svg)

```
[![Health](https://phpackages.com/badges/usernamn0tavailable-crabmagick/health.svg)](https://phpackages.com/packages/usernamn0tavailable-crabmagick)
```

###  Alternatives

[goat1000/svggraph

Generates SVG graphs

135931.0k3](/packages/goat1000-svggraph)[stefangabos/zebra_image

A single-file, lightweight PHP library designed for efficient image manipulation featuring methods for modifying images and applying filters

138121.6k7](/packages/stefangabos-zebra-image)[treinetic/imageartist

ImageArtist is a php gd Wrapper which makes Image manipulation insanely easy, we introduce ImageArtist as Photoshop for php

8783.2k](/packages/treinetic-imageartist)[johncarter/filament-focal-point-picker

An image focal point picker for Filament Admin.

4431.7k1](/packages/johncarter-filament-focal-point-picker)[yk/laravel-ocr

A wrapper for gocr.

1356.6k](/packages/yk-laravel-ocr)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)