Skip to main content
FastPack is a high-performance texture atlas packer written in Rust. It combines a native GUI interface with a full-featured CLI to give you maximum flexibility in your sprite packing workflow.

Installation

Get FastPack installed on Windows, macOS, or Linux in minutes

Quick start

Pack your first atlas in under 5 minutes

CLI reference

Complete command-line interface documentation

Project files

Learn about .fpsheet project configuration

​
Why FastPack?

FastPack is designed as an open-source replacement for TexturePacker, offering:
  • Native performance — Written in Rust for speed and reliability
  • Modern GUI — Real-time atlas preview with collapsible sprite tree and thumbnails
  • Powerful CLI — Full automation support for CI/CD pipelines
  • Multiple algorithms — MaxRects (5 heuristics), Grid, and Basic strip packing
  • Advanced features — Trim modes, rotation, extrusion, alias detection, multipack
  • Format flexibility — Export to JSON, Phaser 3, PixiJS, and more

​
Key features

​
Packing algorithms

FastPack supports multiple packing strategies to optimize atlas density:
  • MaxRects with 5 different heuristics for optimal sprite placement
  • Grid packing for uniform sprite sizes
  • Basic strip algorithm for simple layouts

​
Trim modes

Reduce atlas size by intelligently handling transparent pixels:
  • None — Pack sprites with their full transparent borders
  • Trim — Remove transparent borders while storing offsets for reconstruction
  • Crop — Tightly crop to opaque regions
  • CropKeepPos — Like Crop but preserves original registration points
  • Polygon — Generate convex hull polygons for complex shapes

​
Export formats

Export your atlases in formats that work with your game engine:
  • JSON Hash — TexturePacker-compatible format (default)
  • JSON Array — Array-based format with filename fields
  • Phaser 3 — Native support for scene.load.multiatlas()
  • PixiJS — Compatible with PixiJS sprite sheet loaders

​
Texture compression

Optimize your atlases with multiple compression options:
  • PNG — Lossless compression with oxipng
  • JPEG — Lossy compression with mozjpeg
  • WebP — Modern format with superior compression
  • DXT1/DXT5 — Hardware compression for GPU textures

​
Advanced features

Alias detection

Automatically deduplicate pixel-identical sprites to save space

Multipack

Split sprites across multiple sheets when they overflow

Multi-resolution

Generate scale variants with per-variant suffixes (@1x, @2x, etc.)

Watch mode

Automatically repack when source files change

Nine-patch

Support for nine-patch metadata and pivot points

Rotation

Allow 90° sprite rotation for better packing density

​
How it works

FastPack takes a directory of individual sprite images and combines them into a single texture atlas, along with a data file that describes where each sprite is located:
1

Input sprites

Point FastPack to a directory containing your PNG, JPEG, or other image files
2

Configure packing

Choose your packing algorithm, trim mode, padding, and export format
3

Generate atlas

FastPack arranges sprites efficiently and outputs an atlas image + data file
4

Load in your game

Import the atlas and data file into your game engine

​
Use cases

​
Game development

Reduce draw calls and improve rendering performance by combining sprites into texture atlases. FastPack supports all major game engines including Phaser, PixiJS, Unity, and Godot.

​
UI development

Pack icon sets and UI elements into efficient sprite sheets for web and mobile applications.

​
CI/CD integration

Automate atlas generation in your build pipeline using FastPack’s CLI and watch mode.

​
Next steps

Install FastPack

Download installers or install via cargo

Quick start guide

Pack your first texture atlas

Build docs developers (and LLMs) love

Get started for freeTalk to us