Line-by-line transliteration of a mature image library, offering format decoding/encoding, ImageBuffer/DynamicImage types, imageops (blur, resize, rotate), and provenance-tracked source mapping.
This is a Kotlin Multiplatform line-by-line transliteration port of image-rs/image.
Original Project: This port is based on image-rs/image. All design credit and project intent belong to the upstream authors; this repository is a faithful port to Kotlin Multiplatform with no behavioural changes intended.
This is an in-progress port. The goal is feature parity with the upstream Rust crate while providing a native Kotlin Multiplatform API. Every Kotlin file carries a // port-lint: source <path> header naming its upstream Rust counterpart so the AST-distance tool can track provenance.
image-rs/imageThe text below is reproduced and lightly edited from
https://github.com/image-rs/image. It is the upstream project's own description and remains under the upstream authors' authorship; links have been rewritten to absolute upstream URLs so they continue to resolve from this repository.
This crate provides basic image processing functions and methods for converting to and from various image formats.
All image processing functions provided operate on types that implement the GenericImageView and GenericImage traits and return an ImageBuffer.
Load images using [ImageReader]:
use std::io::Cursor;
use image::ImageReader;
let img = ImageReader::open("myimage.png")?.decode()?;
let img2 = ImageReader::new(Cursor::new(bytes)).with_guessed_format()?.decode()?;
And save them using [save] or [write_to] methods:
img.save("empty.jpg")?;
let mut bytes: Vec<u8> = Vec::new();
img2.write_to(&mut Cursor::new(&mut bytes), image::ImageFormat::Png)?;
With default features enabled, image provides implementations of many common
image format encoders and decoders.
Decoding support for additional image formats is provided by
image-extras, and the same plugin
interface lets third-party crates act as format implementations for image. If
you need to handle some other image format, check crates.io for crates that
implement it.
Note: When using image in a library you intend to publish, it is recommended to set default-features = false and then explicitly enable format features that are absolutely necessary. This ensures a smaller dependency tree and faster iteration time. The default feature configuration would also enable multithreading which may cause unexpected behavior when running for inherently single-threaded environments such as wasm targets.
This crate provides a number of different types for representing images. Individual pixels within images are indexed with (0,0) at the top left corner.
ImageBufferAn image parameterised by its Pixel type, represented by a width and height and
a vector of pixels. It provides direct access to its pixels and implements the
GenericImageView and GenericImage traits.
DynamicImageA DynamicImage is an enumeration over all supported ImageBuffer<P> types.
Its exact image type is determined at runtime. It is the type returned when
opening an image. For convenience DynamicImage reimplements all image
processing functions.
GenericImageView and GenericImage TraitsTraits that provide methods for inspecting (GenericImageView) and manipulating (GenericImage) images, parameterised over the image's pixel type.
SubImageA view into another image, delimited by the coordinates of a rectangle. The coordinates given set the position of the top left corner of the rectangle. This is used to perform image processing functions on a subregion of an image.
ImageDecoder TraitAll image format decoders implement the ImageDecoder trait which provide
basic methods for getting image metadata and decoding images.
The most important methods for decoders are...
image provides the following pixel types:
All pixels are parameterised by their component type.
These are the functions defined in the imageops module. All functions operate on types that implement the GenericImage trait.
Note that some of the functions are very slow in debug mode. Make sure to use release mode if you experience any performance issues.
For more options, see the imageproc crate.
image provides the open function for opening images from a path. The image
format is determined from the path's file extension. An io module provides a
reader which offer some more control.
use image::GenericImageView;
// Use the open function to load an image from a Path.
// `open` returns a `DynamicImage` on success.
let img = image::open("tests/images/jpg/progressive/cat.jpg").unwrap();
// The dimensions method returns the images width and height.
println!("dimensions {:?}", img.dimensions());
// The color method returns the image's `ColorType`.
println!("{:?}", img.color());
// Write the contents of this image to the Writer in PNG format.
img.save("test.png").unwrap();
//! An example of generating julia fractals.
let imgx = 800;
let imgy = 800;
let scalex = 3.0 / imgx as f32;
let scaley = 3.0 / imgy as f32;
// Create a new ImgBuf with width: imgx and height: imgy
let mut imgbuf = image::ImageBuffer::new(imgx, imgy);
// Iterate over the coordinates and pixels of the image
for (x, y, pixel) in imgbuf.enumerate_pixels_mut() {
let r = (0.3 * x as f32) as u8;
let b = (0.3 * y as f32) as u8;
*pixel = image::Rgb([r, 0, b]);
}
// A redundant loop to demonstrate reading image data
for x in 0..imgx {
for y in 0..imgy {
let cx = y as f32 * scalex - 1.5;
let cy = x as f32 * scaley - 1.5;
let c = num_complex::Complex::new(-0.4, 0.6);
let mut z = num_complex::Complex::new(cx, cy);
let mut i = 0;
while i < 255 && z.norm() <= 2.0 {
z = z * z + c;
i += 1;
}
let pixel = imgbuf.get_pixel_mut(x, y);
let image::Rgb(data) = *pixel;
*pixel = image::Rgb([data[0], i as u8, data[2]]);
}
}
// Save the image as “fractal.png”, the format is deduced from the path
imgbuf.save("fractal.png").unwrap();
Example output:
If the high level interface is not needed because the image was obtained by other means, image provides the function save_buffer to save a buffer to a file.
let buffer: &[u8] = unimplemented!(); // Generate the image data
// Save the buffer as "image.png"
image::save_buffer("image.png", buffer, 800, 600, image::ExtendedColorType::Rgb8).unwrap()
dependencies {
implementation("io.github.kotlinmania:image-kotlin:0.1.3")
}
./gradlew build
./gradlew test
See AGENTS.md and CLAUDE.md for translator discipline, port-lint header convention, and Rust → Kotlin idiom mapping.
This Kotlin port is distributed under the same MIT license as the upstream image-rs/image. See LICENSE (and any sibling LICENSE-* / NOTICE files mirrored from upstream) for the full text.
Original work copyrighted by the image authors.
Kotlin port: Copyright (c) 2026 Sydney Renee and The Solace Project.
Thanks to the image-rs/image maintainers and contributors for the original Rust implementation. This port reproduces their work in Kotlin Multiplatform; bug reports about upstream design or behavior should go to the upstream repository.
| Feature | Description |
|---|
default-formats | Default Format support for common image formats: AVIF, BMP, EXR, FF, GIF, HDR, ICO, JPEG, PNG, PNM, QOI, TGA, TIFF, and WebP |
rayon | Default Enables multi-threading with rayon context in some dependencies |
nasm | Enables the build-time use of nasm for ravif, requires nasm installed |
color_quant | Includes color_quant as an implementation of imageops::ColorMap |
avif-native | Enables non-Rust dependencies of avif (mp4parse and dav1d) |
serde | Enables serde integration for various structs and options |
Surfaced from shared tags and platforms — no rankings paid for.