A native, open-source RAW photo editor for Mac, iPad, and iPhone that anyone who knows Lightroom will find familiar.

Redlamp is built from scratch in Swift and Metal for Apple Silicon. It focuses on one thing, developing photos, and aims to do it faster and more natively than anything else on the platform.

!Redlamp editing a Sony α7R V raw file

Watch the film: Introducing Redlamp (1:42, on YouTube)

Status: pre-alpha, iteration 2 (macOS). The core RAW pipeline and the Develop workspace work today: Basic (with Texture, Clarity and Dehaze), Tone Curve, Color Mixer, Color Grading, Detail (noise reduction and sharpening), Effects, lens corrections, crop and Upright, masking (gradients, brush, color and luminance range, Subject, Sky, Background, People and its parts, Objects, Landscape and Depth Range) with local adjustments, healing and removal (Heal, Clone, Remove, content-aware or generative, and Remove Dust), focus stacking, and Recipes, Redlamp's presets, profiles and LUTs in one, with film looks measured from cameras' own renderings and film simulations of 36 film looks from 30 stocks, built from the manufacturers' datasheets. AI Denoise and the rest of Develop parity are next, then 1.0 and the iPad and iPhone apps. See Where we are, the Roadmap, and how Redlamp compares with Lightroom.

> This README is the project's primary status page and is kept up to date as work lands. Last updated: 4 October 2026.

Contents

• Why Redlamp
• Goals
• Where we are
• Film simulations
• Screenshots
• Roadmap
• Installation
• Getting started
• Component harness
• Using Redlamp
• Architecture
• Contributing
• Support Redlamp
• License and acknowledgements

Why Redlamp

A red lamp is the darkroom safelight: the one light you can work by without fogging the paper. That is the idea behind the project: you can see and shape your photo freely, and the original is never harmed.

Lightroom defined how millions of photographers edit, but it is a cross-platform application that doesn't feel at home on a Mac, iPad, or iPhone, and it is tied to a subscription and a cloud. Redlamp keeps the workflow photographers already know, including the panel layout, slider names and ranges, and keyboard shortcuts, and rebuilds everything underneath as a native, GPU-first, open-source application.

Redlamp is an editor, not a catalog. It keeps a working set of folders, as Lightroom Classic's Folders panel does, and stores edits in small sidecar files next to the photos. Library management is a separate, later track.

Goals

1. Immediately familiar to Lightroom users. The Develop module's layout, panel order, slider names, ranges and defaults, and single-key shortcuts all carry over. We copy conventions, never Adobe's assets. One deliberate exception: presets, profiles and LUTs are all Recipes, and a profile is a recipe's Base Look, because for most people they all do one thing, give a photo a look. Lightroom's words still work as tooltips and in search.
2. Best-in-class masks. Masks are part of the architecture from day one. Every edit is a layer (adjustments plus a mask), with Lightroom's model of components combined by add, subtract, and intersect, and on-device AI masks built on Apple Vision and SAM-class models.
3. Modern, native UI and great UX. The UI follows the macOS and iOS 26 design language. Liquid Glass is used only on floating chrome, and editing surfaces stay neutral grey so nothing distorts your color judgment. It is direct-manipulation first, every action can be undone, and there are no modal dialogs while you edit.
4. Extreme responsiveness. Rendering and UI are strictly separated. Slider changes should reach the screen within a frame (under 16 ms), and the UI thread never waits on the engine, the disk, or the GPU.
5. Serious color science. The pipeline is linear and scene-referred up to the tone curve: white balance, exposure, tone, Dehaze and the detail stage, and their masked versions, work on the light the camera recorded, and the color controls, the point curve, vignette and grain work on the tone-mapped image after it (the pipeline). It has DCP camera profiles, LUTs, lens profiles, and our own looks. Some looks are fitted by measurement to match popular camera and editor renderings.
6. Computational photography built into the editing workflow.

1. Mac first, then iPad and iPhone from the same engine. A single platform-neutral engine sits under thin, native shells. The Mac editor comes first; iPad and iPhone follow once the main features are complete, and edits will move between devices through iCloud Drive, Files, and Photos.
2. Open source (MPL-2.0). The license is compatible with the App Store. Algorithms are implemented clean-room from papers and specifications.

Where we are

What works today (macOS)

RAW pipeline (our own, GPU-first)

• [x] Decodes RAW files through LibRaw (unpacking only). Black levels, white balance, demosaicing, and color are all done by Redlamp on the GPU.
• [x] Bayer demosaic by directional filtering with a posteriori decision (Menon, Andriani and Calvagno, 2007), with a dual pass that takes plain green where the neighbours differ only by noise, a first-generation X-Trans demosaic, and linear DNG support (for example iPhone ProRAW).
• [x] Hot pixels are repaired before demosaicing, judged against each photo's own noise level.
• [x] Row and column banding is measured in the sensor's masked (optical-black) margins and subtracted with the black level, only where the margins show more than their own noise.
• [x] DNG gain maps (OpcodeList2), such as phones' lens shading correction, are applied before demosaicing, and noise reduction scales with the noise they amplify.
• [x] Highlight reconstruction: channels are no longer clipped at 1 after white balance, and photosites that did clip are rebuilt from their bright unclipped neighbours, using the colour measured around the clipped area. Fully blown areas stay neutral.
• [x] Tested on Sony ARW, Canon CR3, Nikon NEF, Fujifilm RAF (X-Trans), Apple ProRAW DNG and Google Pixel DNG, plus JPEG, HEIC, TIFF, and PNG.
• [x] The demosaiced image is cached as a full mip pyramid, so interactive renders sample the right resolution for the zoom level.
• [x] A single fused Metal kernel applies every per-pixel adjustment. Frames are delivered as IOSurfaces, so pixels are never copied between engine and UI.
• [x] Latest-wins render scheduling: a burst of slider events collapses to the newest one. Stills wait in two lanes, previews (look thumbnails) ahead of exports, and yield to the canvas between tiles, so an export never holds up a frame by more than a tile; a cancelled still stops at its next tile, and exports rest between tiles when the Mac runs hot.
• [x] Rendering stays off the main thread while you drag a slider. Frames go straight to the canvas, which a dedicated display-link thread presents, and each view observes only the values it shows.
• [x] Both side panels are AppKit: the histogram, tool strip and every Develop and Masking panel on the right, and the Navigator, Recipes, Snapshots and History on the left, built from the same panel component. The right column's panels match their SwiftUI originals pixel for pixel, and a component harness is used to build and review them (see Component harness).
• [x] Temperature and tint use a proper camera white-balance model (Robertson's method with the camera's color matrix). As Shot, Auto, and the illuminant presets all work.

• [x] White balance: Temp and Tint, the presets, Auto, and the eyedropper.
• [x] Basic: Exposure, Contrast, Highlights, Shadows, Whites, Blacks, Vibrance, and Saturation, plus the Auto button.
• [x] Treatment (Color or B&W) and Base Looks (Lightroom's profiles) with an Amount slider (0–200) and a browser that renders every look on the photo. There are six built-in looks (Redlamp Color, Neutral, Vivid, Landscape, Portrait and Monochrome) and 15 film-style looks built on 3D look tables: slide, chrome, negative, cinema, bleach and black and white through color filters. Four of them are measured from cameras' own renderings by the look profiler (see Recipes and looks).
• [x] Tone Curve: a parametric curve with split points, and a point curve with presets.
• [x] Color Mixer: HSL (Hue, Saturation, Luminance, and All) and a per-color mode, working in OKLCh.
• [x] Color Grading: 3-way and individual wheels, Blending, and Balance. It also tints B&W images for split-toning.
• [x] Effects: post-crop vignette (amount, midpoint, roundness, feather, and Highlights to keep bright areas bright under a darkening vignette) and zoom-stable film grain.
• [x] Noise reduction (Detail panel): Luminance with Detail and Contrast, and Color with Detail and Smoothness. It is scaled to each photo's own noise: the DNG NoiseProfile tag, else its camera's calibrated profile at its ISO, else measured from the raw data when the file opens (a raw far cleaner than its camera's profile has had noise reduction in camera, so the measurement wins). Luminance keeps fine texture: wavelet shrinkage judges each detail by its neighbourhood, and at 1:1 and in exports a non-local-means pass guided by that result brings back texture where the photo repeats it. It runs as a cached stage in front of the fused kernel, so other sliders stay as fast as before, and exports render in tiles.
• [x] Sharpening (Detail panel): Amount, Radius, Detail and Masking, in the same cached stage after noise reduction. It is noise-aware: detail is measured on a denoised copy of the luminance and applied to the untouched image, so the photo's noise and grain pass through as they were instead of being sharpened. Detail moves from a halo-limited unsharp mask towards Richardson–Lucy deconvolution of the Radius's blur, and holds back halos on strong edges; Masking keeps flat areas untouched. It boosts luminance detail in stops, so it doesn't depend on exposure and leaves colors alone.
• [x] Texture and Clarity (global): gains on medium (about 2–8 px) and larger (about 8–64 px) luminance detail, taken from the image pyramid in the same cached stage, so tiles and zoom levels agree. Negative values soften. For new edits (process version 9) Clarity is edge-aware: a strong edge isn't its detail, so it puts no bright and dark bands along a skyline or around a tree. From process 11, Texture, Clarity and sharpening read one decomposition of the noise-reduced photo: Texture keeps its strength on texture but no longer outlines strong edges, adds less noise, and matches a downscaled export at every preview size, and dragging Texture, Clarity, Amount, Detail or Masking takes a fraction of a millisecond at 1:1.
• [x] Dehaze (global and in masks): the dark channel prior (He, Sun and Tang, 2009) with the airlight and a haze map measured when the photo opens; negative values add a neutral veil. For new edits (process version 8) the haze map follows the photo's edges, so the sky beside a tree or a ridge has no pale glow.

• [x] Each mask is a layer: its own adjustments plus a mask built from components. Components combine with Add, Subtract, and Intersect, and each can be inverted.
• [x] Linear and radial gradient components.

• [x] Brush (K): A and B brushes and Erase (hold Option), with Size, Feather, Flow, Density and Auto Mask, and pen pressure. Strokes are kept as vectors in the edit and painted on the GPU in mask space (up to 4096 px), redrawing only the stroke being painted. [ and ] or ⌘-scroll change the size, with Shift the feather; the brush's ring shows its size as it changes, also from the panel's sliders, and Space-drag moves the photo while you paint. In every tool the wheel and pinch zoom.
• [x] Luminance Range (⇧Q) and Color Range (⇧J): sample with the eyedropper, then shape the range with four handles (Show Luminance Map) or Refine up to five color samples. They select on the photo with its global edit, so the selection follows white balance and exposure.
• [x] AI masks: Subject, Background, People (each person, or parts: face skin, eyebrows, eye sclera, iris, lips, teeth, and hair from iPhone mattes) and Sky, with Apple Vision's built-in models and nothing to download. Objects: hover to preview, then click, drag a box around the thing or brush over it to select it; click or brush again to add, with Option to take away (Segment Anything 2.1, an 80 MB download on first use). Depth Range: from a photo's own depth map (iPhone), or estimated by Depth Anything 3 (or V2 Small). Landscape (water, vegetation, mountains, architecture, natural and artificial ground, and snow), with adaptive presets such as Brighten Snow: SAM 3, converted to Core ML (a 988 MB download, under Meta's SAM License, which comes with it; Snow's prompt, added later, is in the app with a copy of the licence, so it needs no new download); the same model adds hair on any photo, facial hair, body skin and clothes to People. Sky is Segment Anything prompted inside a classical sky estimate, combined with Depth Anything 3 (converted to Core ML, a 336 MB download) once it is downloaded; then every edge pixel is solved at full size against the sky's own colour, so twigs, leaf gaps and wires keep their own coverage. Subject, Background, People and Objects edges are solved per pixel too (closed-form matting), which brings back stray hairs and beard curls (see the bake-off).
• [x] AI masks are computed from the photo without its edit and kept as bitmaps in the edit, so they never move when you edit and render the same everywhere. Update AI Masks recomputes them with today's models, pasted settings recompute them for the new photo, Refine Edges snaps them harder to the photo, the Refine Edge Brush solves an edge again, hair by hair, wherever you paint over it (kept with the mask, so Update AI Masks applies it again), and Feather and Edge soften an AI mask's edge or move it out or in. From process version 13, coarse AI masks (iPhone mattes, face parts) are refined again at the size the photo is drawn at, so they stay sharp at full size. From process version 14, a Sky mask's edit reaches only the sky's share of each pixel along its edge, so twigs and leaves keep their own colour and brightness when the sky is darkened or warmed.
• [x] Mask presets: Blue Sky, Brighten Subject, Darken Background, Smooth Skin, Whiten Teeth and Pop Eyes compute their masks for each photo; save your own from any mask.
• [x] Beyond Lightroom: a mask's Detail keeps only its textured (or only its flat) areas, and any mask can be reused as a component of another (Existing Mask in Add, Subtract and Intersect).
• [x] Local adjustments: Temp, Tint, Exposure, Contrast, Highlights, Shadows, Whites, Blacks, Texture, Clarity, Dehaze, Hue, Saturation, Sharpness, Noise, a Color swatch that tints what the mask covers, and Curves (RGB, red, green and blue), plus the mask's Amount (0–200%).
• [x] Mask management: a mask overlay (O) in Lightroom's modes (Color Overlay, on B&W, Image on Black or White, B&W, Image on B&W), colors and opacity, and a mask list where you can show and hide, rename, duplicate, "duplicate and invert", reset, delete, and drag to reorder masks and their components.
• [x] Fast by design: gradients and ranges are evaluated per pixel inside the same fused GPU kernel, and brush and AI masks are read from GPU textures. Up to 16 masks cost well under a millisecond extra at Fit.
• [x] Models on demand: Settings › Models lists the downloadable models with their size, and removes them. Every model runs on the Mac; photos are never uploaded. Each shows its licence, which comes with the download. Models still under licence review are offered only when you turn on evaluation models.

• [x] Stacks are found for you: runs of frames with the same camera settings a moment apart, whose sharp region moves from frame to frame, get a "Focus stack detected: N frames" banner with Merge, and the filmstrip slides up for a few seconds to show it. Bursts, time-lapses and pans aren't offered. Photo › Merge to Focus Stack… and Edit Focus Stack…, also in the command palette, open the Stack workspace from the menus.
• [x] The result develops like a raw. Frames are stacked as demosaiced camera RGB before any edit, so every Develop slider, white balance included, works on it. The stack is a small .redlampstack document beside the frames; the merged pixels are cached and rebuilt when needed.
• [x] Alignment follows focus breathing, rotation and shift, brightness is matched frame to frame, and a depth map records which frame is sharpest where.
• [x] Auto, Smooth and Detail: Auto takes tone and color from the depth map and fine detail from the sharpest frames near it; Smooth blends between frames for clean surfaces; Detail keeps the sharpest detail from anywhere, for hair and bristles.
• [x] The Stack workspace: leave frames out, switch methods (each merge is cached), view the depth map, and retouch by painting the frame under the cursor, a chosen frame or another method's result over the merge.
• [x] One frame is in memory at a time, and redlamp stack does the same from the command line.

• [x] A Lightroom-style layout. On the left: Navigator, Folders, Recipes, Snapshots, and History, as collapsible panels like the Develop panels. In the center: the photo, with the filmstrip below. On the right: histogram, tool strip, and the Develop panels in Lightroom's order.
• [x] Folders, as in Lightroom Classic: add folders with +, ⌘O or by dropping them on the window, and they're remembered (by bookmark, so a folder that's renamed or moved is followed). Each shows as a tree with the number of photos in every folder; click one to show it in the filmstrip, or turn on Show Photos in Subfolders (View menu or the folder's context menu) to see everything beneath it. Nothing on disk is moved or changed. The filmstrip follows the disk by itself: photos copied in, deleted, renamed or rewritten appear, leave or update in place, a photo still being copied waits until it's complete, and the selection moves to the next photo when its own is deleted. A folder on a disk that isn't connected is dimmed with a question mark, Locate… points it at where it went, and it comes back when the disk does. Each folder reopens on the photo you last had in it.
• [x] Built to stay fast with any number of photos: a folder lists without reading a single sidecar (badges follow from light reads, visible photos first); thumbnails decode in parallel on every core at the cell's size, from the smallest preview the raw file embeds that's big enough (found by LibRaw; 3 to 11 times faster than ImageIO's full-size one for Sony, Canon and Nikon files), are kept within a 128 MB budget in memory and cached on disk in one file per folder (at most 1 GB), and are warmed in the background while you're not waiting; the filmstrip is AppKit with reused cells, so 50,000 photos cost what a screenful does. Focus stacks are looked for one folder at a time in the background, and remembered. See Measured performance and the design.
• [x] Sliders: click to jump, drag to adjust, Shift-drag for fine control, double-click to reset, and click the value to type one in. Option-dragging a tone slider shows clipping, as in Lightroom.
• [x] Panels: double-click a panel or group title to reset it, and Option-click a header for Solo Mode. The left column's panels collapse the same way when you click their headers, and Option-click shows only one.
• [x] Histogram: clipping indicators, and you can drag across it to adjust Blacks, Shadows, Exposure, Highlights, or Whites.
• [x] Recipes (Lightroom's presets, profiles and LUTs, in one): 39 bundled recipes in eight groups, including camera-style ones built from Fujifilm-style recipe cards. Hover to preview, click to apply, then adjust the recipe's Amount. You can search (Lightroom's words work), mark favorites, save the current edit as a recipe with a settings checklist (⇧⌘N), and import or export .redrecipe, .cube, .3dl and HaldCLUT files (LUTs made for camera log footage too, with their input space chosen on import, in the panel and the Recipe Lab). Lightroom develop presets (.xmp) import too, one, several or a folder at a time, by the menu or by dropping them on the panel, with a report of what came across exactly, approximately or not at all (what maps). Snapshots are also available.
• [x] History with full undo and redo. Each step shows an icon for what it did, and the value before and after ("Exposure 0.00 → +0.50"). Every time you open a photo a new session starts. The earlier sessions are kept with the photo (the last 20) and listed under the current one, and choosing one of their steps brings that edit back as a new step.
• [x] Camera-recipe controls in the Effects panel: Dynamic Range, Color Chrome, Chrome FX Blue, and red and blue white-balance shift.
• [x] Viewing: Fit, Fill, 1:1, and 2:1 zoom, click to zoom, pan, pinch, and a clipping overlay. Sensor clipping (⌥J) marks the photosites the camera clipped, in the colour of each clipped channel (black where all three did), whatever the edit has done since; the colour-assessment view (⇧L) puts the photo on middle grey inside a white frame (ISO 12646). Before/After (\) in three layouts, full frame, side by side and a diagonal split, cycled with Y and ⇧Y; the original is rendered once and cached, so edits don't re-render it.
• [x] Themes: Neutral greys by default, so nothing tints your judgment of color, plus a Redlamp theme and 20 dark and light families with a tint control, from the toolbar's Theme button or Settings (⌘,), which also has an About tab. The command palette follows the app's theme or takes one of its own.
• [x] Lightroom Classic's keyboard shortcuts: 97 actions on 96 key bindings, from one registry that also drives the menus and an in-app ⌘/ reference (see Keyboard shortcuts).
• [x] Command palette (⌘K): every action, with its shortcut shown beside it, every Develop slider, and pickers for white balance, treatment, Base Looks, recipes, Before / After, snapshots and history, all from the keyboard.

• [x] Sliders by hand: ⌘-scroll over any slider adjusts it (Shift coarse, Option fine), and value fields accept arithmetic such as x+10.
• [x] Culling while you develop: star ratings, pick/reject flags and color labels, shown on the filmstrip. There's also an Info overlay (I), Lights Out (L), full-screen preview (F), and Paste from Previous (⌥⌘V and the Previous button).
• [x] Copy, paste and sync settings, as Lightroom does: Copy Settings… (⇧⌘C) opens a checklist of every setting and mask, remembered for next time; Paste (⇧⌘V) applies what was ticked, and recomputes the pasted AI masks for the photo. ⌘- and ⇧-click select several photos in the filmstrip: Sync… (⇧⌘S) and Paste reach all of them in the background, with Undo, and Auto Sync (⌥⇧⌘A) repeats every change. Right-click a photo in the filmstrip to copy its settings or paste onto it without opening it; on a selected photo, the menu has the same Copy, Paste and Sync items.
• [x] Non-destructive edits, saved automatically to a sidecar file next to each photo (IMG_1234.ARW.redlamp).
• [x] Export dialog (⇧⌘E): JPEG, HEIC and AVIF (lossy, with quality and an optional file size limit) or PNG and TIFF (lossless, with TIFF compression), 8, 10 or 16 bits, sRGB or Display P3. Resize by long edge, short edge, width and height, megapixels or percentage, keep all metadata, all but the location, or none (the first two also embed the edit recipe in the file's XMP, format), and choose the folder and file name. Built-in and saved presets, and Export with Previous (⌥⇧⌘E) repeats the last export without the dialog.
• [x] Report a Bug or Send Feedback (the toolbar's Feedback button, the Help menu or the command palette, and Report… beside an error): files a GitHub issue for you, with no GitHub account needed, under an area picked from a list that mirrors the app (such as Masking › Objects), suggested from what you were doing. The report carries what you did in the last minutes, the open photo's camera and edit, and the Mac's details, and you see all of it before it's sent (what it contains). Help › Your Reports lists what you've sent, with each issue's state and replies.
• [x] Test Your Camera (Help menu or the command palette): the camera bench checks how your camera's raw files decode and compares Redlamp's rendering of each with the JPEG the camera saved inside it, on your Mac. It groups photos by camera and raw mode, picks a few of each, shows them side by side and asks one question, then sends only the measurements, which you see first, to add to the cameras page (how it works). redlamp camera-bench runs the same checks from the command line.
• [x] What's New: after an update, the release's highlights open once, in the welcome window's look: the logo rises, the highlights are listed, and each has a page with a screenshot and a button that opens it, such as Test Your Camera…. Help › What's New in Redlamp shows the recent ones again. They come from redlamp.app, so they can be written after a release ships; when they can't be had, nothing opens and the next launch tries again.
• [x] A headless redlamp command-line tool for rendering and export. Exports smaller than the photo are developed at full resolution and downscaled last, so sharpening, noise reduction and texture look the same at every size.

Recipes and looks

• [x] One .redrecipe format for presets, profiles and LUTs: an explicit list of setting groups, an optional Base Look pinned by content hash, immutable versions, and namespaced ids ready for sharing (format, JSON Schema).
• [x] Camera recipe cards: Fujifilm-style recipes (film simulation, dynamic range, highlight and shadow tone, color, Color Chrome, white balance shift, grain) are a recipe dialect you can type in as the card lists them (mapping).
• [x] Measured film looks. The profiler fits a look to cameras' own JPEGs of the same raw files: Fujifilm raws carry the camera's rendering inside. On photos the fit never saw:

The others are hand-designed until there's data for them (look development). Looks keep Redlamp's own names.

• [x] Film simulations: 36 looks from 30 stocks, built physically from the manufacturers' datasheets, including pushed, overexposed, bleach-bypass and cross-processed variants, with halation, bloom and film grain, a Film Looks window and film icons in the Base Look menu (details).
• [x] Look-development tools: lint (neutral axis, skin hue, monotonic lightness, banding, clipping) on a synthetic chart, golden renders per recipe version, style fingerprints and a fitter, and the Recipe Lab in the component harness.
• [x] An agent recipe studio (docs): curator, colorist and critic agents work through redlamp mcp on briefs drawn from public-domain references. People approve the briefs and pick the winners in the Recipe Lab, and the critics are only trusted after they agree with human picks on held-out pairs.

In progress

• Focus stacking: lens corrections before alignment, halo handling, vendor focus-bracketing tags for detection, and baking a stack to DNG.
• Remove, Heal and Clone (Q): click the photo to add a spot. Remove fills it from the photo around it, patch by patch, continuing edges that run into it (content-aware fill), and with Click picks set to Person or Object, a click removes the whole person or object, shaped by its mask. Find outlines things named in words wherever they are in the photo (trash, litter, plastic bags, bottles, cans, cigarette butts, power lines, cables, signs, traffic cones, cars, people and birds, with OWLv2 from Settings › Models), and a click on one removes it the same way, or Remove All removes them all; Heal and Clone find their own source nearby; drag the spot or its source to move it, or its handle to resize it, and change Heal or Clone, Size, Feather and Opacity in the panel. Heal matches the source's texture to the light around the spot. Drag instead of clicking to brush a spot along a scratch, wire or twig. Remove Dust finds the soft, colourless specks sensor dust leaves on smooth areas (sky, walls, water) and heals them in one step; with several photos selected, it heals the specks found in the same place on the sensor in two or more of them (frames showing the same scene around a speck, as from a tripod, count as one), in all of them (one Undo puts the others back), and Visualize Spots shows the photo's edges in white so the rest stand out. Spots are saved with the edit, paste with Copy Settings, and redlamp render --remove x,y,radius, --heal or --clone (or --remove-brush and the others through several points) adds one from the command line, as --remove-dust 50 heals the dust found and --remove-found car removes what's found by name.
• Tools not yet working: the Red Eye tool shows what is coming and when.

Measured performance

Measured on an Apple M1 Ultra with a Release build. Every figure since 29 September, the benchmark harness's runs, and what's got faster or slower are at redlamp.app/performance, from docs/performance/history.jsonl; scripts/perf-record.sh records a run.

| Operation | Time | | --- | --- | | Open a 24–26 MP raw file (decode, GPU upload, demosaic, pyramid) | 70–250 ms | | Interactive render at Fit (every adjustment, fused) | 0.6–3 ms | | Interactive render at Fit with two gradient masks | ~1.3 ms | | Interactive render at 1:1 (full 26 MP frame) | ~13 ms | | Full-resolution export render (24–26 MP) | ~45 ms | | Full-resolution export render with noise reduction (24 MP, tiled) | ~100 ms | | Focus stack of 25 × 17 MP Canon CR3 frames (decode, align, depth map, fuse) | ~8 s | | Focus stack of 109 × 4 MP JPEG frames | ~15 s | | Reopen a merged focus stack from its cache | ~0.1 s | | Detail stage on a 1:1 region (about 10 MP of pyramid texels), GPU time: noise reduction, Texture and Clarity | ~5 ms, ~1 ms | | Detail stage for a 2560 × 1600 view at 1:1 of a 24 MP frame, GPU time: noise reduction alone (Luminance 50); default sharpening, first render; while dragging Radius; while dragging Amount, Detail or Masking (cached analysis); while dragging Luminance | ~3.6 ms, ~7.2 ms, ~5.5 ms, ~2.2 ms, ~4.3 ms |

The detail stage holds about 1.3 GB of GPU memory at 1:1 on a 24 MP photo and 2.3 GB on a 60 MP one, with noise reduction and sharpening on (3.1 GB and 7.5 GB before the memory audit, AUD-03); large views render in tiles within its budget, and nothing is kept once rendering stops for half a second.

Folders and the filmstrip on 50,000 photos in 500 folders (scripts/make-folder-fixture.sh, then --folders-perf), measured while the Mac was busy with other work (load average about 18):

| Operation | Time | | --- | --- | | First photos in the filmstrip, Show Photos in Subfolders on | 14 ms | | All 50,000 photos listed (500 folders, in parallel, in order) | 209 ms | | The visible thumbnails, decoded from the raw files | 33 ms | | Background warming from the raw files | 705 a second | | Thumbnails from the disk cache | 6,210 a second | | Main thread while listing, decoding and warming (p99) | 0.15 ms | | Main thread while scrolling the filmstrip end to end (p99) | 1.4 ms | | Peak memory, 152 MB before opening | 317 MB (531 MB before the memory budgets); 207 MB idle after a memory-pressure trim |

Dragging a slider at 120 events a second (scripts/perf-sweep.sh), with every panel open:

| Main thread during the drag | Iteration 2 | Off-main rendering | AppKit panels | | --- | --- | --- | --- | | Time busy | 100% | ~54% | ~34% | | Typical run-loop iteration (median) | — | 2.3 ms | 0.17 ms | | Slowest 5% of iterations | 157 ms | ~8 ms | ~5 ms | | Slowest 1% of iterations | — | ~13 ms | ~8 ms |

With both side panels in AppKit, most of what remains is Core Animation committing the redrawn layers and the engine's frames arriving; SwiftUI is down to about 2% of the main thread.

Known limitations

• Highlights and Shadows are edge-aware for new edits (process version 7): each region moves by its brightness and keeps the texture inside it. Edits made before keep the per-pixel version, and they haven't yet been compared against Lightroom's own exports.
• X-Trans demosaicing is a first-generation interpolation. A Markesteijn-class demosaic comes in Phase 2.
• Redlamp's exposure for Fujifilm raws differs from the camera's by up to ±0.9 EV depending on the body; the profiler removes it when measuring looks, and the engine fix is tracked (TON-14).
• Non-DNG raws use a single-illuminant Adobe-derived matrix (LibRaw's). DNGs interpolate their two calibrations by white balance, and since process 4 apply their embedded profile's HueSatMap, but the Temperature and Tint model still converts with one matrix. The profile's look (LookTable and tone curve) is offered as a Base Look under "In This Photo", Apple ProRAW's look comes with its gain table map, Apple's local tone mapping, so it renders the way the iPhone does. Importing .dcp files is deferred.
• Landscape masks (mountains, water, vegetation, ground, architecture, snow) and people parts beyond the face (body skin, clothes, and hair without an iPhone matte) come from SAM 3, under Meta's SAM License; a model trained on data Redlamp has rights to, which would replace it, doesn't exist yet (plan).
• Objects (Segment Anything 2.1), Depth Range and Sky (Depth Anything V2 Small and 3) use open models trained partly on data Redlamp couldn't use itself, offered to everyone by the owner's decisions (tracker DEC-24, DEC-02). Vision's own tap-to-segment arrives with macOS 27.
• AI mask edges are solved per pixel when the mask is made, at up to 4096 px on the long side, so on larger photos they're slightly soft at 100%. For new edits (process version 13), masks coarser than that (iPhone mattes, face parts, masks made before edges were solved per pixel) are refined again where the photo is drawn, at its resolution (a guided filter, freedom-to-operate pending as DEC-05); where the photo has no edge for such a mask's to follow, it keeps its own, which is soft at full size.
• The app is not sandboxed yet (required later for the Mac App Store), but photos and focus-stack frames decode in a sandboxed service with no file access (RedlampDecoder.xpc, sent each file's bytes), never in the app, so a damaged file can't crash the editor while it decodes. These reads still parse files in the app itself: filmstrip thumbnails (a raw's embedded preview, through LibRaw, or ImageIO), the Portrait mattes and depth a photo carries, focus-stack detection, the metadata an export copies from its source, an imported HALD look, and the Camera Bench window (Help › Test Your Camera…). iPad and iPhone come in Phase 5.
• Sidecars are read and written under file coordination, so iCloud Drive syncs them safely and conflicting copies merge (the newest edit wins, the others become snapshots, and the rating, flag and label each come from the newest copy that set them). A photo that is open doesn't reload when another Mac changes its edit, but its next save merges the two edits instead of writing over the other Mac's.
• Nikon's High Efficiency NEFs (HE and HE\*, from the Z 8, Z 9, Z 6III, Z f, Z5 II and Z50 II) don't open yet: LibRaw 0.22 can't read them (CAM-12). Bodies LibRaw 0.22.2 doesn't list need a LibRaw update: the Sony A7 V doesn't open, the A1 II opens with a black strip along the bottom (CAM-13), and the Z5 II's and Z50 II's lossless NEFs open without a colour matrix (CAM-21).

• Phase One IIQ files develop with the back's black levels subtracted and its calibration applied; they had a magenta cast.
• Hasselblad FFF files (Phocus's format) open as raws.
• White balance now works for linear DNGs such as iPhone ProRAW.
• The Navigator outlines the zoomed viewport.
• The loading placeholder now shows while a photo decodes.
• Dragging a slider no longer stutters. Every change used to re-render every panel and wait on the canvas's drawable on the main thread.

Film simulations

Redlamp's film looks are physical simulations, built from the data in each manufacturer's own datasheet: characteristic curves, spectral sensitivities and dye spectra, digitised into research/film-data/. Most film presets are tuned by eye.

Portra 160 Colour negative	Portra 400 Colour negative	Portra 800 Colour negative	Ektar 100 Colour negative	Gold 200 Colour negative	UltraMax 400 Colour negative
Superia 400 Colour negative	Pro 400H Colour negative	CineStill 800T Tungsten negative	CineStill 50D Daylight negative	Vision3 500T Cinema print	Vision3 250D Cinema print
Vision3 50D Cinema print	Eterna Vivid Cinema print	Provia 100F Slide	Velvia 50 Slide	Velvia 100 Slide	Ektachrome Slide
Kodachrome 64 Slide	Tri-X 400 Black and white	T-Max 100 Black and white	T-Max 400 Black and white	HP5 Plus Black and white	Delta 100 Black and white
Delta 3200 Black and white	FP4 Plus Black and white	Pan F Plus Black and white	Darkroom Print Grade 2 print	Soft Print Grade 1 print	Hard Print Grade 4 print
Portra 400 · +2 Overexposed	Portra 800 · 1600 Pushed	Tri-X · 1600 Pushed	2383 Bleach Bypass Cinema print	Velvia 50 · Cross Cross-processed	Provia 100F · Cross Cross-processed

How the film engine works

The datasheets drive an offline model that bakes each film into a Base Look table and its effects settings. Only those ship, and the GPU applies them while you edit:

```mermaid flowchart LR pdf["Makers' datasheets
Kodak · Fujifilm · Ilford"] --> data["research/film-data
curves · sensitivities · dyes · granularity"] subgraph model["Film model (offline)"] direction LR spectrum["

... (README truncated for length)