# How to Vibe Code Your Own ON1 Photo RAW (and Stop Paying for It)

> All-in-one photo editing, RAW processing, and AI tools without a subscription

- Site: https://on1.com
- Category: Desktop Software
- Verdict: **Don't bother** (12/100 vibecodeable)
- Estimated effort: 6+ months of full-time work (and likely failure on core rendering engines)

## Verdict

Keep paying for ON1 Photo RAW; building a functional personal clone requires writing an entire C++/Rust RAW demosaicing engine and GPU image pipeline from scratch.

Replicating a performance-intensive native desktop application like ON1 Photo RAW as a solo developer using AI coding agents is practically impossible at parity. While AI agents can write boilerplate wrappers or scaffold UI components in Tauri or Electron, they cannot magically synthesize proprietary RAW camera sensor decoders, high-performance GPU-accelerated graphics shaders for real-time canvas manipulation, or optimized on-device machine learning pipelines for noise reduction and upscaling. You would spend months debugging memory leaks, threading bottlenecks, and color science rendering errors. At ~$99 for a perpetual license, paying for the software is infinitely more rational than attempting an impossible systems-programming death march.

### What you can't replicate

- Proprietary RAW demosaicing libraries supporting thousands of specific camera sensors
- 21 years of low-level C++ performance optimization for zero-latency GPU canvas rendering
- Extensive plugin compatibility bridge for Adobe Photoshop and Lightroom Classic

## What it does

A performance-intensive desktop software suite for digital photo organization, non-destructive editing, RAW demosaicing, and local AI-powered retouching and enhancement.

### Core features

- RAW camera sensor demosaicing parser for hundreds of camera models
- Non-destructive editing history tree and parameter serialization engine
- GPU-accelerated hardware rendering canvas for real-time zooming and panning
- Local machine learning model execution for noise reduction, upscaling, and portrait retouching
- Layered compositing, blend modes, and brush masking tools
- Digital asset management (DAM) cataloging with metadata search and smart albums
- Bi-directional plugin architecture for host apps like Adobe Photoshop and Lightroom

## The business

### Pricing

- ON1 Photo RAW (Perpetual): $99.99 — Standalone perpetual license for core editing and cataloging.
- ON1 Photo RAW MAX: $199.99 — Includes full plugin integration for Photoshop/Lightroom and advanced AI tools.
- ON1 Photo Studio Subscription: $89.99/yr — All apps, plugins, 1TB cloud sync storage, and training resources.

Founded 2005.
Team size: 24-60.

## The hard parts

- Writing or binding a high-performance C++/Rust RAW parsing and demosaicing engine to decode proprietary camera sensor arrays
- Optimizing real-time GPU graphics pipelines (Metal/DirectX/Vulkan) for instantaneous canvas rendering during heavy brush strokes and filter adjustments
- Managing local on-device neural network runtimes (ONNX/CoreML) for heavy computer vision tasks without crashing user GPUs
- Architecting a transactional non-destructive metadata history tree that re-renders filter stacks instantly

## How to vibe code ON1 Photo RAW

### Prerequisites

- Mac or Windows Workstation (existing hardware): Required for compiling native desktop binaries with direct GPU access
- Rust & C++ Toolchain (free): Needed for building high-performance image processing modules via Tauri

### Recommended AI tools

- Claude Code: Best-in-class multi-file agent for bootstrapping the application architecture and writing Rust bindings
- Cursor: Useful for iterating on the frontend UI layout and component styling

### Stack

- Frontend: React + TypeScript inside a Tauri desktop shell
- Backend: Rust (core image processing and file system indexing)
- Database: SQLite (local metadata catalog and editing history)
- Auth: None (local desktop app)
- Payments: None (personal use subset)
- Other: libraw (open-source RAW image decoder library), OpenCV / image-rs for basic pixel manipulation

### Hosting

- Local Desktop Execution (Runs entirely locally on your workstation hardware): $0/mo

### Build guide

1. **Scaffold Tauri Native Desktop Shell** — Initialize a cross-platform desktop application project combining a Tauri Rust backend with a React and Tailwind CSS frontend.

```
Create a new Tauri v2 project configured with React, TypeScript, and Tailwind CSS. Set up a clean desktop window layout with a dark-mode photo editing studio aesthetic, including a top menu bar, a left sidebar for tool selection (Develop, Effects, Layers, Export), a central canvas viewport area, and a right sidebar for inspector panels (histogram, color adjustments, layer stack). Configure Tauri IPC commands in Rust to handle basic desktop file dialogs for opening local directories and image files. Ensure proper window resizing bindings and smooth DPI scaling for high-resolution displays.
```

2. **Implement Local File System Indexer & Catalog View** — Build a high-performance local file browser and thumbnail generator using Rust to scan directories and index image files.

```
Implement a Rust-powered file system scanner in the Tauri backend that recursively indexes a selected local folder for image extensions (.jpg, .png, .tiff, and basic raw formats). Generate fast low-resolution thumbnail cache files stored in the application's local data directory. Create a responsive grid view component in React that virtualizes the thumbnail list for smooth scrolling across thousands of assets. Add metadata extraction (EXIF data: shutter speed, aperture, ISO, camera model) to display in a metadata inspector panel when an image is selected.
```

3. **Integrate Open-Source RAW Decoder (LibRaw)** — Incorporate LibRaw or equivalent C/C++ bindings into the Rust backend to parse and demosaic raw camera files.

```
Integrate the LibRaw library (or a Rust wrapper) into the Tauri backend to enable decoding of raw camera sensor files. Write an asynchronous worker task in Rust that decodes a selected RAW file into an RGB bitmap buffer, applying basic half-size demosaicing for fast preview rendering. Expose an IPC command that streams the processed bitmap back to the React frontend canvas for real-time viewing. Handle memory cleanup and error management gracefully when corrupt or unsupported raw files are encountered.
```

4. **Build Non-Destructive Editing History Engine** — Architect a transactional parameter tree that records all adjustments without modifying the source image file.

```
Design a non-destructive editing history state machine in TypeScript and Rust. Implement a data model where every adjustment (exposure, contrast, saturation, white balance, highlights, shadows) is stored as a JSON parameter tree rather than modifying pixel data. Create UI slider controls in the Develop panel that update the state tree in real-time. Write a Rust image-processing pipeline that applies these parameter adjustments sequentially onto the decoded bitmap buffer whenever slider values change, ensuring undo/redo history stack integrity.
```

5. **Implement GPU-Accelerated Canvas Viewport & Zoom** — Build a responsive WebGL/WebGPU canvas component supporting smooth panning, zooming, and brush masking overlays.

```
Build a high-performance canvas component using HTML5 Canvas backed by WebGL shaders (or Tauri webview acceleration) to render large image bitmaps. Implement smooth mouse-wheel zooming centered on the cursor position and click-and-drag panning. Overlay a brush masking layer system that records brush stroke coordinates and radius locally, allowing users to paint adjustment masks over specific regions of the image. Optimize rendering loops to maintain 60fps interaction during canvas navigation.
```

6. **Build Batch Export & File Rendering Pipeline** — Create an export module to render and save edited photos out to standard image formats with custom sizing and color profiles.

```
Implement an export module in the Rust backend that processes a queue of selected images through the non-destructive editing history stack at full resolution. Add export configuration settings in the UI: format selection (JPEG, TIFF, PNG), quality slider, color space (sRGB, Adobe RGB), target resizing dimensions, and destination folder naming templates. Display a real-time progress bar tracking export completion and notify the user upon successful batch export.
```

### Cost vs paying

**Starting costs (one-time):**

- Hardware Workstation: existing
- Total: $0 one-time

**Ongoing costs (monthly):**

- AI coding assistant subscription: $20/mo
- Total: $20/mo

- Paying for the SaaS instead: $8.33/mo ($99.99/yr perpetual value)
- Build time: 120+ hours (excluding core graphics engineering hurdles)
- AI tool credits: $20/mo (Claude Pro)
- Break-even: Never (paying $99.99 once for the actual software is vastly more cost-effective and functional)

## Sources

- [ON1 Official Website](https://on1.com)
- [PCMag ON1 Photo RAW Review](https://www.pcmag.com/reviews/on1-photo-raw)
- [Tracxn ON1 Company Profile](https://tracxn.com/d/company/on1)