A fast, lightweight, native Windows application for batch converting images between JPEG, PNG, WebP, AVIF, HEIC/HEIF, and TIFF. Camera RAW formats (DNG, CR2, NEF, ARW, PEF, SR2) are decoded via the bundled dcraw executable.
Version: 1.0.3
Platform: Windows 10/11 (64-bit)
License: GPL-3.0-or-later
Note: This application is designed specifically for Windows. The core conversion engine is written in Rust, and you are welcome to fork the repository and extend it for porting to other platforms.
- Multi-format Support: Convert between JPEG, PNG, WebP, AVIF, HEIC/HEIF, and TIFF; decode DNG/CR2/NEF/ARW/PEF/SR2 via bundled
dcraw - Icon Generator: Generate Windows ICO, Web Favicon, and Android app icon packages with drag-and-drop and custom output folders
- Simple & Advanced Modes: Switch between a streamlined interface and a full advanced panel
- Batch Processing: Process multiple files simultaneously with configurable batch size (1–500)
- Real-time Progress: Each file shows a live percentage (
0%→100%) during conversion - Quality Control: Quality slider (1–100) mapped 1:1 to every lossy encoder — JPEG, WebP, AVIF, and HEIC all reach their format ceiling
- Encode Intent: Balanced, Archive, or Social — sets chroma subsampling, encoder effort, and privacy handling to match what the output is actually for
- Lossless Compression: Available in advanced mode for HEIC and WebP output — automatically hides the quality slider when enabled
- PNG Optimization: Optional oxipng compression for smaller PNG sizes, disabled by default because it is CPU-heavy on large batches
- Image Resizing: Scale to custom dimensions with an optional "Preserve Aspect Ratio" lock
- Smart Resize Filter: Automatically selects Mitchell filter for upscaling and Lanczos3 for downscaling
- Precision Crop (Top/Bottom/Left/Right): Crop each side with percentage range
0–100before resize, including decimal input support (0.66,1.25,1,25) - Optional Metadata Preservation: When
Keep Metadatais enabled, preserve EXIF, XMP, IPTC, and ICC metadata where the target container supports them. PNG, AVIF, and TIFF outputs supplement missing OS-visible fields from EXIF-derived XMP so Windows Properties can read more than just author/creator. WebP/AVIF/HEIC do not natively support IPTC. ICC colour profiles may still be carried for supported outputs to keep colour rendering consistent. - Filename Customization: Add prefixes, find/replace patterns, auto-suffix with resolution, and sequential numbering
- Custom Output Folder: Optionally save converted files to a user-selected directory
- Dark/Light Theme: Modern UI with theme switching
- Drag & Drop: Simply drop files into the application
- Settings Management: Backup and restore your preferences and presets database directly from the UI
- Smart Dataset Logging: Incrementally generates
dataset_log.txtlists grouped by original folder - Custom Presets: Define, save, and load multiple conversion configurations for quick reuse
- Portable: No installation required; settings and presets stored in a
data/folder next to the executable - Official Release Bundle: The automated release build (
build_release_windows.bat) packages the executable, all required DLLs, and the Visual C++ Redistributable into a single portable folder - Security Hardening: File magic validation rejects unknown extensions; filename sanitization prevents path traversal
- Select Files: Click "Select Files" or drag & drop images into the application.
- Configure Options: Choose output format, quality, crop/resize settings, and filename options.
- Convert: Click "Start Conversion" to process all files.
- Output: Converted files are saved to the same folder as originals (or a custom output folder), with the final resolution reflecting crop + resize configuration.
The application uses high-performance libraries including mozjpeg for JPEG compression, oxipng for PNG optimization, libheif for HEIC encoding/decoding, ravif for AVIF encoding, and dav1d for AVIF decoding. The quality slider is mapped per encoder:
- JPEG: direct mapping
1..=100. Chroma subsampling is disabled (4:4:4) at high quality. - WebP: direct mapping
1..=100. Lossy WebP is always 4:2:0 — there is no 4:4:4 mode at any quality — so sharp-YUV conversion is used to limit chroma damage, and Archive intent switches to near-lossless at 95+. - AVIF: direct mapping
1..=100, encoded at 10-bit internal depth. - HEIC: direct mapping
1..=100unless lossless mode is enabled.
Before v1.0.3 JPEG silently clamped to 95 and AVIF mapped through 20 + q * 0.70 (a real
ceiling of 90), while the UI advertised 100 for both. Both now reach the format ceiling.
Presets saved in earlier versions keep their quality number but will produce larger,
higher-quality AVIF output.
Alongside quality, advanced mode offers an Intent that says what the output is for:
| Intent | Use for | Effect |
|---|---|---|
| Balanced | General conversion | Chroma follows quality; default encoder effort |
| Archive | Long-term storage | Full chroma where the format allows, slowest/smallest encoder settings, WebP near-lossless at 95+ |
| Social | Uploading to platforms | Subsampled chroma, faster encoding, quality capped at 90, and GPS coordinates and camera serial numbers stripped |
Social caps quality because receiving platforms re-encode uploads — bytes spent above ~90 are discarded before anyone sees the image, so a smaller clean file gives a better final result than a larger one. The cap is shown next to the slider rather than applied silently.
Note that JPEG is never truly lossless even at quality 100. For maximum-fidelity archiving, use TIFF, PNG, or HEIC/WebP in lossless mode.
Individual conversion tasks use a 5-minute conversion deadline. The engine checks the deadline between major stages and applies a hard kill timeout to the dcraw RAW subprocess so malformed RAW input cannot leave a hidden child process running after the UI marks a conversion as failed.
Engine design highlights
- Single-read I/O:
convert_imagereads file bytes once; validation, dimension extraction, orientation, and decoding operate on the same in-memory buffer. - Atomic writes: Output is written to a UUID-named temp file, verified, then atomically published. Existing Windows outputs are replaced with
ReplaceFileWso the previous file is not deleted before the replacement succeeds. - Concurrency limiting:
tokio::sync::Semaphorecapped at2 × CPU cores(minimum 2) to prevent thread pool exhaustion. - Smart resize: Automatically selects Mitchell filter for upscaling and Lanczos3 for downscaling.
- File magic validation: Rejects unknown extensions and validates magic signatures for JPEG, PNG, WebP, HEIC, and AVIF.
- Filename sanitization: Collapses
..sequences and strips illegal filesystem characters to prevent path traversal.
When Keep Metadata is enabled, the conversion engine stores metadata in the standard location for each output container and adds OS-readable projections where Windows commonly reads a narrower subset than metadata tools such as ExifTool or Exif Pilot. The default app setting leaves EXIF/XMP/IPTC preservation off, while supported ICC colour-profile transfer can still be used to preserve colour appearance.
| Output | Metadata storage behavior |
|---|---|
| JPEG | EXIF APP1, XMP APP1, IPTC Photoshop APP13, and ICC APP2 chunks |
| PNG | eXIf, iTXt XML:com.adobe.xmp, IPTC raw profile, ICC, and selected tEXt fallback fields for Windows/WIC visibility |
| WebP | RIFF EXIF, XMP , and ICCP chunks |
| AVIF | ravif EXIF, and XMP as a HEIF/ISOBMFF mime metadata item linked with iref/cdsc (ICC profile is not supported) |
| HEIC | libheif EXIF, XMP, and ICC metadata blocks |
| TIFF | TIFF/Exif IFD tags plus XMP (0x02BC), IPTC (0x83BB), and ICC (0x8773) in IFD0 |
For TIFF-like RAW sources, embedded metadata extraction follows IFD0, chained IFDs, SubIFD, ExifIFD, GPSIFD, and InteropIFD when locating XMP/IPTC/ICC blocks. Non-DNG RAW sidecar .xmp and .iptc files are also loaded when present.
RAW-derived PNG, AVIF, and TIFF output additionally projects camera-setting fields from EXIF into standards-based XMP, including ISO speed, max aperture, structured flash state, light source, exposure mode, metering mode, white balance, focal length, Exif 2.3 lens/body serial fields, image unique ID, user comment, GPS timestamp/status/speed/track/image direction, and related capture settings. Windows-readable MicrosoftPhoto XMP aliases are emitted for camera serial number, lens manufacturer, and lens model without replacing the standards-based exifEX values. EXIF ASCII text is copied from raw metadata values instead of formatter display strings, so generated wrapper quotes are avoided without changing source spacing or source quote characters.
PNG GPS metadata is stored in the standard eXIf chunk and projected into XMP iTXt for OS panels that prefer XMP. Latitude and longitude projections preserve the EXIF hemisphere references (N, S, E, W) when present, and altitude preserves GPSAltitudeRef. If a source XMP packet contains partial GPS coordinates without hemisphere suffixes, EXIF-derived complete GPS values upgrade the PNG XMP/text projection.
TIFF → HEIC performs a two-way OS metadata projection before HEIC encoding: TIFF XMP camera/GPS/lens fields are materialized into canonical EXIF ExifIFD/GPSIFD tags for OS readers that ignore HEIC XMP, while incomplete TIFF XMP is still supplemented from EXIF when needed.
ICC profile transfer is implemented per target container: JPEG uses APP2 ICC_PROFILE, PNG uses iCCP, WebP uses RIFF ICCP, HEIC uses libheif raw colour profiles, and TIFF uses tag 0x8773. AVIF does not support ICC profile embedding due to ravif limitations.
Verified RAW OS-level metadata routes: RAW (DNG, CR2, NEF, ARW, PEF, SR2) → PNG, AVIF, and TIFF are currently OK for both XMP-sidecar and embedded-only RAW metadata, with future refinement expected as more camera-specific samples are validated.
Verified-stable metadata routes (15, treated as protected — do not change unless a task explicitly targets them): JPEG → WebP, JPEG → HEIC, PNG → JPEG, PNG → WebP, PNG → HEIC, WebP → JPEG, WebP → HEIC, AVIF → JPEG, AVIF → WebP, AVIF → HEIC, HEIC → JPEG, HEIC → WebP, and RAW → JPEG, HEIC, WebP.
A further 20 routes are verified OS-readable with future refinement expected, and TIFF → HEIC is tracked as still improving.
The full route status note is maintained in docs/metadata-route-status.md, with matching code markers in src/convert/metadata/mod.rs.
Cross-format Metadata Transfer Matrix
| Source → Output | EXIF | XMP | IPTC | ICC |
|---|---|---|---|---|
* → JPEG |
✓ | ✓ | ✓ | ✓ |
* → PNG |
✓ | ✓ | ✓ | ✓ |
* → WebP |
✓ | ✓ | — | ✓ |
* → AVIF |
✓ | ✓ | — | — |
* → HEIC |
✓ | ✓ | — | ✓ |
* → TIFF |
✓ | ✓ | ✓ | ✓ |
Source formats: JPEG, PNG, WebP, AVIF, HEIC, TIFF, and Camera RAW (DNG, CR2, NEF, ARW, PEF, SR2).
Developer-facing technical details (click to expand)
- AVIF XMP is injected as a
mimeitem withcontent_type = "application/rdf+xml", linked to the primary image viairef/cdsc. All file-relativeilocoffsets are shifted by the meta growth delta. - AVIF ICC profile embedding is not supported due to
ravifencoder limitations. - TIFF metadata uses a custom relocator that appends a new IFD0 at end-of-file and updates the TIFF header pointer without touching image data.
- EXIF-to-XMP generation covers
tiff:Make,tiff:Model,tiff:ImageDescription,tiff:Software,tiff:DateTime,tiff:Artist,tiff:Copyright,exif:DateTimeOriginal,exif:DateTimeDigitized,exif:ExposureTime,exif:FNumber,exif:FocalLength,exif:ISOSpeedRatings,exif:ExposureProgram,exif:MeteringMode,exif:Flash,exif:WhiteBalance,exif:SceneCaptureType,exif:GPSLatitude,exif:GPSLongitude,exif:GPSAltitude,exifEX:CameraOwnerName,exifEX:BodySerialNumber,exifEX:LensSpecification,exifEX:LensMake,exifEX:LensModel,exifEX:LensSerialNumber, WindowsMicrosoftPhotocamera/lens aliases, and additional camera-setting fields. build_compact_exif_tifffilters 40+ TIFF structural tags (NewSubFileType,ImageWidth,Compression,SubIFDs, etc.) inappropriate for non-TIFF containers.- Added encode-level AVIF XMP regression test.
- Added
docs/metadata-route-status.mdand code-level route markers for stable and OS-verified metadata paths. - Release publishing runs rustfmt, library tests, and clippy. Dependency auditing is handled as an internal review workflow, outside the public release script.
The official release (Full Bundle) requires NO installation. It includes all necessary runtime libraries (VS Redistributable + Dependencies), so it works out-of-the-box on any standard Windows 10/11 system.
For Manual Build / Compile from Source (Windows):
- Windows 10/11 (64-bit)
- Rust toolchain (stable, MSVC target)
- Install via
rustup. The main app is built with the Windows MSVC Rust target because the current dependency bundle uses thex64-windowsvcpkg triplet and MSVC runtime DLLs.
- Install via
- MSVC linker toolchain
- Visual Studio 2022 Build Tools (or Visual Studio 2022) with C++ build tools + Windows SDK. This is primarily for the Rust/MSVC target and any vcpkg ports that need to compile from source.
- Git and CMake
- Required by the standard vcpkg bootstrap workflow.
- MinGW/GCC
- Required when
build_release_windows.batneeds to rebuilddcraw.exefromdcraw\dcraw.c. The script callsgccdirectly and skips this step only when the existingdcraw.exeanddcraw.exe.sha256hash match.
- Required when
- Standalone vcpkg installation (required for HEIC and AVIF on Windows)
- vcpkg must be installed separately (outside Visual Studio) for CLI/manual builds.
- Install and bootstrap:
git clone https://github.com/microsoft/vcpkg.git cd vcpkg .\bootstrap-vcpkg.bat
- Set environment variable:
set VCPKG_ROOT=D:\path\to\vcpkg
- Install port(s):
vcpkg install libheif[hevc]:x64-windows vcpkg install dav1d:x64-windows vcpkg install pkgconf:x64-windows
For Running Bare EXE / Minimal Distribution (without full bundle):
- Microsoft Visual C++ Redistributable (x64)
- Required HEIC/AVIF DLLs copied near the executable (
heif.dll,libde265.dll,libx265.dll,dav1d.dll) - No runtime
dcraw.exesidecar is required for current buildsdcraw.exeis embedded into the Rust executable at compile time and extracted to a verified temporary file when RAW conversion runs. Manual source builds still needdcraw.exeanddcraw.exe.sha256in the repository root beforecargo build.
Building from a fresh clone:
dcraw.exeanddcraw.exe.sha256are gitignored, butconstants.rsandconvert/dcraw.rsembed them withinclude_str!/include_bytes!. A clone without them will fail to compile. Generate the pair first with thegcccommand below, or runbuild_release_windows.bat, which does it automatically.
Versions below are the requirements declared in Cargo.toml; the exact resolved versions
are pinned by the committed Cargo.lock. C-library versions are recorded in
docs/ARCHITECTURE.md §10.5.
| Crate | Version | Purpose |
|---|---|---|
| iced | 0.12.1 | GUI framework (Windows build with default wgpu renderer) |
| image | 0.25 | Image decoding/encoding |
| mozjpeg | 0.10.13 | High-quality JPEG compression |
| oxipng | 10.1.1 | PNG optimization |
| webp | 0.3.1 | WebP encoding |
| libheif-rs | 2.7 | HEIC/HEIF encoding & decoding |
| ravif | 0.13 | AVIF encoding |
| rgb | 0.8 | AVIF pixel buffer handling |
| imgref | 1.12 | AVIF pixel buffer views |
| png | 0.18.1 | PNG encoding (raw container) |
| jpeg-encoder | 0.7.1 | JPEG fallback encoder |
| img-parts | 0.4.0 | JPEG/PNG metadata container |
| rfd | 0.17.2 | Native file dialogs |
| tokio | 1.53 | Async runtime |
| tracing | 0.1 | Structured logging |
| tracing-subscriber | 0.3 | Log formatting & filtering |
| anyhow | 1.0 | Ergonomic error handling |
| thiserror | 2.0 | Typed error definitions |
| bytes | 1.12 | Byte buffer utilities |
| serde / serde_json | 1.0 | Preset and settings serialization |
| mimalloc | 0.1 | Fast memory allocator |
| uuid | 1.24 | Unique temp filenames |
| exif (kamadak-exif) | 0.6.1 | EXIF metadata parsing |
| little_exif | 0.6 | EXIF writing for TIFF paths |
| sha2 | 0.11 | SHA-256 integrity checks |
| embed-resource | 3.0.11 | Windows resource compilation (build dep) |
| rusqlite | 0.40.1 | Settings persistence (SQLite) |
| fast_image_resize | 6.1.0 | High-performance resizing |
| ico | 0.5 | Windows ICO generation |
| zip | 8.6 | ZIP packaging for icon output |
Before building, ensure you have:
-
Rust Toolchain (stable)
rustup update stable
-
Git
-
CMake
-
Windows MSVC target / linker tools
The main executable is built for the Windows MSVC Rust target and uses vcpkg
x64-windowscodec/runtime DLLs. -
MinGW/GCC
Ensure
gccis available inPATHif you want the release script to rebuilddcraw.exe. Existingdcraw.exebuilds are reused when the hash indcraw.exe.sha256matches. -
Windows users: complete vcpkg setup below.
Install vcpkg and the required ports:
# 1. Clone vcpkg
git clone https://github.com/microsoft/vcpkg.git C:\vcpkg
C:\vcpkg\bootstrap-vcpkg.bat
# 2. Install dependencies
C:\vcpkg\vcpkg install libheif[hevc]:x64-windows
C:\vcpkg\vcpkg install dav1d:x64-windows
C:\vcpkg\vcpkg install pkgconf:x64-windows
# 3. Set environment variable (permanently via System Settings, or per-session)
$env:VCPKG_ROOT = "C:\vcpkg"A dedicated script is available to automate the verified release build process, including dependency bundling:
- Ensure
VCPKG_ROOTenvironment variable is set. - Ensure
gccis available inPATHifdcraw.exemay need to be rebuilt. - Run
build_release_windows.bat.
The fully portable distribution will be created in the build_release_windows folder, including:
- The executable and all required DLLs
- A pre-created
data/folder for settings and presets - The cleanup script for resetting settings
During release packaging, build_release_windows.bat verifies dcraw.exe against dcraw.exe.sha256. If the executable is missing or the hash changed, the script rebuilds it with MinGW/GCC:
gcc -O3 -DNO_JASPER -DNO_JPEG -DNO_LCMS -w -o dcraw.exe dcraw\dcraw.c -lm -lws2_32If gcc is unavailable and dcraw.exe cannot be reused, the release can still build the main app, but RAW conversion will not be available in that bundle.
If you are building manually outside the automated batch script, set the following environment variables so Cargo can locate the vcpkg-provided pkgconf and library metadata:
# PowerShell
$env:PKG_CONFIG = "$env:VCPKG_ROOT\installed\x64-windows\tools\pkgconf\pkgconf.exe"
$env:PKG_CONFIG_PATH = "$env:VCPKG_ROOT\installed\x64-windows\lib\pkgconfig":: CMD
set PKG_CONFIG=%VCPKG_ROOT%\installed\x64-windows\tools\pkgconf\pkgconf.exe
set PKG_CONFIG_PATH=%VCPKG_ROOT%\installed\x64-windows\lib\pkgconfigThese variables are automatically configured when you run
build_release_windows.bat.
# Development
cargo build
# Release (optimized)
cargo build --releaseThe executable will be at:
- Windows:
target/release/image-converter-windows-app.exe
# Check
cargo check
# Lint
cargo clippy --all-targets -- -D warnings
# Test (conversion pipeline only, no GUI)
cargo test --lib
# Run debug build
cargo run
cargo testneeds the vcpkg DLLs onPATH. The test binary hard-importsheif.dllanddav1d.dll, so without them the run fails withSTATUS_DLL_NOT_FOUND(0xc0000135) before a single test executes — that is aPATHproblem, not a broken build:$env:PATH = "$env:VCPKG_ROOT\installed\x64-windows\bin;$env:PATH"
Recommended: Use build_release_windows.bat to automatically bundle all required files.
If building manually, copy these runtime files to the same folder:
| File | Required |
|---|---|
image-converter-windows-app.exe |
Yes |
heif.dll |
For HEIC support |
libde265.dll |
For HEIC support |
libx265.dll |
For HEIC support (Hard Dependency) |
dav1d.dll |
For AVIF support |
vcruntime140.dll |
Visual C++ Runtime |
vcruntime140_1.dll |
Visual C++ Runtime |
msvcp140.dll |
Visual C++ Runtime |
DLLs are located in vcpkg/installed/x64-windows/bin/ and System32. If
msvcp140_1.dll, msvcp140_2.dll, or concrt140.dll exist on the build machine, the
release script copies those too as forward compatibility; they are not required today.
HEIC needs the whole folder. The executable imports
heif.dll, which in turn importslibx265.dllandlibde265.dll. Moving the.exeout of the release folder on its own breaks HEIC, and antivirus quarantine oflibx265.dll(~5 MB) looks identical. The app checks this at startup and reports it in the status bar instead of failing silently partway through a batch.
build_release_windows.bat fails closed: if any required file is missing after copying,
packaging aborts rather than producing a ZIP that only works on the build machine.
For RAW support in a manual build, keep dcraw.exe and dcraw.exe.sha256 in the repository root before compiling. The compiled application embeds that binary and verifies it at runtime; it does not search for dcraw.exe beside the installed executable.
The application separates concerns into two state layers to improve testability and enable safe destructive-action confirmation:
- UiState (15 fields) — Ephemeral UI interactions: the Win32 window handle, the open native dialog, drag-and-drop indices,
status_message,pending_confirmation, theme toggle, and the preset-manager overlay state (search, tab, folders). - DomainState (10 fields) — Business logic:
files,selected_indices,is_processing,options,presets,batch_offset,inactive_snapshot,reference_aspect_ratio,active_progress,is_simple_mode.
Destructive actions such as Delete Selected and Clear List trigger a confirmation dialog via the PendingAction enum before execution.
Switching between Simple and Advanced mode preserves the inactive mode's files, selected_indices, and options in a ModeSnapshot, so neither mode's queue is lost when toggling. Field-by-field tables are in docs/ARCHITECTURE.md §3.
├── app_metadata.toml # Metadata configuration (single source of truth for app name/publisher)
├── build.rs # Builds Windows resource files and compiles app_metadata.toml
├── src/
│ ├── main.rs # Application entry point
│ ├── error.rs # Structured conversion error types (ConversionError enum)
│ ├── components/ # Reusable UI components (header, file list, options panel, preset manager, etc.)
│ ├── handlers/ # Message handlers (files, options, presets, batch, database)
│ ├── view.rs # Main UI layout assembly
│ ├── convert/ # Image conversion engine
│ │ ├── mod.rs # Conversion pipeline orchestration
│ │ ├── heic.rs # libheif runtime probe and HEIC decoding
│ │ ├── dcraw.rs # Embedded RAW decoder subprocess
│ │ ├── integrity.rs # SHA-256 verification for bundled binaries
│ │ ├── encode/ # Format-specific encoders
│ │ │ ├── mod.rs # EncodeParams: quality, chroma and effort policy
│ │ │ ├── avif.rs # AVIF encoding (ravif) + ISOBMFF XMP injection
│ │ │ ├── jpeg.rs # JPEG encoding (mozjpeg + fallback) + metadata embedding
│ │ │ ├── png.rs # PNG encoding (png crate + oxipng) + metadata chunks
│ │ │ ├── webp.rs # WebP encoding (webp crate) + VP8X metadata flags
│ │ │ ├── heic.rs # HEIC encoding (libheif-rs handles colour conversion)
│ │ │ └── tiff.rs # TIFF encoding (image crate) + IFD0 tag injection
│ │ ├── metadata/ # Metadata extraction per format
│ │ │ ├── mod.rs # Metadata struct and main dispatcher (extract_metadata_from_bytes)
│ │ │ ├── exif.rs # EXIF helpers (orientation patch, normalize, strip prefix)
│ │ │ ├── privacy.rs # GPS and device-serial removal for Social intent
│ │ │ ├── xmp_iptc.rs # XMP sidecars, IPTC from XMP, Photoshop APP13 parser
│ │ │ ├── jpeg.rs # JPEG metadata extraction (APP1/APP13/APP2 ICC)
│ │ │ ├── png.rs # PNG metadata extraction (eXIf, iTXt, tEXt, zTXt)
│ │ │ ├── webp.rs # WebP metadata extraction (EXIF, XMP, ICC chunks)
│ │ │ ├── isobmff.rs # ISOBMFF metadata extraction (HEIC/AVIF EXIF, XMP, ICC)
│ │ │ ├── tiff.rs # TIFF/RAW EXIF extraction and compact TIFF builder
│ │ │ └── icc.rs # ICC profile extraction across all supported formats
│ │ ├── transform.rs # Orientation correction, crop, resize
│ │ └── utils.rs # Shared conversion utilities, PixelSource
│ ├── lib.rs # Public module re-exports (test/library surface)
│ ├── state.rs # Application state split into UiState + DomainState
│ ├── settings.rs # SQLite persistence with WAL and atomic transactions
│ ├── status_message.rs # Shared status-message classification and formatting
│ ├── theme.rs # Color palette, spacing, and typography tokens
│ ├── color.rs # Hex colour parsing shared by state and UI
│ ├── platform.rs # Exe-relative paths and Windows window-icon loading
│ ├── memory.rs # mimalloc heap collection hook
│ ├── message.rs # UI event definitions (ConfirmAction / CancelAction)
│ └── constants.rs # Application constants (includes OUT_DIR/metadata_generated.rs)
├── docs/
│ ├── ARCHITECTURE.md # Deep technical reference (layers, pipeline, build, pinning)
│ └── metadata-route-status.md # Per-route metadata status, mirrored by code markers
├── CHANGELOG.md # Release history
├── rust-toolchain.toml # Pinned Rust compiler version
└── vcpkg.json # Pinned C library versions (libheif, dav1d) via builtin-baseline
Icon generation lives in src/handlers/icon_generator.rs (engine) and
src/components/icon_generator.rs (UI).
Settings are stored in a portable data/ folder next to the executable using SQLite with WAL journaling for durability. Preset and settings saves are atomic (transaction-backed). The folder is created automatically on first run.
| Platform | Path |
|---|---|
| Windows | <executable_directory>/data/settings.db |
To reset settings, delete the data/ folder next to the executable or run scripts/cleanup_settings_windows.bat (Windows).
This project is licensed under the GNU General Public License v3.0 or later (GPL-3.0-or-later).
This application includes or links against the following libraries with their respective licenses:
- dcraw: Dave Coffin's custom license (embedded and runtime-extracted executable for RAW/DNG decoding). Non-Foveon processing code is free for all uses. Redistribution under GPL-2.0-or-later is explicitly permitted per the source header.
- libheif: LGPL-3.0 (dynamic linking via
heif.dll) - libde265: LGPL-3.0 (dynamic linking via
libde265.dll) - libx265: GPL-2.0+ (dynamic linking via
libx265.dll) - dav1d: BSD-2-Clause (dynamic linking via
dav1d.dll) - All other Rust dependencies: MIT / Apache-2.0 / BSD-3-Clause
Made with Rust and iced.