Built in Rust Free Open Source GPU Accelerated Lightweight

The editor
that respects
your work.

PaintFE is a fast, lightweight, native raster image editor built in Rust. Single portable binary. No install, no subscription, no cloud. No AI generating your art without permission. Just a powerful, honest tool. Yours to keep.

Download for Free View Source → Scripting API

Windows · Linux · single portable .exe (~30 MB) · wgpu GPU pipeline · rayon parallel CPU · Rhai scripting · Local AI (BYOM)

Single binary under 30 MB. No installer, no internet connection, no telemetry, no auto-updater. Your files never leave your machine.

23 drawing tools 25 blend modes GPU-accelerated compositing Unlimited undo with COW tiles Rhai scripting engine CLI headless batch processing Local AI background removal GIF & APNG animation support RAW camera format support Brush tip library Mesh Warp with Catmull-Rom splines Zero subscriptions · zero telemetry 23 drawing tools 25 blend modes GPU-accelerated compositing Unlimited undo with COW tiles Rhai scripting engine CLI headless batch processing Local AI background removal GIF & APNG animation support RAW camera format support Brush tip library Mesh Warp with Catmull-Rom splines Zero subscriptions · zero telemetry

Why PaintFE

Purpose-built.
Performance-first.

Every design decision traces back to one question: does this help the artist do better work faster?

🦀

Written in Rust

No garbage collector pauses. No JVM warmup. No Electron tax. PaintFE compiles to a slim native binary that starts in under a second and runs at full CPU speed from frame one.

Honestly, the lead developer wanted to learn Rust and built this project to do it. What started as an experiment with the language and some new coding tools turned into something worth shipping.

edition = 2024 · wgpu 0.20 · rayon 1.7

⚡

GPU-Accelerated Everything

Compositing, gradient generation, liquify warping, and mesh warp displacement all run on GPU via WGSL compute shaders through the wgpu API. The GPU pipeline handles 4K canvases at interactive frame rates, with CPU fallbacks when no GPU is available.

wgpu WGSL Compute GPU Readback

🗂️

Layers & Blend Modes

Full layer stack with 25 blend modes: Normal, Multiply, Screen, Overlay, Soft Light, Difference, and many more. Per-layer opacity and non-destructive compositing.

🧠

AI That's Yours

Background removal via local ONNX models (BiRefNet, U²-Net, IS-Net). You bring the model, it runs on your machine. No API calls. No data leaves your computer.

💻

Built-in Scripting

Automate anything with the embedded Rhai scripting engine. Pixel loops, built-in filters, live canvas preview. All from a built-in code editor.

↩️

Memory-Efficient History

Copy-on-Write tiles mean undo snapshots only store what changed. A full-canvas snapshot at 4K takes ~36KB instead of ~64MB, making deep history practical even on modest hardware. Browse your history in the History panel and jump to any state instantly.

36KB

4K snapshot

blend modes

tools

🌍

15 Languages

Ships with full UI localization in English, German, French, Spanish, Italian, Portuguese, Russian, Japanese, Chinese (Simplified & Traditional), Polish, Dutch, Turkish, Belarusian, and more.

Toolset

Everything you expect.
Some things you don't.

All Tools →

Paint

Brush, Pencil, Eraser, Line, Fill, Gradient. Brush tip library, variable spacing, and soft/hard edges.

Select

Rect, Ellipse, Lasso (freeform), Magic Wand, Move Pixels, Move Selection. Add/subtract/intersect modes.

Warp

Warp & Retouch

Clone Stamp, Content-Aware Fill, Color Remover, Liquify, Mesh Warp (Catmull-Rom), Perspective Crop.

Utility

Color Picker, Text tool (system fonts), Zoom, Pan, 17 Shapes (ellipse, star, heart, and more).

AI Features

AI that earns its place.

PaintFE includes exactly one AI feature: background removal. It's local, optional, and you control everything. No cloud. No subscription. No model training on your images.

✓

Bring Your Own Model (BYOM)

Point PaintFE to any compatible ONNX model on your drive. BiRefNet, U²-Net, and IS-Net are all supported and auto-detected.

✓

Runs Entirely Locally

ONNX Runtime is loaded dynamically. Install it once and it works offline forever. Your images never leave your machine.

✓

Honest About Limitations

Background removal is a tool, not magic. It works best on clear subjects. PaintFE shows you the result as a layer you can refine. No false promises.

