# Why This Repo Matters

> OpenCut is rebuilding a free, MIT-licensed video editor for web, desktop, and mobile. This page separates the product story from what the tree actually contains today: a multi-app monorepo shell, not a finished editor core.

- Repository: OpenCut-app/OpenCut
- GitHub: https://github.com/OpenCut-app/OpenCut
- Human wiki: https://grok-wiki.com/public/wiki/opencut-app-opencut-2bfee888b2cd
- Complete Markdown: https://grok-wiki.com/public/wiki/opencut-app-opencut-2bfee888b2cd/llms-full.txt

## Source Files

- `README.md`
- `Cargo.toml`
- `apps/web/src/router.tsx`
- `apps/api/src/index.ts`
- `apps/desktop/src/main.rs`

---

<details>
<summary>Relevant source files</summary>

The following files were used as context for generating this wiki page:

- [README.md](README.md)
- [Cargo.toml](Cargo.toml)
- [apps/api/src/index.ts](apps/api/src/index.ts)
- [apps/desktop/src/main.rs](apps/desktop/src/main.rs)
- [apps/web/src/router.tsx](apps/web/src/router.tsx)

</details>

# Why This Repo Matters

OpenCut’s public story is a free, MIT-licensed video editor aimed at web, desktop, and mobile. This page separates that product intent from what the tree shows today: a multi-app monorepo shell—API health endpoints, a desktop GPUI window, and a web router—while the rewrite is still being designed.

That gap is the useful signal for maintainers and observers. Classic OpenCut still ships for users; this repository is scaffolding for a ground-up rewrite, not a finished editor core.

Sources: [README.md:7-28](), [README.md:63-64](), [Cargo.toml:1-13](), [apps/api/src/index.ts:1-15](), [apps/desktop/src/main.rs:31-50](), [apps/web/src/router.tsx:1-13]()

## The product story (what the project says it is)

The README frames OpenCut as:

> A free and open source video editor for web, desktop, and mobile.

Licensing is MIT (workspace package metadata and the license badge both say so). The project states it is **being rewritten from the ground up**, with a roadmap that includes:

| Stated direction | What the README claims |
| --- | --- |
| Editor API | Coming as part of the rewrite |
| Plugins | First-class third-party plugins via a plugin-first architecture |
| Multi-platform | Desktop, mobile, and browser from one codebase (Rust core) |
| AI agents | MCP server |
| Automation | Headless mode (batch rendering) |
| In-editor scripting | A scripting tab in the editor |

Until that rewrite is ready, users are pointed at the previous product surface:

