PaintFE is free & open source. No subscriptions. No telemetry. Just an image editor.   View on GitHub →
Built in Rust Free & Open Source

An image editor that stays out of your way.

PaintFE is a fast, native raster image editor. Single portable binary, GPU-accelerated, scriptable. Runs locally, no account needed, nothing phoning home. Download it once and it's yours.

Windows · Linux · macOS · Portable ~50 MB binary · wgpu · rayon · Rhai

What's under the hood.

The architecture choices that make PaintFE fast at 4K and lightweight on disk.

All 23 tools →

GPU-Accelerated Everything

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

wgpu WGSL Compute Dirty-Rect Readback COW Tiles

Written in Rust

No garbage collector. No JVM warmup. No Electron tax. Compiles to a slim native binary that starts in under a second.

Built because the developer wanted to learn Rust. What started as an experiment turned into something worth shipping.

edition = 2024  ·  wgpu 0.20  ·  rayon 1.7

Layers & 25 Blend Modes

Full layer stack, per-layer opacity, non-destructive compositing. 23 tools across paint, selection, warp, and utility groups. 15 languages built in.

Built-in Scripting

Automate anything with the embedded Rhai engine. Pixel loops, 23 effect functions, live canvas preview, CLI batch mode.

Local AI

Background removal via your own ONNX models. BiRefNet, U²-Net, IS-Net — auto-detected. Runs on your machine, offline, no API calls.

One AI feature. That's it.

PaintFE includes background removal via ONNX models. It runs locally, it's optional, and you supply the model yourself. Nothing is uploaded. Nothing is trained 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.

Not Magic

Background removal works best on clear subjects. PaintFE gives you the result as a layer you can refine by hand. It won't be perfect every time.

A note on AI and creative work

PaintFE doesn't generate images or replace anyone's work. The only AI feature is background removal — a time-saver for tedious masking, nothing more.

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!
}

Write a script. Watch it run.

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

What PaintFE is.

A fast raster image editor

GPU compositing, 4K at interactive frame rates, sub-second startup. Single portable binary.

Free and open source — actually

MIT licensed, no telemetry, no account required, no cloud, no "pro" tier. The full app ships for free.

Scriptable and automatable

Built-in Rhai scripting with pixel-level API, headless CLI batch mode, saveable custom effects.

Enough features to actually get things done

25 blend modes, 23 tools, RAW support, animated GIF/APNG, local AI background removal.

What it isn't.

Not a Photoshop replacement

No CMYK, no vector paths, no adjustment layers. If you need those, you need a different tool.

Not a plugin platform

Rhai scripts extend it, but there's no marketplace or third-party plugin ecosystem (yet).

Not trying to be everything

It's a solo project. It does what it does well, and the things it can't do aren't hidden behind a paywall — they just aren't there yet.

Reads & writes
PNGJPEG WebPBMP TIFFTGA GIFAPNG ICOCR2 NEFARW DNG.PFE

Built around 4K
from day one.

The rendering pipeline targets 4K canvases at interactive frame rates. The hot paths have been profiled and optimized one by one.

~1MB
dirty-rect readback
per brush stroke at 4K
CPU copies needed
for GPU texture upload
COW
copy-on-write tile system
for instant undo
N+
rayon multi-thread
CPU compositing
  • Dirty-rect partial readback. GPU only reads back the pixels that changed — a 40×40 brush stroke uploads ~6 KB instead of ~33 MB at 4K.
  • Zero-copy display. GPU readback bytes are cast directly to Color32 via bytemuck. No per-pixel conversion loop at any resolution.
  • Texture handle reuse. GPU textures are updated in-place with set_partial() rather than freed and reallocated each frame.
  • Async double-buffered readback. Ping-pong staging buffers mean GPU compositing and CPU readback overlap — no stalls during brush strokes.
download

Free, and staying that way.

MIT licensed. No trial period, no feature gates, no "pro" tier that locks away the good stuff. Download it, use it, share it.

Download for Windows Download for Linux Build from Source

MIT licensed  ·  No installer required  ·  Portable binary