→

A note for creators

We know AI affects creators deeply. PaintFE's AI tools are strictly assistive: they help you remove backgrounds, not generate art. Your creativity remains yours.

AI background removal — before and after comparison

            
example.rhai

// Dramatic B&W with vignette
apply_desaturate();
apply_brightness_contrast(10.0, 40.0);
apply_vignette(0.5, 0.3);

// Custom per-pixel effect
map_channels(|r, g, b, a| {
    let warm_r = clamp(r + 15, 0, 255);
    let cool_b = clamp(b - 8, 0, 255);
    [warm_r, g, cool_b, a]
});

// Live preview while running
for i in 0..5 {
    apply_hsl(0.0, -5.0, 0.0);
    sleep(150); // canvas updates live!
}

Scripting

Automation without limits.

PaintFE embeds a full Rhai scripting engine. Write pixel manipulation scripts, chain filters, create custom effects, and watch them execute live on your canvas.

Effect API 23 built-in effect functions

Transform API Flip, rotate, resize — layer or canvas

Pixel API Per-pixel read/write & bulk iteration

Live Preview See canvas update in real-time via sleep()

Selection-Aware Scripts respect your current selection

Scripting Docs →

File Formats

Opens what you have.

PaintFE reads and writes industry-standard formats plus its own lossless project format.

Open & Edit

PNGJPEG WebPBMP TIFFTGA ICOGIF APNG.PFE Project

RAW Camera Formats

CR2NEF ARWDNG and more via rawloader

Export / Save As

PNGJPEG WebPBMP TIFFTGA ICOAnimated GIF APNG.PFE

vs. Others

Honest comparison.

PaintFE isn't trying to replace Photoshop or GIMP. It's its own thing: fast, native, scriptable, and free. No asterisks.

Feature	PaintFE	GIMP	Photoshop	Krita
Free & open source	✓	✓	✗	✓
Zero telemetry, fully offline	✓	✓	✗	✓
No account or login required	✓	✓	✗	✓
Portable single-file binary	✓	✗	✗	✗
Startup in <1 second	✓	✗	✗	⚬
Binary under 30 MB	✓	✗	✗	✗
Native binary (no JVM / Electron)	✓	✓	✓	✓
GPU-accelerated compositing	✓	⚬	✓	✓
Copy-on-write memory-efficient undo	✓	✗	✗	✗
Headless CLI batch processing	✓	⚬	⚬	✗
Built-in scripting with pixel API	✓	⚬	⚬	⚬
Local AI background removal	✓	✗	⚬	✗
Animated GIF & APNG export	✓	✓	✓	⚬
RAW camera format support	✓	✓	✓	✗
Mesh warp with spline interpolation	✓	✗	✓	✗
Windows & Linux	✓	✓	⚬	✓
Plugin / extension ecosystem	⚬	✓	✓	✓
CMYK color space	✗	⚬	✓	✗
Vector / path editing tools	✗	⚬	✓	✓

✓ = yes · ⚬ = partial / limited · ✗ = no · Reflects general feature availability, not quality comparison. "Portable single-file binary" = runs from a single .exe/.AppImage with no installer or runtime dependencies. "Plugin / extension ecosystem" = PaintFE supports importable, saveable Rhai scripts that function as custom effects; no third-party marketplace. "Built-in scripting with pixel API" = integrated code editor with direct canvas pixel access.

Performance

4K-ready.
No compromises.

PaintFE's rendering pipeline was designed around 4K from the start. Every bottleneck has been profiled and addressed.

~1MB

dirty-rect readback
per brush stroke at 4K

0×

CPU copies needed
for GPU texture upload

COW

copy-on-write tile system
for instant undo

N+

rayon multi-thread
CPU compositing

Deep Dive: Performance →

Dirty-Rect Partial Readback

GPU only reads back the pixels that changed. A 40×40 brush stroke uploads ~6KB instead of ~33MB at 4K.

bytemuck Zero-Copy Cast

GPU readback bytes are cast directly to Color32 via bytemuck. Zero CPU work for 4K (8.3M pixels).

TextureHandle Reuse

GPU textures are reused across frames via set_partial(). No allocation/deallocation churn or flicker.

Async GPU Readback

Double-buffered staging with ping-pong for non-blocking composite during interactive strokes.

The editor that respects your work.

Purpose-built.Performance-first.