Luxe A simple, opinionated RAW photo editor, powered by darktable's image-processing engine.

Luxe is a desktop photo editor built with Godot 4. Instead of reimplementing RAW processing from scratch, it embeds darktable's real pixel pipeline in-process through a small C++ GDExtension, so every slider you drag is processed by the same code darktable's own darkroom uses.

• What is Luxe
• Screenshots
• Features
• Getting started
• How it works
• Roadmap
• Contributing
• License

Luxe is a RAW photo editor with a deliberately small surface. You open a file, drag a handful of well-chosen sliders, and export. There is no module browser, no plugin marketplace, and no wall of technical settings: just the adjustments that actually move a photograph.

Under the hood it is darktable. Luxe runs darktable's core library (lib_darktable) inside the same process as the editor and drives its pixel pipeline directly, so the preview you see and the file you export are produced by darktable's genuine processing code, not an approximation. The frontend is Godot, which gives us a fast, GPU-accelerated, cross-platform UI shell.

The result is a small, fast editor with a serious processing engine underneath.

Available for macOS (Apple Silicon), Linux (x86_64), and Windows (x86_64).

• Library: add folders from disk and browse every supported image in them (arrow keys to move around, Enter or double-click to open in the editor)
• Reject flags: mark photos you want to cull with the x key or the Reject button (in the Library grid, or the matching button in the editor's floating corner cluster); rejected photos are dimmed in the grid, can be hidden entirely with "Hide Rejected", and the flags persist across restarts. In the editor, Left/Right arrows step through the folder's keepers, skipping rejected photos.
• Non-destructive edits: your adjustments save automatically and come back the next time you open the photo, even after restarting the app (edited photos are flagged with a yellow dot in the Library grid)
• Filmstrip: a collapsible, resizable strip of thumbnails below the editor for quickly jumping between photos in the current folder
• Before/after compare: hold Space (or the Before button) to see the photo as shot, without your edits
• Histogram at the top of the edit panel, plus a clipping overlay toggle (Clipping button or J: red = blown highlights, blue = crushed shadows)
• Focus peaking toggle (Peaking button or K): in-focus edges highlighted green
• Responsive layout (Android builds only): on narrow or portrait screens the editor stacks the photo above the sliders and the Library stacks folders above the grid
• Exposure
• Contrast
• Highlights
• Shadows
• Blacks
• Whites
• Saturation
• Vibrance
• Tone curve
• Dehaze
• Sharpening
• Noise reduction
• White balance
• Crop
• Straighten (w/ auto-crop support)
• Rotate (90° left/right)
• Export

The UI also gives you:

• Edit resolution (25% - 100%)
  • Chooses the resolution the pipeline actually processes at
  • Lower is meaningfully faster
  • Dynamically chosen to keep editing fast when importing
• Display zoom and pan
  • a continuous 10%-400% zoom plus Fit, decoupled from edit resolution
  • a Navigator panel showing a bird's-eye of the photo with a viewport box you can drag to pan
• Library selection and batch export
  • click, Shift-click (range), Cmd-click (toggle), Cmd+A (all), Esc (clear)
  • Export… writes the selection, or whole libraries when nothing is selected, as JPEG/PNG/TIFF with saved edits applied
  • per-format quality (JPEG quality, 8/16-bit PNG/TIFF), long-edge resize, color space (sRGB, Display P3, Adobe RGB, ProPhoto), EXIF on/off, with a progress dialog and cancel
• Light and dark themes

v0.1.5 -- Navigator, filmstrip, before/after compare, sharpening & noise reduction

v0.1.4 -- Library view, non-destructive persistent edits, reject/approve workflow, Windows support

v0.1.3 -- Speed up edits by 5x, add advanced sliders, add Crop

v0.1.2 -- Add extra sliders

v0.1.1 -- light/dark theme system and macOS export.

v0.1 -- the first editor shell: open a RAW, drag exposure, watch the preview re-render live.

• macOS on Apple Silicon is the currently supported development platform.
• Godot 4.6 (targets 4.6.beta3).
• Python 3 + SCons (pip install scons).
• A C++ toolchain (Xcode Command Line Tools: xcode-select --install).
• A darktable build and godot-cpp

Building darktable

Luxe does not vendor darktable; the extension is built against your own darktable checkout. Build a headless configuration of darktable from source (see darktable's build docs) and place the checkout as a source/ directory beside this repo, so the relative paths in project/project.godot resolve.

Building the GDExtension

Clone the branch matching this repo's Godot version and build both targets:

git clone --branch 4.5 --depth 1 https://github.com/godotengine/godot-cpp extension/godot-cpp
cd extension/godot-cpp
scons target=template_debug arch=arm64

Then build the C++ shim itself:

cd extension
scons arch=arm64
scons arch=arm64 target=template_debug

The build writes compiled frameworks into project/bin/, which project/dt_backend.gdextension points at.

Android (arm64, experimental)

Requires JDK 17, the Android SDK and NDK 28.1 installed. The app reads photos from /sdcard/Pictures and /sdcard/DCIM and needs "All files access". On Android, RAW thumbnails only appear after a photo is opened.

Godot knows nothing about RAW processing and darktable knows nothing about Godot, so a GDExtension bridges them: one C++ class, DtBackend, that GDScript can call.

• GDScript calls plain methods like backend.set_exposure(1.5) or backend.export_image("out.jpg").
• DtBackend translates each call into the actual darktable C API calls that darktable-cli uses internally.
• Everything runs in one process and one memory space. No sockets, no IPC, no serializing image data across a boundary.

flowchart LR
    UI["GDScript UI"] --> BE["DtBackend<br/>(C++ GDExtension)"]
    BE --> DT["darktable core<br/>(headless)"]
    DT --> UI

The internals of the bridge are not documented here; read the source if you're curious. It is single-session (one image open at a time) and keeps the UI responsive while the pipeline runs.

• More adjustments: selected darktable IOP modules plus purpose-built Luxe tools. Darktable modules with masks, drawn shapes, splines, or color pickers need real custom UI first.
• A universal (arm64 + x86_64) GDExtension build.

Contributions are welcome. See CONTRIBUTING.md for the full guide. The short version:

1. Read Getting started and build darktable, godot-cpp, and the GDExtension.
2. Run scripts/smoke_test.sh to confirm the pipeline works end to end.
3. Install the tracked git hooks once after cloning: scripts/install-hooks.sh. The pre-commit hook rebuilds the GDExtension when its sources change and then runs every backend smoke test (scripts/*smoke_test*.sh), aborting the commit on a build or test failure.
4. Keep changes focused, make sure the smoke tests pass, and explain the "why" in the commit message.

Tests live under project/tests/, split by what they need to run:

• unit/ — backend-free pure-logic tests (EditStore, Library, RejectStore, UiState, Filmstrip). Run on a bare Godot binary via scripts/run_unit_tests.sh; these are what CI runs on every push/PR.
• feature/ — per-adjustment tests driving the real darktable backend. Run in parallel via scripts/feature_smoke_tests.sh (needs a darktable build).
• pipeline/ — the RAW→PNG oracle (smoke_test.sh) and the full-UI end-to-end regression (e2e_smoke_test.sh).

Each runner globs its directory, so a new *_smoke_test.gd dropped into the right folder is picked up automatically with no list to update.

Luxe is free software, released under the GNU General Public License, version 3 or (at your option) any later version (GPL-3.0-or-later). See LICENSE for the full text.

• darktable, which Luxe embeds and links against as its image-processing engine, is licensed under GPL-3.0 (see NOTICE).
• godot-cpp, which provides the C++ bindings for the GDExtension, is licensed under the MIT License and is not covered by Luxe's GPL-3.0 licensing.

Because Luxe links against GPLv3 darktable, the combined work is distributed under the GPL. By contributing, you agree to license your contributions under GPL-3.0-or-later.