- **Classic code:** [opencut-app/opencut-classic](https://github.com/opencut-app/opencut-classic) — “the one to reach for today”
- **Production site:** [opencut.app](https://opencut.app) still runs classic
- **Rewrite preview host:** [new.opencut.app](https://new.opencut.app) until the rewrite takes over

Outside contributions are explicitly paused while architecture is designed; Discord and issues are the stated ways to follow along.

Sources: [README.md:7-28](), [README.md:51-52](), [README.md:63-64](), [Cargo.toml:7-10]()

## What the tree actually contains today

The evidence is not an editor implementation. It is a thin multi-surface shell with three runnable app shapes and a minimal Rust workspace.

```text
OpenCut monorepo (evidence snapshot)
├── Product claim: free FOSS editor (web / desktop / mobile)
│
├── apps/web     → TanStack Router bootstrap
├── apps/api     → Elysia + Cloudflare Worker (health / echo)
├── apps/desktop → GPUI window: "desktop shell scaffold"
│
└── Cargo.toml   → workspace members: apps/desktop only
                    gpui 0.2.2; package version 0.1.0; MIT
```

### Development surface

Root tooling expects [proto](https://moonrepo.dev/proto) and moon targets:

| Command | Role (as documented) |
| --- | --- |
| `proto use` | Install tools pinned in `.prototools` |
| `moon run web:dev` | Web app on localhost:5173 |
| `moon run api:dev` | API on localhost:8787 |
| `moon run desktop:dev` | Desktop app (see `apps/desktop/README.md`) |

Those commands describe how to run the shells; they do not imply editor features exist in the sources below.

Sources: [README.md:31-48]()

### Web: router shell

`apps/web` evidence is a TanStack React Router factory: route tree import, scroll restoration, intent preload. There is no timeline, media pipeline, or editor UI in this file—only app routing infrastructure.

```4:12:apps/web/src/router.tsx
export function getRouter() {
  const router = createTanStackRouter({
    routeTree,
    scrollRestoration: true,
    defaultPreload: 'intent',
    defaultPreloadStaleTime: 0,
  })

  return router
}
```

Sources: [apps/web/src/router.tsx:1-19]()

### API: health and echo only

`apps/api` is an Elysia app on the Cloudflare Workers adapter. Endpoints are:

- `GET /` → `{ status: "ok" }`
- `GET /health` → healthy flag + ISO timestamp
- `POST /echo` → body echo with a typed `{ message: string }`

There is no media upload, project API, auth, or render job surface in this file—only a compile-ready worker scaffold.

Sources: [apps/api/src/index.ts:1-15]()

### Desktop: GPUI placeholder window

The Rust workspace lists a single member, `apps/desktop`, with workspace dependency `gpui = "0.2.2"`, package version `0.1.0`, edition `2024`, license MIT.

The desktop binary opens a 960×600 window titled “OpenCut” and renders a centered label plus status text **`"desktop shell scaffold"`**—an explicit admission that this is a shell, not the editor.

```31:50:apps/desktop/src/main.rs
fn main() {
    Application::new().run(|cx: &mut App| {
        // ...
                cx.new(|_| Root {
                    status: "desktop shell scaffold".into(),
                })
        // ...
    });
}
```

Sources: [Cargo.toml:1-13](), [apps/desktop/src/main.rs:6-50]()

## Vision vs. implementation gap

```text
README roadmap                          Evidence in this snapshot
─────────────────                       ─────────────────────────
Editor API                              API: / , /health , /echo
Plugin-first architecture               Not present in supplied sources
Rust core, multi-platform               Cargo workspace: desktop only
MCP server                              Not present
Headless / batch rendering              Not present
In-editor scripting tab                 Not present
Working video editor for users today    Classic repo / opencut.app (external)
```

The monorepo’s value today is **layout and tooling**: named `web`, `api`, and `desktop` surfaces, moon/proto workflow, MIT metadata, and a GPUI desktop entry point. It is not evidence of a shared media engine, plugin host, or MCP layer—those remain stated goals, not inspected code.

Sources: [README.md:17-28](), [apps/api/src/index.ts:4-15](), [Cargo.toml:1-5](), [apps/desktop/src/main.rs:44-46]()

## Why this still matters

1. **Honest rewrite posture.** The project does not pretend the new tree is production-ready; classic stays the daily driver while architecture is designed.
2. **License and scope clarity.** MIT + multi-app layout signal an intended open, multi-surface product—even while contribution gates are closed during design.
3. **Scaffold as architecture signal.** Separate web (TanStack), API (Elysia/Cloudflare), and desktop (GPUI/Rust) targets match the “one product, many surfaces” story without yet proving a shared Rust editor core across all of them (Cargo members only list desktop).
4. **Builder takeaway.** Treat this repo as **infrastructure for a future core**, not as a drop-in CapCut/Premiere alternative. For shipping behavior today, the README itself points elsewhere (classic).

Sources: [README.md:17-28](), [README.md:51-52](), [Cargo.toml:1-10]()

## What remains unknown (from this evidence alone)

The supplied sources do not show: timeline/media engines, shared packages beyond the desktop workspace member list, mobile targets, plugin interfaces, MCP handlers, headless render paths, auth/data models, or how `web`/`api`/`desktop` will share a Rust core. Those are open design questions, not established facts here.

## Summary

OpenCut matters as an MIT-licensed, multi-platform video-editor *ambition* with a clear rewrite narrative and a classic product still serving users. In the tree captured by this evidence, it is a monorepo shell: moon-driven `web`/`api`/`desktop` apps, a minimal Cloudflare/Elysia API, a GPUI desktop window labeled as scaffold, and a Cargo workspace that currently owns only the desktop app. Read the README for product direction; read `apps/*` and `Cargo.toml` for what exists—and keep those two layers separate when reasoning about readiness or contributions.

Sources: [README.md:7-28](), [Cargo.toml:1-13](), [apps/api/src/index.ts:1-15](), [apps/desktop/src/main.rs:31-50](), [apps/web/src/router.tsx:1-13]()