lapstack

[!NOTE] Nothing leaves your machine. The browser app runs the whole engine on your own GPU through WebGPU; no frame is uploaded anywhere. The command-line tool and the desktop application run the same engine natively.

Features

Everything in the box

Under the hood

• One core, three engines: lapstack-core holds the pyramid, the aligner, the depth pass and every output. The CUDA engine and the wgpu engine run the same kernels natively; the browser runs the wgpu kernels on WebGPU, one frame at a time in a Web Worker, so browser memory stays at a couple of frames regardless of stack size.
• Streaming by design: a 100-frame stack of 45 MP frames never sits in memory whole. Frames stream from disk, the fold keeps one accumulator, and a pooling allocator recycles the big planes; the CPU run peaks at 12 GB, the CUDA run at 9.4 GB.
• From scratch: written from the papers cited in docs/README.md, with no reference to anyone else's source. The design document in docs/engine.md and docs/browser.md states every formula and names the file that implements it.
• The raw decoder kept apart: the camera raw decoder (rawler, LGPL) is a module of its own, loaded at run time by the CLI and as a separate wasm module by the browser, so the MIT-licensed engine never links it and you can replace it.
• Checked against itself: the browser's fused image, depth map and confidence match the native run's to the quantization; the wgpu and CUDA aligners land on the CPU's registration within the search's own tolerance; a headless Chrome test runs the browser end to end on a GPU.

crates/lapstack-core   library: pyramid, fusion, depth from focus, aligner, dust map, stereo views, 3D model, batch splitting, I/O, linear DNG, frame preparation
crates/lapstack-cli    `lapstack` command-line tool
crates/lapstack-web    the browser app's engine: wasm32 decode + the core's wgpu kernels on WebGPU
crates/lapstack-raw    the camera raw decoder (rawler, LGPL) as a module of its own: a shared library the CLI loads at run time, a wasm module the browser app loads beside its engine
web/                   the browser app (static files) and its headless test
docs/                  the design document (`engine.md`, `browser.md`) and the papers the algorithm is written from, cited
lightroom/             the Lightroom Classic plugin (the CLI as an export target and a Library menu item)
desktop/               the browser app as an Electron desktop application

Get started

In the browser, nothing to install: open lapstack.app.ragtux.com, add the frames, press Run. Chrome and Edge have WebGPU on by default on Windows and macOS; on Linux, Chrome needs the switches in web/chrome.sh (or use the desktop application); Firefox needs dom.webgpu.enabled; Safari 26 and later work.

The command-line tool, from a release or from source:

cargo build --release                                              # the CLI and the raw decoder module, in target/release
lapstack --align-coarsen 2 --save-depth -o out.png frames/*.tif    # align, fuse, write the depth map beside the result
lapstack --no-align -o out.png aligned/*.png                       # already registered: streams from disk
lapstack --gpu --gpu-align --align-coarsen 2 -o out.png frames/*.tif   # fusion, depth pass and the aligner's search on the GPU
lapstack --help                                                    # every option, with its default

A directory stands for the image files in it. Input is PNG, JPEG or TIFF, 8- or 16-bit, or a camera raw; the output keeps the input bit depth (16-bit needs PNG or TIFF) and carries the first frame's EXIF, ICC profile and XMP (--no-metadata turns it off).

From source, the rest: just lists the developer commands (build, test, serve, chrome, dev, …); just build-web && just serve builds the browser app and serves it on http://localhost:8765/; CONTRIBUTING.md is the short version.

GPU builds

Two engines, two build features, one switch: --gpu fuses (and runs the depth pass) on the GPU, --gpu-align puts the aligner's cost search there too, and --gpu-backend cuda | wgpu names the engine — without it the first that answers is taken, CUDA before wgpu, and a run with neither says so and goes on on the CPU.

cargo build --release --features gpu,wgpu -p lapstack-cli
# CUDA (`gpu`; `gpu.rs`): NVIDIA. Linux: libcuda (driver) + libnvrtc (toolkit) on the path,
#   and nvidia_uvm loaded. NixOS: LD_LIBRARY_PATH=/run/opengl-driver/lib:<cudaPackages.cuda_nvrtc's lib output>/lib
#   Windows: nvcuda.dll ships with the display driver; drop the two DLLs from NVIDIA's cuda_nvrtc
#   redist zip (bin/nvrtc64_120_0.dll + nvrtc-builtins) next to lapstack.exe, their major.minor
#   matching the driver's CUDA version (nvidia-smi), or the PTX JIT rejects the kernels.
# wgpu (`wgpu`; `wg/`): any GPU — Vulkan on Linux and Windows, Metal on macOS, DX12 on Windows.
#   Linux needs the Vulkan loader (libvulkan.so.1) and the driver's ICD; NixOS:
#   LD_LIBRARY_PATH=<vulkan-loader's lib>:/run/opengl-driver/lib and, with several ICDs installed,
#   VK_ICD_FILENAMES=/run/opengl-driver/share/vulkan/icd.d/nvidia_icd.json (or the one for the card).

cudarc is built with dynamic-loading and wgpu finds its backends at run time, so a binary built with both features runs on a machine with neither: --gpu reports what it looked for and the CPU does the work.

Downloads

Builds for Linux, Windows and macOS are attached to each release; the browser app needs no download. The desktop builds are not code signed, so Windows and macOS warn before the first launch.

Command-line tool

Each archive holds the binary, the raw decoder module beside it, LICENSE, THIRD-PARTY.md and the decoder's source.

Platform	File	GPU engines in the build
Linux x86_64	lapstack-<ver>-x86_64-unknown-linux-gnu.tar.gz	CUDA and wgpu (Vulkan)
Windows x64	lapstack-<ver>-x86_64-pc-windows-msvc.zip	CUDA and wgpu (Vulkan, DX12)
macOS, Apple silicon	lapstack-<ver>-aarch64-apple-darwin.tar.gz	wgpu (Metal)
macOS, Intel	lapstack-<ver>-x86_64-apple-darwin.tar.gz	wgpu (Metal)

Desktop application

The browser app in an Electron window, with WebGPU on every platform and no launcher script.

Platform	Files
Linux	lapstack-<ver>.AppImage, lapstack-desktop_<ver>_amd64.deb
Windows	NSIS installer (.exe)
macOS	.dmg, x64 and arm64

Lightroom Classic plugin

lapstack-lightroom-<ver>.zip holds lapstack.lrplugin: add it in File › Plug-in Manager, point it at the lapstack binary, then select the frames of a stack and choose Library › Plug-in Extras › Stack with lapstack, or export with lapstack as the Export To target. The result comes back into the catalog stacked above the first frame. lightroom/README.md has the settings and the details; desktop/README.md the desktop application's.

Documentation

• The manual, for users: lapstack.ragtux.com/docs.
• The design document, for anyone reading or changing the code: docs/engine.md (the engine and the command-line tool: transform, fusion, alignment, depth from focus, the raw and DNG paths, dust map, scale bar, stereo and 3D model, batch runs, performance, the wgpu engine) and docs/browser.md (the browser app: every layer and render, retouch, results and project files, the GPU aligner).
• The papers the algorithm is written from: docs/README.md.
• CONTRIBUTING.md for bug reports and changes, SECURITY.md for a security problem ([email protected]).

lapstack is made by RAGTUX LLC. A contribution helps keep it going and buys nothing, because nothing is for sale.

License

lapstack is free software under the MIT license: Copyright (c) 2026 RAGTUX LLC, LICENSE is the whole of it (SPDX MIT), and it covers the source in this repository and everything built from it — the command-line tool, the browser application, the desktop application and the Lightroom Classic plug-in. Earlier revisions were published under other terms (AGPL-3.0-only from 2026-09-24 to 2026-09-30, then a proprietary license); those terms stay with the copies distributed under them and do not extend to this revision. Paying for lapstack, where it is offered, buys support and services, not the software: the software is yours.

Third-party components keep their own licenses and are listed with their notices in THIRD-PARTY.md, which just third-party regenerates from the Cargo metadata and the crates' own license files; a distributed build carries it. Two need more than a listing:

• The camera raw decoder is LGPL-2.1: vendor/rawler (MIT and LGPL-2.1 per file, copyright Daniel Vogelbacher) inside crates/lapstack-raw, RAGTUX's own LGPL-2.1 shim around it. It is kept a component of its own so that the MIT-licensed parts and the LGPL work stay separate and the user can replace it, as the LGPL asks, so lapstack never links it: lapstack-raw is built as a shared library the CLI loads at run time and as a wasm module the browser app loads beside its engine, and its source — the crate and the patched rawler, with a workspace file so it builds as it is — travels with every build (web/dist.sh puts legal/lapstack-raw-src.tar.gz in the app; the CLI's downloads carry the same tarball). vendor/rawler/LAPSTACK-PATCH.md has the obligations in full; crates/lapstack-raw/README.md how to rebuild and drop in a replacement.
• The papers the algorithm is written from are cited in docs/README.md rather than redistributed: they are their authors' and publishers' work, under their own copyright.