# How to Vibe Code Your Own Skylum (and Stop Paying for It)

> AI-powered photo editing applications and professional digital imaging tools

- Site: https://skylum.com
- Category: Creative Software
- Verdict: **Impossible** (12/100 vibecodeable)
- Estimated effort: 6+ months of full-time work for a graphics systems team

## Verdict

You cannot vibecode Skylum because building a high-performance local RAW engine, GPU-accelerated neural networks, and native cross-platform graphics apps requires deep computer graphics systems engineering, not web tech.

Skylum is an engineering behemoth built over 18 years by a team of native graphics and machine learning engineers. Vibecoding agents like Claude Code or Cursor write web applications in TypeScript and Python; they cannot author a custom C++/Swift RAW decoding engine or optimize neural network weights to run real-time image segmentation via Metal on local GPUs. Attempting to clone this with an AI agent will hit an immediate wall when the agent tries to invent low-level graphics shaders and sensor-specific demosaicing algorithms.

### What you can't replicate

- Proprietary raw camera sensor decoding for hundreds of distinct manufacturer formats
- High-performance local GPU-accelerated neural network inference engine
- Non-destructive layer graphics pipeline running at 60fps on 50MP images
- Native bidirectional plugin integration with Adobe Photoshop and Lightroom

## What it does

Skylum develops high-performance native photo editing software like Luminar Neo and Aperty, featuring local RAW processing engines, neural network-driven local AI features (sky replacement, object removal, generative editing), and cross-device mobile support.

### Core features

- Native RAW image processing engine for 50+ megapixel files
- Local GPU-accelerated machine learning inference (ONNX/CoreML)
- Layer-based non-destructive editing engine with history states
- AI Sky Replacement, Relighting, and Object Removal
- Generative editing tools (GenErase, GenSwap, GenExpand)
- Plugin host integration for Adobe Photoshop and Lightroom Classic
- Cross-device mobile editing and syncing engine
- Digital asset marketplace for presets, LUTs, and overlays

## The business

### Pricing

- Perpetual Desktop License: $119.00 — One-time payment for desktop app on Windows/macOS with 1 year of generative tools
- Perpetual Cross-Device License: $159.00 — Desktop plus mobile app access
- Perpetual Max License: $179.00 — Complete package with creative library
- Aperty Monthly: $30/mo — Specialized AI portrait retouching software

### Funding

0 raised.

Founded 2008.
Team size: 100-159.

## The hard parts

- Writing a high-performance native RAW decoding engine supporting hundreds of camera sensor formats in Swift/C#
- Optimizing heavy neural network segmentation and generative models to run locally on consumer client hardware via Metal/OpenGL without cloud bottlenecks
- Building a robust non-destructive graphics rendering pipeline with real-time mask generation and high-DPI canvas zooming
- Maintaining stable bidirectional plugin architecture across third-party applications like Adobe Photoshop and Lightroom

## How to vibe code Skylum

### Prerequisites

- Mac + Xcode (Free (Developer account $99/yr for distribution)): Required for writing native macOS/iOS applications in Swift and SwiftUI with Metal acceleration.
- Node.js (free): Required for building any accompanying web spaces or asset marketplace backend.
- Cursor ($20/mo): AI code editor for authoring scaffolding and web-based supporting components.

### Recommended AI tools

- Claude Code: Best-in-class coding agent for generating the web marketplace and supporting APIs.
- Cursor: Provides an IDE environment for editing both web and helper code.

### Stack

- Frontend: Swift / SwiftUI (Desktop & Mobile client subset)
- Backend: Next.js (for Marketplace and User Licensing backend)
- Database: Turso
- Auth: better-auth
- Payments: Stripe
- Other: Fal.ai API (for cloud fallback generative photo editing features), Cloudflare R2 (for storing asset marketplace presets and LUTs)

### Hosting

- Cloudflare (Hosting the asset marketplace, user account dashboard, and preset storage via R2.): $0-5/mo
- None — runs locally (The native image editor runs completely offline on local client hardware.): $0/mo

### Build guide

1. **Scaffold Marketplace Web Portal & Licensing DB** — Establish the Next.js web application for user authentication, software license key verification, and the digital asset marketplace.

```
Create a Next.js 16 application using TypeScript, Tailwind CSS, and better-auth for authentication. Set up a Turso SQLite database schema with tables for users, licenses (tracking 2-device activation limits), and marketplace products (presets, LUTs, courses). Implement an account dashboard where users can view their active licenses, download app installers, and browse the digital creative asset catalog. Ensure strict TypeScript types and robust error handling on all API routes.
```

2. **Build Native macOS Canvas Shell (Subset Scope)** — Create a native macOS desktop wrapper in Swift and SwiftUI capable of opening JPEG/PNG images and rendering them inside a pan/zoom graphics view.

```
Write a native macOS application using Swift and SwiftUI that provides a dark-themed photo editing workspace. Implement a file importer supporting JPEG and PNG images, a high-performance custom NSView/SwiftUI canvas supporting pinch-to-zoom and pan navigation, and a sidebar layout for adjustment panels. Integrate CoreImage filters for basic exposure, contrast, and saturation adjustments applied non-destructively to a master image buffer.
```

3. **Integrate Cloud Generative Fallbacks (GenErase API)** — Connect the native desktop client to a cloud AI endpoint (via fal.ai) to simulate cloud-backed generative inpainting and object removal.

```
Add a brush mask tool to the Swift macOS app allowing users to paint over unwanted elements on the canvas. When the user clicks 'GenErase', serialize the base image and the binary mask into a multipart request payload, and dispatch it to an external image-to-image AI endpoint (using fal.ai Flux Inpaint). Receive the processed image bytes asynchronously, load them into a new editing layer, and render the result seamlessly onto the canvas with undo/redo history state support.
```

4. **Implement Preset and Asset Marketplace Sync** — Build an in-app download manager that syncs creative presets and LUTs from the web marketplace directly into the local desktop app directory.

```
In the Next.js backend, add an API endpoint to serve downloadable preset JSON files and binary LUT (.cube) files stored in Cloudflare R2. In the Swift macOS app, implement a marketplace tab that authenticates against the user's account, fetches available presets, and downloads them over HTTPS into the local application support directory. Parse the downloaded JSON filter parameters and apply them instantly to the active image filter chain.
```

### Cost vs paying

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

- Apple Developer Account: $99/yr
- AI API Credits (fal.ai for generative features): $20
- Total: ~$119 one-time

**Ongoing costs (monthly):**

- Cloudflare Workers & R2 Storage: $5/mo
- Cloud AI Generative API Usage: ~$10/mo
- Total: ~$15/mo

- Paying for the SaaS instead: $119 one-time (Luminar Neo)
- Build time: 160+ hours (Subset desktop prototype only)
- AI tool credits: $40 (Cursor Pro + Claude Code API credits)
- Break-even: Never — buying the perpetual license is vastly cheaper and yields a vastly superior product.

## Sources

- [Skylum Official Website](https://skylum.com)
- [Luminar Neo Pricing & Tech Specs](https://skylum.com/luminar/pricing)
- [Aperty Pricing](https://skylum.com/aperty/pricing)