RapidRAW: a GPU-accelerated RAW editor built on Tauri, Rust and wgpu

What RapidRAW solves, and who it is actually for

The README describes RapidRAW as "a modern, high-performance alternative to Adobe Lightroom" and says it is aimed at photographers who want a "clean, fast, and simple workflow". That is a narrower claim than it first looks. The project is not trying to match Lightroom's catalogue, cloud sync or print module. It is trying to make the core loop of RAW editing, open a file, adjust it, see the result immediately, export it, feel fast on ordinary hardware.

The author states he started the project as a personal challenge at 18, to build a tool for his own photography workflow while learning React, WGSL and Rust. That origin explains the shape of the product: a small download (the README puts it under 20MB), a heavy GPU pipeline, and a feature set that grows release by release rather than following a published roadmap. It also explains the honest disclaimer in the README itself: RapidRAW "is still in active development and isn't yet as polished as mature tools like Darktable, RawTherapee, or Adobe Lightroom", and users "may encounter bugs".

So the audience is the hobbyist or semi-professional who edits their own shoots, wants something lighter than Darktable's interface, and is comfortable with a tool that changes every couple of weeks. It is not a fit for a team that needs stable behaviour across a five-year archive.

The Tauri, Rust and wgpu split, and where edits live

The repository layout shows the architecture clearly. The frontend lives in src/ and is a React 19 application built with Vite; the native shell and image pipeline live in src-tauri/. The package manifest lists @tauri-apps/api, @tauri-apps/plugin-dialog, @tauri-apps/plugin-os, @tauri-apps/plugin-process and @tauri-apps/plugin-shell as the bridge to the Rust side, plus konva and react-konva for canvas interaction, zustand for state, and react-window for virtualised lists.

The rendering itself is not done in JavaScript. The README's badges name wgpu, and the release notes refer to a "WGSL shader" and a "scene-referred V-Log color pipeline" for the built-in film emulations added on 2026-08-17. WGSL is the WebGPU shading language, so the adjustments run as GPU shaders rather than as CPU loops over pixel buffers. That is the mechanism behind the speed claim: a slider change re-runs a shader over the image instead of re-processing it on the CPU.

Non-destructive editing is the other half. The release notes for 2026-08-29 mention "folder-level EXIF caching" and "prevent redundant adjustment saves", which indicates adjustments are stored separately from the source file and written when they change. The README does not document the sidecar file format or where the adjustment data is kept, so if you need to know exactly what gets written next to your originals, that is something to check on disk rather than take on faith.

Installing RapidRAW and a first real edit

The README does not give a build-from-source walkthrough. It points at the GitHub releases page for packaged builds for Windows, macOS, Linux and Android, and at getrapidraw.com/docs for tutorials. If you want a packaged binary, the releases page is the documented route.

If you are working from the repository instead, the package.json scripts are the entry point. The dev server and the Tauri shell are started together by the start script, which runs tauri dev. Note that tethering is behind a Cargo feature, so it needs a separate script.

npm install
npm run start

The first command installs the JavaScript dependencies listed in package.json. The second runs tauri dev, which builds the Rust side and opens the editor window. Expect the first build to take a while, because the Rust and wgpu dependencies compile before the window appears.

Camera tethering is not compiled in by default. The package.json defines a dedicated script that passes the feature flag through to Cargo:

npm run start:tethering

The release notes for 2026-08-16 describe tethering as macOS and Linux only, with live view, exposure controls, ghost overlay and direct library ingestion. On Windows that feature is not part of the documented set.

Before opening a pull request, the repository's own checks are worth running, since they cover type errors, lint and translation extraction:

npm run typecheck
npm run lint
npm run i18n:check

The i18n:check script runs i18next-cli extract in CI mode and then a runtime check, so it fails if a translation key is missing at runtime rather than only if extraction is out of date. For a first edit, open a RAW file through the file dialog, move an exposure or highlight slider, and watch the canvas. The release notes for 2026-09-13 describe improved RAW highlight recovery and colour clipping, so that is the area that has seen the most recent shader work.

