High-performance image manipulation for web servers. Includes imageflow_server, imageflow_tool, and libimageflow
Download blazing fast and safer tools for a modern image workflow.
imageflow_tool
is a command-line tool for experimenting, running batch jobs, JSON jobs,
or when you want process isolation. Up to 17x faster than ImageMagick. Also produces smaller files at higher quality.libimageflow
is for direct (in-process) use from your programming language. See our Node bindings, Go bindings, Scala bindings, Elixir bindings, or .NET bindings. If we don't already have bindings for your language, consider spending a day to add them. Imageflow has a simple
C-compatible ABI, of which only 4 methods are needed to implement bindings./bucket/img.jpg?w=200
) for direct use from
HTML. Source images can reside in blob storage, on another server, or on the filesystem. It's a production ready server with excellent hybrid disk caching, support for Azure and Amazon blob storage, and can be easily customized. You can deploy it easily via Docker, on a VM, or via any cloud host. It's also backwards compatible with the ImageResizer API - which is useful, as ImageResizer as been integrated into more than a thousand different CMSes and applications in the last decade.Open an issue to share ideas, feedback, or ask questions. We believe in feedback-driven design, and streamlining real-world usage is the fastest way to a great product.
libimageflow and imageflow_tool are available as self-contained binaries for Windows, Ubuntu, and Mac. We also offer Docker images for Linux (where glibc and OpenSSL are required).
We thank our backers on Kickstarter and the many supporters of ImageResizer for making this project a reality. Visit Imageresizing.net if you need an AGPLv3 exception for commercial use.
imageflow_tool examples --generate
- creates an examples directory with JSON jobs and invocation scripts.
You can use command strings that are compatible with ImageResizer 4 querystrings:
imageflow_tool v1/querystring --in source.jpg --out thumb.jpg --command "width=50&height=50&mode=crop&format=jpg"
Or submit a JSON job file. JSON jobs can have multiple inputs and outputs, and can represent any kind of operation graph.
The following generates multiple sizes of an image from an example job file:
imageflow_tool v1/build --json examples/export_4_sizes/export_4_sizes.json
--in waterhouse.jpg
--out 1 waterhouse_w1600.jpg
2 waterhouse_w1200.jpg
3 waterhouse_w800.jpg
4 waterhouse_w400.jpg
--response operation_result.json
By default, imageflow_tool prints a JSON response to stdout. You write this to disk with --response
.
--debug-package
will create a .zip file to reproduce problematic behavior with both v1/build
and v1/querystring
. Please submit bug reports; we try to make it easy.
NOTE: imageflow_server has been removed as the underlying web framework (iron) is abandoned and no longer secure. For the last few years we have suggested moving to the production-ready Imageflow.Server product, which also offers docker deployment (but we suggest your own dockerfile to permit configuration)
Now you can edit images from HTML... and use srcset without headache.
<img src="http://localhost:39876/demo_images/u3.jpg?w=300" />
<img src="" srcset=" http://localhost:39876/demo_images/u3.jpg?w=300 300w
http://localhost:39876/demo_images/u3.jpg?w=800 800w
http://localhost:39876/demo_images/u3.jpg?w=1600 1600w" />
You'll want to mount various image source locations to prefixes. The --mount
command parses a colon (:
) delimited list of arguments. The first is the prefix you'll use in the URL (like http://localhost:39876/prefix/
. The second is the engine name. Remaining arguments are sent to the engine.
--mount "/img/:ir4_local:C:\inetpub\wwwroot\images"
--mount "/proxyimg/:ir4_http:https:://myotherserver.com/imagefolder/"
(note the double escaping of the colon)--mount "/cachedstaticproxy/:permacache_proxy:https:://othersite.com"
--mount "/githubproxy/:permacache_proxy_guess_content_types:https:://raw.github.com/because/it/doesnt/support/content/types"
--mount "/static/":static:./assets"
imageflow_core
crate.You also may find that imageflow_tool
is quite fast enough for your needs.
bindings/headers
You'll need more than just Rust to compile Imageflow, as it has a couple C dependencies.
git clone [email protected]:imazen/imageflow.git && cd imageflow
)If you are using bash
on any platform, you should be able to use build.sh
./build.sh clean
- to clean./build.sh test
- run all tests./build.sh debug
- generate slow debug binaries./build.sh release
- generate release binaries./build.sh install
- install release binaries to /usr/local
(must run `./build.sh release first)./build.sh uninstall
- uninstall release binariesbuild.sh
places binaries in the ./artifacts/ directory
If you are on Windows, only run build commands in the window created by win_enter_env.bat
.
You can also build using cargo
directly, although this will place binaries in ./target/release
instead.
* cargo test --all
to test Imageflow in debug (slooow) mode
* cargo build --package imageflow_abi --release
to compile libimageflow/imageflow.dll
* cargo build --package imageflow_tool --release
to compile imageflow_tool(.exe)
* cargo build --all --release
to compile everything in release mode
* cargo doc --no-deps --all --release
to generate documentation.
Note that we no longer use docker containers for CI, so this method is outdated.
git clone [email protected]:imazen/imageflow.git
cd imageflow
./build_via_docker.sh debug
This will create caches within ~/.docker_imageflow_caches
specific to the docker image used. Instances will be ephemeral; the only state will be in the caches.
The official Dockerfiles are also a great place to get more detailed environment setup steps, as we don't list steps for setting up:
(tested on Ubuntu 20.04 and 22.04.)
#Install Rust by running
`curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain stable`
#Ensure build tools are installed (git, curl, wget, gcc, g++, nasm, pkg-config, openssl, ca-certificates)
`sudo apt-get install git wget curl build-essential pkg-config libssl-dev libpng-dev nasm `
brew install nasm pkg-config wget
sudo apt-get update
to update available packages.curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain stable
sudo apt-get install git wget curl build-essential pkg-config libssl-dev libpng-dev nasm
ln -s /mnt/c/Users/[YourWindowsUserName]/Documents/imageflow ~/win_imageflow
Run As Administrator
the NASM 64-bit installer - it will not prompt.stable
as the default, and confirm adding it to PATH
.ci/wintools/SETUP_PATH.bat
to ensure that rust/cargo, nasm, git, and Git/mingw64/bin are all in %PATH%
.win_enter_env.bat
to start a sub-shell (edit it if you want a 32-bit build)cmd.exe /c "ci\wintools\win_verify_tools.bat"
to check tools are present.First, read High Performance Images for context.
There are not many great textbooks on the subject. Here are some from my personal bookshelf. Between them (and Wikipedia) I was able to put together about 60% of the knowledge I needed; the rest I found by reading the source code to many popular image processing libraries.
I would start by reading Principles of Digital Image Processing: Core Algorithms front-to-back, then Digital Image Warping. Wikipedia is also a useful reference, although the relevant pages are not linked or categorized together - use specific search terms, like "bilinear interpolation" and "Lab color space".
I have found the source code for OpenCV, LibGD, FreeImage, Libvips, Pixman, Cairo, ImageMagick, stb_image, Skia, and FrameWave is very useful for understanding real-world implementations and considerations. Most textbooks assume an infinite plane, ignore off-by-one errors, floating-point limitations, color space accuracy, and operational symmetry within a bounded region. I cannot recommend any textbook as an accurate reference, only as a conceptual starting point. I made some notes regarding issues to be aware of when creating an imaging library.
Also, keep in mind that computer vision is very different from image creation. In computer vision, resampling accuracy matters very little, for example. But in image creation, you are serving images to photographers, people with far keener visual perception than the average developer. The images produced will be rendered side-by-side with other CSS and images, and the least significant bit of inaccuracy is quite visible. You are competing with Lightroom; with offline tools that produce visually perfect results. End-user software will be discarded if photographers feel it is corrupting their work.