Arte Ogre

A Rust-native, GPU-accelerated layered image editor.
Paint, composite, select, and cut out - with layers done right.
Fast Rust core · egui + wgpu GPU canvas · sparse tiled copy-on-write engine · no telemetry · GPL-3.0-only.

---

What is Arte Ogre?

Arte Ogre is a desktop image editor built around one promise most editors break: layers keep their exact position. Rectangle-select a region, right-click, and Cut/Copy to New Layer drops the content onto a fresh layer at its exact original canvas coordinate - pixel for pixel. That guarantee falls out of the data model (sparse tiled copy-on-write buffers), not UI bookkeeping.

It is built around three goals:

• GPU-native. The whole document composites on the GPU through wgpu, sharing the same device as the UI for a zero-copy canvas, and recomposites only the dirty tiles per edit - so a deep layer stack stays interactive.
• Correct by construction. 32-bit float RGBA, straight alpha, linear light. Every GPU result is golden-tested against a CPU reference compositor within 1e-4 per channel; the killer cut/copy feature is pinned by a byte-identical round-trip test.
• Private by default. No telemetry. Editing stays local. Network access happens only when you explicitly check for updates or ask the optional AI background-refine feature to download its model.

What it does today

• Layers - raster, groups, blend modes, opacity, non-destructive ordering; cheap duplicate and undo via copy-on-write tiles.
• Bird's Eye View - a full-workspace layer organizer: view every open document as a card, reorder root layers by dragging thumbnails, move or copy layers between documents, and double-click a thumbnail to jump back to the editor with that layer active.
• Selection - Rectangle, Ellipse, Polygon, Freehand, and Magnetic Lasso; Magic Wand and Quick Selection; marching-ants outlines; selection arithmetic, feather/grow/shrink, clipboard actions, and exact-position Copy/Cut to a new layer.
• Paint - brush, pencil, eraser (pressure-aware), paint bucket, eyedropper, tiled brush/stroke rasterization, and brush-engine tools for clone/heal, blur/sharpen/smudge, dodge/burn/sponge, and color replacement.
• Vector - Shape, Pen, and Type create non-destructive, re-editable vector layers (a per-tool Vector/Pixels toggle); select a vector layer to load it back into the tool and edit in place.
• Transform - move, crop, and free transform with scale, rotate, skew, distort, perspective, and warp modes.
• Remove Background - lift a solid or checkerboard "fake transparency" matte to true alpha, losslessly, with edge defringe - plus an optional AI matte refine (IS-Net via pure-Rust ONNX) for fine hair.
• Filters & color - GPU compute filters with a CPU fallback; ICC color via lcms2.
• Files - native .ogre (zstd tiles + msgpack), .ora interchange, PSD import, EXR / TIFF / PNG / JPEG / WebP raster I/O, BMP import, and SVG import/export via resvg/usvg. See the format compatibility guide before interchange work.
• Extensible - sandboxed, undoable tile filters through wasmtime and document scripts through mlua, with fuel, instruction, memory, and timeout limits. See the plugin author guide.

---

Quick start

Arte Ogre currently targets Linux with a Vulkan-capable GPU.

1. Download the AppImage from the latest release.
2. Make it executable: chmod +x Arte_Ogre-x86_64.AppImage.
3. Run it: ./Arte_Ogre-x86_64.AppImage.
4. Use File → New or File → Open. Save layered work as .ogre; use Export for a flattened deliverable.

The current renderer and native loader support canvases up to 8192×8192. Read the user guide for the full interface, tools, shortcuts, recovery, privacy, and limits.

---

Setup (build from source)

Arte Ogre is a standard Cargo workspace.

Prerequisites

• Rust toolchain (2021 edition).
• A Vulkan-capable GPU and drivers (Linux; wgpu selects Vulkan).
• For the AppImage: linuxdeploy and appimagetool on PATH, plus ImageMagick (magick) for icon resizing.

Build & run

git clone https://github.com/visorcraft/Arte-Ogre.git
cd Arte-Ogre

cargo run -p ogre                 # launch the editor (eframe + wgpu)

Arte Ogre currently has no command-line file or option interface. Open files with File → Open or drag one into the window. Drag-and-drop requires X11.

Quality gate (run before any commit; warnings are hard errors)

cargo test   -p <crate>
cargo clippy -p <crate> --all-targets -- -D warnings
cargo fmt    --check
cargo doc    -p <crate>          # use --no-deps to skip dependency docs

scripts/gate.sh wraps test + clippy + fmt for ogre-core.

After dependency changes, regenerate the third-party attribution files:

scripts/licenses.sh   # requires cargo-about

---

Install

The release build packages into a single-file AppImage installed under ~/.local/bin without root. Prefer the helper script once the one-time tools are on PATH:

# One-time: linuxdeploy + appimagetool (continuous static builds) + ImageMagick
curl -L https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage -o ~/.local/bin/linuxdeploy
curl -L https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage -o ~/.local/bin/appimagetool
chmod +x ~/.local/bin/linuxdeploy ~/.local/bin/appimagetool

scripts/build_appimage.sh          # → target/appimage/Arte_Ogre-x86_64.AppImage
install -Dm755 target/appimage/Arte_Ogre-x86_64.AppImage ~/.local/bin/arte-ogre

Manual equivalent (same layout the script builds):

cargo build --release -p ogre
rm -rf AppDir && mkdir -p AppDir/usr/bin AppDir/usr/share/applications \
  AppDir/usr/share/icons/hicolor/256x256/apps
cp target/release/ogre AppDir/usr/bin/arte-ogre
magick assets/ArteOgre.png -resize 256x256 \
  AppDir/usr/share/icons/hicolor/256x256/apps/arte-ogre.png
cat > AppDir/usr/share/applications/arte-ogre.desktop <<'EOF'
[Desktop Entry]
Name=Arte Ogre
Exec=arte-ogre %F
Icon=arte-ogre
Type=Application
Categories=Graphics;2DGraphics;RasterGraphics;
Comment=GPU-native image editor
Terminal=false
StartupWMClass=arte-ogre
MimeType=image/png;image/jpeg;image/webp;image/avif;image/tiff;image/x-ora;
EOF
# NO_STRIP=1 is required where libraries use DT_RELR relocations.
NO_STRIP=1 linuxdeploy --appdir AppDir \
  --desktop-file AppDir/usr/share/applications/arte-ogre.desktop \
  --icon-file AppDir/usr/share/icons/hicolor/256x256/apps/arte-ogre.png \
  --output appimage   # → Arte_Ogre-x86_64.AppImage

install -Dm755 Arte_Ogre-x86_64.AppImage ~/.local/bin/arte-ogre

Wayland title-bar icon. Wayland has no per-window icon protocol - the compositor takes the icon from a desktop entry matching the window's app_id (arte-ogre). Install the same .desktop + icon into your data dir so it resolves: copy arte-ogre.desktop to ~/.local/share/applications/ and the 256×256 icon to ~/.local/share/icons/hicolor/256x256/apps/arte-ogre.png.

After install, launch with arte-ogre, then use File → Open.

Linux backend. Defaults to winit's native backend (Wayland on a Wayland session - smooth resize). Set ARTE_OGRE_X11=1 to force X11/XWayland, the only backend with file drag-and-drop. File → Open works on both.

---

The stack

Layer	Choice
Language	Rust 2021, Cargo workspace
UI shell	egui + eframe + egui_dock
Graphics	wgpu (Vulkan on Linux), WGSL shaders via naga
Layer engine	sparse tiled copy-on-write buffers · 32-bit float RGBA (linear) · per-layer offset
Compositing	wgpu passes · blend modes as shaders · dirty-tile updates
Vector / brush	lyon · kurbo · cosmic-text
I/O	image, psd, exr, tiff · native .ogre (zstd + msgpack) · .ora · SVG
Color	lcms2 (ICC)
AI matte	IS-Net via pure-Rust ONNX (tract), optional ml feature
Plugins	wasmtime (WASM) + mlua (Lua), sandboxed
Version	Workspace crates at 1.8.2 (see Cargo.toml members)

The crates form one dependency chain: ogre-core → ogre-gpu → ogre-ui → ogre (binary), with ogre-io, ogre-plugins, and ogre-vector alongside. ogre-core is the headless ground truth and is #![deny(unsafe_code)]. There are no JavaScript packages; third-party Rust crates and assets are listed in CREDITS.md and THIRD_PARTY_LICENSES.md (regenerate with scripts/licenses.sh after dependency changes).

---

Contribute

Patches, bug reports, and design feedback are welcome. See CONTRIBUTING.md for the full workflow, coding standards, and the engine invariants every change must respect.

• Fork on GitHub, branch from master, send a PR.
• Run the per-crate quality gate before pushing - it must pass with zero warnings.
• Arte Ogre is GPL-3.0-only. Development follows a TDD, checkbox-driven flow (write test → verify fail → implement → verify pass).

Found a vulnerability? Please follow the security policy - don't open a public issue.

---

Documentation

• User guide - install, interface, every tool family, layers, selections, shortcuts, settings, recovery, privacy, and limits.
• File formats - open/save/export matrix, fidelity, color handling, and known interchange limits.
• Architecture - crate map, data model, coordinates, mutation flow, rendering, workers, and correctness invariants.
• Plugin author guide - bundle format, Lua API, WASM ABI, sandbox limits, installation, and debugging.
• Troubleshooting - GPU startup, Wayland/X11, recovery, model downloads, plugins, and diagnostics.
• Contributing - development setup, test matrix, coding rules, and release packaging.
• Security policy - supported versions, private reporting, scope, network behavior, and hardening.
• Credits and third-party licenses.

---

Licence

Arte Ogre is licensed under the GNU General Public License v3.0 only.