Skip to content
pchPublic

About

📸 Free, fast, Lightroom-compatible RAW photo editor for Linux, macOS, and Windows.

Topics

Resources

Contributing

Stars

1.7k stars

Watchers

3 watching

Forks

Latest commit

 

History

3,381 Commits

Folders and files

Repository files navigation

RAWmakase

/raw·muh·KAH·say/, RAW + omakase

RAWmakase is a fast, non-destructive RAW photo developer for Linux, macOS and Windows, written in Rust. It develops RAW, JPEG, PNG, TIFF, WebP, AVIF, HEIF/HEIC and JPEG XL files with a Lightroom-style set of controls and exports JPEG, 16-bit TIFF, PNG or JPEG XL, with HDR edits exported as HDR TIFF or JPEG XL or as JPEG with a gain map (exporting to WebP, AVIF and HEIF is not available yet). It can also import a Lightroom Classic catalog with its ratings, flags, labels, keywords and compatible develop settings, without ever writing to the original catalog or your photos.

RAWmakase Develop view with presets, the photo, and the Basic and Tone Curve panels

⬇ Download the latest version
macOS (Apple Silicon, Intel) · Linux (.deb, .rpm, Arch) · Windows (x86_64, ARM64) · install notes

It is a personal project in active development. It develops photos from almost every current camera, including monochrome DNGs (such as the Leica Monochrom's), linear DNGs (such as iPhone ProRAW) and Lightroom's HDR and panorama merges; the exceptions are Sigma's Foveon cameras, GoPro's GPR files, the Pentax K-3 Mark III Monochrome's PEFs (its DNGs open), and Adobe's older lossy DNGs (JPEG-compressed, as Adobe DNG Converter's "lossy compression" writes them). Rendering aims for close, not exact, Lightroom parity; see parity gaps.

Warning

RAWmakase is early software in active development. The rendering engine may change from one version to the next, so photos you have already edited can look different after an upgrade. Until 1.0, backwards compatibility is limited and not guaranteed. The contents of your originals are never modified, but keep exports of finished work.

Features

  • Develop: white balance and picker, one-click Auto tone and Auto white balance, exposure and tone, Shadows/Highlights, Clarity, Dehaze, point curves and levels, HSL color mixer, three-way color grading, sharpening, crop, straighten and Transform, lens corrections, effects and calibration.
  • HDR: edit a RAW or HDR file in High Dynamic Range, as Lightroom's HDR does, see light above SDR white on an HDR display (seen on macOS; the Windows and Wayland paths are not yet checked on a real HDR display), and export PQ or HLG TIFF and JPEG XL or gain-map JPEG; see HDR.
  • Denoise: Luminance and Color noise reduction fitted to Camera Raw's, using the noise measured in each photo.
  • AI Denoise: a neural model denoises and demosaics the RAW in one pass, on this computer (on the GPU on Apple Silicon), blended in by Amount as in Lightroom's Denoise; see AI Denoise.
  • Spot removal and masks: Heal and Clone spots and brushed areas with automatic sources, and brush, gradient and range masks with local adjustments, also imported from Lightroom.
  • AI masks: one-click Select Subject, Sky and Background, made by models running on this computer or on a remote worker, and refined with brushes, ranges and gradients; see masking.
  • AI object removal (experimental): AI Remove and AI Replace regenerate what you paint over, with a prompt, through the AI Retouch extension and your own API key; see AI Retouch.
  • Library: SQLite catalogs, folders, ratings, flags, color labels, filtering, and non-destructive Lightroom .lrcat import with folder relinking.
  • Presets and profiles: 26 built-in presets and your Lightroom XMP presets; RAWmakase's own Standard and Color profiles for every camera with a usable color matrix, plus DCP and XMP camera profiles you import yourself, and .cube LUTs imported as looks, as Camera Raw makes them.
  • Non-destructive: the contents of your originals are never modified. Edits live in the catalog, and all writes are atomic.
  • Fast previews: every change renders at viewport size, with the color and tone stage on the GPU (Metal on macOS, Vulkan on Linux, DirectX 12 on Windows) and a CPU fallback.
  • Command line and headless rendering: inspect, render, export thumbnails, import catalogs and profiles, and benchmark without the GUI; render on a server or in a container with no display or GPU.
  • Keyboard shortcuts: Lightroom's, each one changeable in Preferences > Shortcuts or in a keymap.toml; see keyboard shortcuts.
  • Extensions: add commands, panels, control adapters, mask generators, retouch generators and photo sources (watched folders, tethering), written in Rust with the extension SDK and packaged with cargo rawmakase. MIDI, MCP and AI Masks are bundled; others install from Preferences > Extensions. See extensions.
  • External control: MIDI controllers, scripts, and an MCP server for agents to adjust the running editor, inspect previews, save and export.
  • Updates: the app checks GitHub for new releases; the Apple Silicon and Windows installer builds update themselves, other installs are pointed at the release page.

Install

Download the package for your system from GitHub Releases.

Let your agent install it

Point your coding agent to GitHub Releases and tell it to install the latest version for your operating system, or give it this prompt:

Install the latest release of RAWmakase for my operating system from https://github.com/pch/rawmakase/releases. Pick the right package for my OS and CPU architecture, verify it against the release's checksums, install it, and tell me how to launch it.

Omarchy

Install rawmakase-bin from Omarchy menu → Install → Package, or from a terminal:

omarchy pkg add rawmakase-bin

It updates with the rest of the system.

Omarchy makes windows slightly transparent by default, which changes how photos look. To keep RAWmakase fully opaque, add this to your Hyprland looknfeel.lua:

-- Keep RAWmakase fully opaque (opt out of Omarchy's default window opacity)
o.window("^RAWmakase$", { tag = "-default-opacity", opacity = "1 1" })

macOS (15 or newer)

Install with Homebrew:

brew install --cask pch/tap/rawmakase

Update with brew upgrade --cask rawmakase.

Or install the DMG directly:

Choose rawmakase-v<version>-macos-arm64.dmg for Apple Silicon or rawmakase-v<version>-macos-x86_64.dmg for Intel. Open the DMG, drag RAWmakase into Applications, and launch it there. Release DMGs are signed and notarized and carry the ONNX Runtime library that subject, sky and background selection and AI Denoise need; Homebrew is not required.

Linux (x86_64 and aarch64)

Download the package for your architecture (amd64/x86_64 or arm64/aarch64), then run the matching command from its folder, replacing the filename with the one you downloaded:

System Package Install
Ubuntu 24.04+ / Debian 13+ .deb sudo apt install ./rawmakase_<version>_amd64.deb
Fedora 43+ .rpm sudo dnf install ./rawmakase-<version>-1.x86_64.rpm
Arch Linux (x86_64) .pkg.tar.zst sudo pacman -U ./rawmakase-<version>-1-x86_64.pkg.tar.zst

Arch packages use system dependencies. A working graphics driver is required; install your desktop's xdg-desktop-portal backend for native file dialogs.

AUR publication is paused. Install the Arch package directly, or (on Arch Linux ARM too) download and extract rawmakase-<version>-arch-recipe.tar.gz into an empty folder and build as a normal user:

makepkg -si

The development recipe is in packaging/arch/rawmakase-git.

The rawmakase-<version>-<arch>-linux.tar.gz download contains the same files as the DEB/RPM packages, including the bundled ONNX Runtime library. Extract it and run ./usr/bin/rawmakase from the extracted folder. Keep the whole directory together. It requires the same OS/runtime baseline as the packages above; it is not a fully static build.

The rawmakase-<version>-<arch>.AppImage download is the same build as a single file: make it executable (chmod +x) and run it. It needs the same OS baseline as the packages above (Ubuntu 24.04+, Debian 13+, Fedora 43+; glibc 2.39 or newer), so it does not run on older distributions. On systems without FUSE 2, run it with APPIMAGE_EXTRACT_AND_RUN=1. It carries update information, so AppImageUpdate, Gear Lever and similar tools can update it to the newest release, downloading only what changed.

Windows (10 or newer on x86_64, 11 on ARM64)

Run rawmakase-v<version>-x86_64-pc-windows-msvc-setup.exe, or rawmakase-v<version>-aarch64-pc-windows-msvc-setup.exe on an ARM64 PC. It installs for your user account only, without administrator rights, and adds RAWmakase to the Start menu. The installer is not code-signed yet, so Microsoft Defender SmartScreen may warn about an unrecognized app: choose More info → Run anyway. For a copy without installing, extract rawmakase-v<version>-<arch>-pc-windows-msvc.zip and run rawmakase.exe from the extracted folder.

HEIC photos (from phones) are decoded by Windows itself, which needs Microsoft's HEIF Image Extensions and HEVC Video Extensions from the Microsoft Store; some PCs come with them. Without them HEIC photos are listed but not shown, and opening one says what to install.

Updates and verification

RAWmakase checks GitHub for a newer release after launch and once an hour, and shows a notice when one is out (turn the check off in Preferences). The Apple Silicon DMG and the Windows installer download and install the update themselves; Intel Macs, the Linux tarball and AppImage, the Windows archive and package-managed installs (Homebrew, DEB, RPM, Arch) are pointed at the release page or their package manager. Settings and catalogs are kept separately from the installed application, so reinstalling over an old version loses nothing.

Each release includes SHA256SUMS. After downloading it beside your package, verify downloaded files on Linux with sha256sum --ignore-missing -c SHA256SUMS. On macOS, use shasum -a 256 <downloaded-file> and compare the result with that file's entry in SHA256SUMS.

From source (Linux and macOS)

You need Rust 1.98 or newer and a C compiler (a few Rust crates, such as the catalog's bundled SQLite, compile C); no RAW or colour-management library is needed.

  • Arch Linux: sudo pacman -S rust base-devel
  • macOS: the Xcode command-line tools (xcode-select --install). Use a native rustup toolchain (aarch64-apple-darwin on Apple Silicon).
make                                  # cargo build --release --locked
make install PREFIX="$HOME/.local"    # binary, desktop entry, icon and licenses

make install never builds, so make && sudo make install PREFIX=/usr does not compile as root. make uninstall removes the installed files.

On Linux, HEIC photos are decoded by the system's libheif with its HEVC decoder (libde265), opened when RAWmakase first needs it: install libheif on Arch, libheif1 and libheif-plugin-libde265 on Debian or Ubuntu, or libheif-freeworld from RPM Fusion on Fedora. Without it HEIC photos are listed with their metadata, and opening one says what to install (see dependencies).

On macOS, packaging/macos/app.sh builds target/release/RAWmakase.app, which you can open from Finder. It is not signed and does not include ONNX Runtime: to run the selection models or AI Denoise on this Mac, place libonnxruntime.dylib in the bundle's Contents/Frameworks (packaging/onnxruntime.py fetches the pinned library).

Usage

rawmakase                     # reopen the last catalog
rawmakase Photos.rawmakase    # open a catalog
rawmakase photo.dng           # add the photo's folder to the last catalog and edit it

Photos are edited through the Library. The first launch starts a catalog named Photos in RAWmakase's data folder and asks for a folder of photos; to keep your Lightroom Classic folders, ratings and edits, import its catalog instead. Both, and other catalogs, are available later from the Catalog menu. Folders dropped onto the window, one or several, are added to the open catalog; right-click a folder in the Library's Folders panel to remove it and its photos from the catalog (its files stay on disk), or select photos and press Delete to move their files to the Trash or just remove them from the catalog. Drag photos onto a folder, or use Move to Folder… in their menu, to move their files there; New Folder Inside… in a folder's menu makes a folder and can move the selection into it. F2 renames a photo, or several by a template in the order they were taken; Rename Folder… renames a folder, and a folder dragged onto another (or Move Folder…) moves there. A photo dropped there or passed on the command line has its folder added, then opens in Develop. You can also drop a catalog onto the window. The camera's embedded JPEG shows immediately while the RAW develops. A JPEG, PNG, TIFF, WebP, AVIF, HEIF or JPEG XL opens in Develop like a RAW: untouched it looks as the file does, and its white balance is Lightroom's relative Temp and Tint (−100 to 100) rather than Kelvin. WebP, AVIF and HEIF are read only for now. An HDR file (PQ, HLG, linear light or a gain map) opens as an HDR edit; see HDR files. Develop does not edit animated, tiled AVIF or 4:2:2 and monochrome HEIF files; animated ones still show in the Library.

Useful shortcuts:

Key Action
Left / Right Previous / next photo
F / Z Fit / toggle Fit and 100%
0–5, 6–9 Rating; red, yellow, green, blue label
P / X / U Pick / reject / clear flag
Shift + rating, label or flag key Apply and advance
R or C Crop
J Shadow and highlight clipping warnings (click a histogram triangle for one)
Backslash Before alone
Shift+Backslash Camera thumbnail: the embedded JPEG, labelled, in place of the photo
Y / Option+Y / Shift+Y Before and after: left and right / top and bottom / split
I Photo info over the photo: Info 1, Info 2, off
Shift+R Reference View: another photo beside the one you edit (drag it from the filmstrip)
Tab / Shift+Tab Hide or show the side panels / also the filmstrip and status bar
F7 / F8 / F6 Hide or show the left panel / right panel / filmstrip
F11 Full screen (on a Mac, View › Enter Full Screen)
Cmd/Ctrl+Z, Cmd/Ctrl+Shift+Z Undo / redo
Cmd/Ctrl+Shift+U Auto tone

Double-click a slider or a color grading wheel to reset it, type its value for precision, or hover a slider and press Up or Down (Shift for ten steps). As in Lightroom, . and , select the next or previous Basic slider (or click its name), and = and - step it by Lightroom's amounts (Shift for more, Option for less), even with the panel folded. On a grading wheel, Shift keeps a drag to hue or saturation and Cmd/Ctrl moves it finely. Drag sideways in the histogram to move Blacks, Shadows, Exposure, Highlights or Whites, whichever region you start in.

Tab hides the side panels to give the photo the window, and Shift+Tab the filmstrip too; pressed again, each brings back the panels it hid. The panel buttons at either end of the top bar hide or show the left panel, the right panel or the filmstrip alone.

The switch in a panel's header turns the panel off without losing its settings, as in Lightroom; right-click a header for Solo Mode, where opening one panel closes the others on that side.

Camera profiles

Every camera with a usable color matrix gets two profiles of RAWmakase's own: RAWmakase Standard (the camera's color matrix with the DNG default tone curve) and RAWmakase Color (a mild look on top of it). A new photo uses a compatible imported Adobe Color, then Adobe Standard, then a DNG's own profile, and RAWmakase Color when it has none of those. No Adobe profiles are bundled. For Lightroom's color, import DCP and XMP profiles you are licensed to use (for example from your own Lightroom or Camera Raw installation, or published third-party DCPs such as RawTherapee's) from the Profile menu in Develop, from Preferences, or with rawmakase import-profiles. The same import takes .cube LUTs, which become look profiles with a Profile Amount, as Camera Raw's Create Profile makes them, for LUTs made for sRGB, Adobe RGB, Display P3, ProPhoto RGB or Rec. 2020. On a Mac or PC, the Profile menu also looks in Camera Raw's profile folder and, when it finds profiles filed under the camera's name, offers to import them in one click. Imported profiles are copied into RAWmakase's own data directory. See Lightroom profiles.

Command line

rawmakase inspect photo.dng
rawmakase thumbnail photo.dng embedded.jpg
rawmakase render photo.dng edited.jpg --exposure 0.7 --max-edge 2400
rawmakase render photo.dng small.jpg --max-edge 1600 --quality 80
rawmakase render photo.dng edited.tiff --xmp preset.xmp
rawmakase render photo.dng edited.jpg --auto
rawmakase render photo.dng wide.tiff --color-space prophoto
rawmakase import-catalog Lightroom.lrcat Photos.rawmakase
rawmakase fingerprint *.NEF        # decode facts per file as JSON lines, for regression checks
rawmakase help

render starts where the app would. With --catalog Photos.rawmakase it uses the photo's edit in that catalog: its saved edit, else its Lightroom edit, else the raw defaults. A path names the master, not a virtual copy, and a photo the catalog doesn't have is an error. Without a catalog it uses the raw defaults chosen in Preferences. --recipe replaces that starting point with a saved RAWmakase preset; --xmp applies an XMP preset on top of it, so settings the XMP leaves out keep the starting point's values. For a render that depends on nothing saved, pass --recipe. The catalog's export settings don't apply: the output is what the command line asks for. It needs --overwrite to replace an existing file. --quality 1–100 sets a JPEG's quality, as the Export dialog's slider does (92 without it); a .jxl output is lossless unless --jxl-quality gives it one. render-batch --quality applies to the jobs it writes as JPEG.

Headless rendering

render and render-batch open no window and need no display server or GPU, so they run on a server, in a container or from a script. Point RAWMAKASE_DATA_DIR at a folder, import the camera profiles your presets use into it with import-profiles, and render:

export RAWMAKASE_DATA_DIR=/srv/rawmakase
rawmakase import-profiles /path/to/profiles/
rawmakase render photo.ARW out.jpg --xmp preset.xmp --max-edge 2400 --quality 85

The Linux build needs glibc 2.39 or newer (Ubuntu 24.04+, Debian 13+, Fedora 43+), so AWS Lambda needs a container image. Output goes to local files; copy them to S3-compatible storage with rclone or the AWS CLI. See Headless rendering for the folders, AI Denoise's model, a container example and the limits.

Where data lives

  • Catalogs, with every edit: the .rawmakase file you choose.
  • Profiles, presets, previews and session state: ~/Library/Application Support/RAWmakase on macOS, $XDG_DATA_HOME/rawmakase (default ~/.local/share/rawmakase) on Linux, %APPDATA%\RAWmakase on Windows. RAWMAKASE_DATA_DIR overrides it.

Exports are sRGB unless the Export dialog's Color Space says Adobe RGB (1998) or ProPhoto RGB (16-bit TIFF only), each with its own embedded profile; render and render-batch take --color-space srgb|adobe-rgb|prophoto. An HDR export is in Rec. 2020, Display P3 or Rec. 709 instead (HDR export). The preview of an SDR edit is sRGB and is not a soft proof of a wider export; an HDR edit on an HDR display shows light above SDR white. The display defaults to sRGB; pick a monitor ICC profile under More only if your compositor does not already manage color.

Development

Start with CONTRIBUTING.md, the documentation index, the code map and the architecture guide. The website source and deployment guide live in website/.

make check    # every CI check that runs locally: fmt, clippy, tests, cargo doc, MSRV build, scripts

The repository contains no RAW photos, Lightroom catalogs or camera profiles, so tests that need them are ignored by default. Run them with your own files:

Environment variable Test target Needs
RAWMAKASE_FIXTURES --test raw_fixtures A folder of RAW files (the test currently expects both a Bayer and an X-Trans file)
RAWMAKASE_PROFILES --test private_profiles A folder of DCP files
RAWMAKASE_TEST_DCP -p rawmakase-model --lib camera_profiles A DCP file (the assertions currently match RawTherapee's SONY ILCE-7M2.dcp)
RAWMAKASE_LRCAT -p rawmakase-catalog --lib catalog A Lightroom catalog
RAWMAKASE_CORPUS --test color The private tier of the color corpus: your own RAWs and their Camera Raw renders
RAWMAKASE_FIXTURES=~/raw-fixtures cargo test --release --test raw_fixtures -- --ignored --nocapture

The public part of the color corpus runs with every cargo test: synthetic chart DNGs rendered on the CPU and compared with committed snapshots and with Camera Raw's renders of the same charts, so a color change beyond its tolerances (ΔE00 0.5 per patch, 0.1 on a case's mean) is noticed. The GPU preview path is covered by the hardware tests below, not by this suite. When a change is intended, RAWMAKASE_BLESS=1 cargo test --test color rewrites the snapshots, and also the charts and the Camera Raw baseline (tests/corpus/camera-raw/baseline.json). Read the baseline diff on its own before committing: it records how far renders are from Camera Raw, and accepting a larger distance should be a decision, not a side effect. Commit the files with the reason.

Tests that need a real file system other than the one the repository is on are ignored too. They are the main checks that the fake disk the file-operation tests use behaves like real volumes. Point each variable at a writable folder on such a volume and run the test by name with -- --ignored, for example RAWMAKASE_TEST_OTHER_VOLUME=/Volumes/Card cargo test -p rawmakase-catalog real_volumes -- --ignored:

Environment variable Tests Needs
RAWMAKASE_TEST_OTHER_VOLUME -p rawmakase-catalog: a_move_between_two_real_volumes, a_folder_moves_between_two_real_volumes, a_root_moves_between_two_real_volumes; -p rawmakase: another_volume_says_what_its_trash_does (with RAWMAKASE_TRASH_TESTS=1 it also trashes a synthetic folder there) A writable folder on a second drive, card or disk image
RAWMAKASE_TEST_FAT_VOLUMES -p rawmakase-fs: fat_and_exfat_volumes_are_told_and_have_no_stable_ids Folders on FAT or exFAT volumes, separated as PATH is
RAWMAKASE_TEST_NTFS_VOLUMES -p rawmakase-fs: ntfs_volumes_rename_without_replacing_and_keep_the_file_object Folders on NTFS volumes, separated as PATH is
RAWMAKASE_TEST_NTFS_VOLUME -p rawmakase-catalog: photos_on_an_ntfs_volume_rename A writable folder on an NTFS volume
RAWMAKASE_TEST_NETWORK_SHARE -p rawmakase-fs: an_smb_share_is_told_and_makes_files_only_where_none_is; -p rawmakase: a_file_on_an_smb_share_is_kept_as_its_volume_has_no_trash A writable folder on an SMB share
RAWMAKASE_TEST_MOUNT, RAWMAKASE_TEST_MOUNT_NAME -p rawmakase: a_drive_mounted_anywhere_is_found A drive's mount point and its label
RAWMAKASE_TEST_VHDS, RAWMAKASE_TEST_LETTER -p rawmakase (Windows only): two_disks_swapped_at_one_letter_are_two_drives Two .vhdx files, each a volume holding a folder named as its label, and a drive letter; run as an administrator

GPU tests are ignored as well; run them with cargo test -p rawmakase-engine --lib gpu -- --ignored on a machine with a compute adapter. The GPU parity workflow runs them on a macOS runner for pull requests that touch the renderer, the model's colour, profile, optics or preview-overlay maths, or wgpu, and weekly on main.

Application CI runs the checks make check runs, on Linux, Windows and macOS, plus a release build, an Arch package build and a cargo deny license and advisory audit. Website-only pushes and pull requests run the Hugo build instead; edits to its workflow also run the workflow linter. A stable vX.Y.Z tag on main matching Cargo.toml builds both macOS DMGs, the Linux packages and the Windows installer. Publication waits for Apple notarization and package checks, then refreshes the website's download links. See packaging/RELEASING.md for credentials, rehearsal runs, supported systems and the AUR pause.

The RAW decoders have fuzz targets (fuzz/: open, preview and decode of rawmakase-raw), run nightly by the Fuzz RAW decoders workflow, seeded only from the repository's synthetic DNGs. Locally: cargo +nightly fuzz run open from the repository root, with cargo-fuzz.

Skills

Coding agents follow AGENTS.md. For the recurring maintainer workflows, and for writing extensions, the repository also has skills in .agents/skills/ (Codex reads them there; .claude/skills links to the same folder for Claude Code). Run one with /name in Claude Code or $name in Codex, or just ask in plain words: agents pick a skill up from its description.

Skill What it does Example
issue Reads an issue and everything it links, checks for overlapping PRs, gets sample RAWs, reproduces the bug with a failing test, fixes it and hands off to ship. Can also stop at a diagnosis or a status report. /issue 812
"#812: investigate, don't fix yet"
"where do we stand with #675?"
ship Has a model from another provider review the change until it approves, then opens the PR, watches CI and bot comments, and merges when green. Can also review a plan before any code is written. /ship
"let codex astra medium review, merge when green"
"PR only, don't wait for Windows CI"
"plan this with codex until you agree, let me approve"
release Waits for the PRs you name, writes the release notes from the tagged range with credits, commits Release x.y.z, tags it and follows the build through to publication. /release 0.4.12 after #812
"cut 0.4.12, highlights: AI masks, credit contributors, do a tldr"
"what would go into the next release?"
gh-reply Writes issue and PR comments for the maintainer, signed by the model that wrote them. Drafts first when the reply makes a decision: refusing, closing or promising. "ask the reporter for their system info, they're not technical"
"thank the contributor and merge"
"decline this PR, cite licensing risk; let me approve before posting"
extension Takes a new extension from cargo rawmakase new to a published package: the manifest rules, the SDK's commands, panels, control adapters, mask generators and photo sources (watched folders, tethering), MockHost tests and the protocol's pitfalls, with tested code sketches. A separate checklist covers bundled extensions in this repo. "write an extension that adds a film-look command"
"add a mask generator to my extension"
"package and publish my extension on GitHub"

The skills call on each other: issue hands off to ship, and ship and issue reply on GitHub through gh-reply. Each one is a short Markdown file, and the policy it follows stays in AGENTS.md and the docs it links.

License

RAWmakase is released under the MIT License. The DNG default tone curve and temperature table come from the Adobe DNG SDK, under the license in licenses/Adobe-DNG-SDK.txt. The Adobe RGB (1998) and ProPhoto RGB profiles exports embed are Compact-ICC-Profiles' public-domain (CC0) files (licenses/Compact-ICC-Profiles-CC0.txt). The interface uses the system's own font on macOS and Windows; on Linux it uses Inter, under the SIL Open Font License (licenses/Inter-OFL.txt). The icons are Lucide's, under the ISC License (licenses/Lucide-ISC.txt). egui's bundled fallback fonts are compiled into the binary as well: Hack (licenses/Hack-MIT-BitstreamVera.txt), Noto Emoji (licenses/NotoEmoji-OFL.txt), Ubuntu Light (licenses/Ubuntu-UFL.txt) and the emoji icon font (licenses/emoji-icon-font-MIT.txt). The Rust dependencies and ONNX Runtime keep their own licenses; see dependencies.

Adobe, Lightroom and Camera Raw are trademarks of Adobe Inc. RAWmakase is not affiliated with or endorsed by Adobe.

About

📸 Free, fast, Lightroom-compatible RAW photo editor for Linux, macOS, and Windows.

Topics

Resources

Contributing

Stars

1.7k stars

Watchers

3 watching

Forks

Releases

Sponsor this project

Packages

Contributors

Languages