Where RapidRAW stops being the right tool

The README is unusually direct about this: RapidRAW is not yet as polished as Darktable, RawTherapee or Lightroom. Take that at face value. A project whose release notes include a rewritten vibrance and local contrast algorithm on 2026-09-17, a rewritten Wayland/Nvidia workaround on 2026-09-03, and a refactored crop panel on 2026-09-02 is a project where behaviour can change between two releases. If you have built presets or a workflow around a specific slider response, an update can move it.

The platform story has sharp edges too. Tethering is documented for macOS and Linux only. The Wayland/Nvidia workaround has been rewritten at least once, which tells you that GPU driver combinations on Linux are an active source of trouble. On Android the README lists support, but the release notes mention mobile UI improvements on 2026-08-31 and restored side panels on tablets on 2026-08-19, so the mobile layout is still settling.

There is also a support boundary. The README asks users to report bugs, and the project is maintained by one author. There is no documented enterprise support, no LTS branch, and no compatibility promise for old adjustment files. If your work depends on a bug being fixed on a schedule, this is the wrong tool.

RapidRAW against Darktable and RawTherapee

The README names Darktable and RawTherapee as the mature alternatives, and the comparison is worth taking seriously rather than treating them as competitors to beat. Darktable and RawTherapee have years of accumulated camera profiles, documented module behaviour and a large body of tutorials. Their pipelines are CPU-oriented by default, with GPU acceleration available in parts, and their interfaces assume you will learn a module system rather than drag a few sliders.

RapidRAW's difference is architectural. It is a Tauri application, so the UI is web technology and the image maths is in Rust and WGSL shaders. That is why the README can claim a download under 20MB while still shipping a GPU pipeline. The trade-off is that the project depends on the WebGPU stack being healthy on your machine, which is exactly the kind of dependency that produced the Wayland/Nvidia workaround rewrite.

A second difference is scope. Darktable is a full digital asset manager with a database, tagging and a print path. RapidRAW is an editor with a library view; the release notes mention a masonry thumbnail layout and back and forward navigation history in the library, but nothing resembling a catalogue database. If your problem is finding one image among fifty thousand, Darktable's model is the better fit. If your problem is editing two hundred images from one shoot quickly, RapidRAW's model is the more direct one.

Licence, upgrades and what maintenance costs you

RapidRAW is licensed under AGPL-3.0. For an individual photographer editing their own files, that is a non-issue. For anyone embedding the editor in a product, or offering it as a hosted service, the AGPL's network clause is the part to read carefully, because it extends source disclosure obligations to users who interact with the software over a network. This is not legal advice; if that scenario applies to you, talk to a lawyer.

The upgrade cost is real but bounded. Version numbers move fast: v1.6.2 on 2026-08-21, v1.6.3 on 2026-09-03, v1.6.4 on 2026-09-17. Each of those releases carries feature work rather than only fixes, and the release notes show algorithm rewrites landing in patch releases. There is no documented migration path for adjustment data between versions, and the README does not describe a rollback procedure. The last push to the repository was on 2026-09-21.

Practically, that means pinning a version you have validated and treating upgrades as a deliberate step rather than an automatic one. The counterweight is that the project is clearly alive: the release cadence and the changelog entries are consistent with a maintainer who is actively working on the editor.

Editorial conclusion

Adopt RapidRAW if you want a lightweight, GPU-driven editor for a personal photography workflow and you are willing to file bug reports, because the README states the project is still in active development and not yet as polished as Darktable, RawTherapee or Lightroom. Do not adopt it as a studio's only editor if you depend on years of documented behaviour or on a support contract; the licence is AGPL-3.0 and the author is a single developer. Before committing, verify two things yourself: whether your camera body and lens appear in the bundled Lensfun database, and whether your GPU driver works with the wgpu renderer on your platform, since the release notes record a Wayland/Nvidia workaround rewrite on 2026-09-03.

Frequently asked questions

Official sources

1. CyberTimon/RapidRAW on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases