Skip to content

The truly free, open-source, local-first, cross-platform CapCut replacement. Scriptable through a JSON-RPC API & MCP.

updates

Jareer258a99dfc41e
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 844460cc..baf04640 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,15 +1,20 @@
name: Build App
-# Compiles the WolfCut desktop app for macOS and Windows and uploads the
-# bundles as artifacts. Runs on pushes to main and on demand.
+# Compiles the WolfCut desktop app for macOS and Windows.
#
-# The bundled FFmpeg (desktop/src-tauri/ffmpeg/) is not staged here - these
-# builds fall back to FFmpeg on PATH at runtime, which is the dev behaviour.
-# Drop platform binaries into that directory before building to ship them.
+# Every build stages the static FFmpeg pair into desktop/src-tauri/ffmpeg/
+# first - the release guard in build.rs refuses to build without it, because a
+# packaged app without its FFmpeg ships broken (no PATH fallback from Finder).
+#
+# - Pushes to main and manual runs: build and upload the bundles as artifacts.
+# - Tags starting with v (v0.1.0-alpha.1, v0.2.0, ...): additionally publish
+# the installers to a GitHub release. Tags containing a hyphen are marked as
+# pre-releases.
on:
workflow_dispatch:
push:
branches: [main]
+ tags: ["v*"]
concurrency:
group: build-${{ github.ref }}
@@ -54,6 +59,39 @@ jobs:
with:
workspaces: desktop/src-tauri
+ # Static builds, so the pair runs on machines with nothing installed.
+ # macos-latest is Apple Silicon, hence the arm64 build.
+ - name: Stage bundled FFmpeg (macOS)
+ if: matrix.platform == 'macos'
+ run: |
+ set -euo pipefail
+ mkdir -p desktop/src-tauri/ffmpeg ffdl
+ curl -fsSL --retry 5 --retry-all-errors -o ffdl/ffmpeg.zip \
+ "https://ffmpeg.martin-riedl.de/redirect/latest/macos/arm64/release/ffmpeg.zip"
+ curl -fsSL --retry 5 --retry-all-errors -o ffdl/ffprobe.zip \
+ "https://ffmpeg.martin-riedl.de/redirect/latest/macos/arm64/release/ffprobe.zip"
+ unzip -o ffdl/ffmpeg.zip -d ffdl/ffmpeg-out
+ unzip -o ffdl/ffprobe.zip -d ffdl/ffprobe-out
+ mv "$(find ffdl/ffmpeg-out -type f -name ffmpeg | head -1)" desktop/src-tauri/ffmpeg/ffmpeg
+ mv "$(find ffdl/ffprobe-out -type f -name ffprobe | head -1)" desktop/src-tauri/ffmpeg/ffprobe
+ chmod +x desktop/src-tauri/ffmpeg/ffmpeg desktop/src-tauri/ffmpeg/ffprobe
+ desktop/src-tauri/ffmpeg/ffmpeg -version | head -1
+ desktop/src-tauri/ffmpeg/ffprobe -version | head -1
+
+ - name: Stage bundled FFmpeg (Windows)
+ if: matrix.platform == 'windows'
+ shell: pwsh
+ run: |
+ $ErrorActionPreference = "Stop"
+ New-Item -ItemType Directory -Force desktop/src-tauri/ffmpeg | Out-Null
+ curl.exe -fsSL --retry 5 --retry-all-errors -o ffmpeg-win.zip `
+ "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n8.1-latest-win64-gpl-8.1.zip"
+ Expand-Archive ffmpeg-win.zip -DestinationPath ffdl
+ Copy-Item (Get-ChildItem ffdl -Recurse -Filter ffmpeg.exe | Select-Object -First 1).FullName desktop/src-tauri/ffmpeg/
+ Copy-Item (Get-ChildItem ffdl -Recurse -Filter ffprobe.exe | Select-Object -First 1).FullName desktop/src-tauri/ffmpeg/
+ & desktop/src-tauri/ffmpeg/ffmpeg.exe -version | Select-Object -First 1
+ & desktop/src-tauri/ffmpeg/ffprobe.exe -version | Select-Object -First 1
+
- run: npm ci
working-directory: desktop
@@ -64,12 +102,54 @@ jobs:
- run: npm run app:build
working-directory: desktop
+ # The runtime looks for the pair in the app's resource directory; a
+ # bundle that lost them (or their execute bit) would ship broken while
+ # this workflow reports green.
+ - name: Verify FFmpeg made it into the bundle (macOS)
+ if: matrix.platform == 'macos'
+ run: |
+ set -euo pipefail
+ app="$(find desktop/src-tauri/target/release/bundle/macos -maxdepth 1 -name '*.app' | head -1)"
+ test -n "$app" || { echo "no .app produced"; exit 1; }
+ for binary in ffmpeg ffprobe; do
+ staged="$app/Contents/Resources/ffmpeg/$binary"
+ test -x "$staged" || { echo "$staged missing or not executable"; exit 1; }
+ "$staged" -version | head -1
+ done
+
- uses: actions/upload-artifact@v4
with:
name: WolfCut-${{ matrix.platform }}
path: |
- desktop/src-tauri/target/release/bundle/macos/*.app/**
desktop/src-tauri/target/release/bundle/dmg/*.dmg
desktop/src-tauri/target/release/bundle/msi/*.msi
desktop/src-tauri/target/release/bundle/nsis/*.exe
if-no-files-found: error
+
+ release:
+ name: Publish release
+ if: startsWith(github.ref, 'refs/tags/v')
+ needs: [engine-tests, app]
+ runs-on: ubuntu-latest
+ permissions:
+ contents: write
+ steps:
+ - uses: actions/download-artifact@v4
+ with:
+ path: bundles
+ merge-multiple: true
+
+ - name: List what is being published
+ run: find bundles -type f | sort
+
+ - uses: softprops/action-gh-release@v2
+ with:
+ name: WolfCut ${{ github.ref_name }}
+ # A hyphen in the tag (v0.1.0-alpha.1) marks a pre-release.
+ prerelease: ${{ contains(github.ref_name, '-') }}
+ generate_release_notes: true
+ fail_on_unmatched_files: true
+ files: |
+ bundles/**/*.dmg
+ bundles/**/*.msi
+ bundles/**/*.exe
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
deleted file mode 100644
index 63adb87a..00000000
--- a/ARCHITECTURE.md
+++ /dev/null
@@ -1,265 +0,0 @@
-# How WolfCut works
-
-A map of the whole system. For *why* particular choices were made, see the
-decision logs in `engine/docs/decisions/` and `desktop/docs/decisions/`.
-
-## The two halves
-
-```mermaid
-graph TB
- subgraph desktop["desktop/ — the editor"]
- UI["React UI<br/>(runs in WebView2)"]
- HOST["Tauri host<br/>relay-desktop.exe"]
- end
-
- subgraph engine["engine/ — the video engine"]
- CORE["relay-core<br/>time · arena · frames · timeline"]
- MEDIA["relay-media<br/>decode · encode · probe"]
- RENDER["relay-render<br/>plan · composite"]
- CLI["relay-cli<br/>headless driver"]
- end
-
- FF["ffmpeg / ffprobe<br/>(child processes)"]
-
- UI -->|"invoke() — JSON"| HOST
- HOST -.->|"events"| UI
- HOST -->|"plain function calls"| MEDIA
- HOST --> RENDER
- MEDIA --> CORE
- RENDER --> CORE
- CLI --> MEDIA
- CLI --> RENDER
- MEDIA -->|spawn| FF
- HOST -->|spawn| FF
-```
-
-The engine has **no idea a UI exists**. It builds, tests and versions on its
-own, `relay-cli` drives the identical code from a terminal, and every engine
-test runs headless. That is why `desktop/` depends on `engine/` by path and
-never the reverse.
-
-`relay-core` has **zero dependencies** — std only. It is the vocabulary
-everything else speaks, so a dependency there is a dependency everywhere.
-
-## The bridge
-
-There is no IPC between the host and the engine — they are one process, and
-calls are ordinary Rust. The only boundary is between the webview and the host,
-and it carries four different kinds of traffic for four different reasons.
-
-```mermaid
-graph LR
- UI["React"]
- HOST["Rust host"]
- DISK[("files on disk")]
-
- UI -->|"1. invoke — JSON commands"| HOST
- HOST -->|"2. events — export progress"| UI
- HOST -->|"3. ipc::Response — raw ArrayBuffer"| UI
- DISK -->|"4. asset:// — straight to video/audio/img"| UI
-```
-
-1. **Commands** — `probe_media`, `export_project`, `save_project`… Every one
- goes through `src/lib/engine.ts`; nothing else in the app calls `invoke`, so
- a signature change has exactly one place to fix.
-2. **Events** — export runs on a blocking thread and emits `export://progress`.
- A two-minute render that says nothing is indistinguishable from a hang.
-3. **Raw bytes** — filmstrips, audio, filtered renders. A few megabytes as a
- JSON array of numbers would be unusable.
-4. **The asset protocol** — media files load straight into `<video>`/`<audio>`
- without touching Rust. Preview playback is not bottlenecked on the bridge.
-
-## Two paths through everything
-
-This is the single most important thing to understand. **Preview and export are
-different code paths**, and they are allowed to be — but only where they
-cannot disagree about the *result*.
-
-```mermaid
-graph TB
- MODEL["The edit<br/>lib/project.ts"]
-
- subgraph preview["Preview — must be instant"]
- VID["&lt;video&gt; element"]
- AUD["&lt;audio&gt; + GainNode"]
- end
-
- subgraph export["Export — must be correct"]
- PLAN["relay-render::plan_frame"]
- COMP["CpuCompositor"]
- MIX["ffmpeg filter_complex"]
- end
-
- MODEL --> VID
- MODEL --> AUD
- MODEL --> PLAN
- PLAN --> COMP
- MODEL --> MIX
-```
-
-| | Preview | Export |
-|---|---|---|
-| Picture | one `<video>`, top clip only | full multi-track composite |
-| Sound | media elements + gain nodes | ffmpeg `filter_complex` mix |
-| Compositing | **none** | real |
-| Clock | browser `requestAnimationFrame` | frame counter |
-
-The preview deliberately cannot composite. Two stacked clips show only the
-upper one. That is a known limit, not a bug — see
-`desktop/docs/decisions/0004`.
-
-**Where they must agree, there is only one source of truth.** Clip gain, fades,
-speed and filters are *numbers on the clip*, and both paths read the same
-numbers. Audio filters go further: `lib/filters.ts` produces one FFmpeg filter
-string, and the preview plays a render produced by that exact string. There is
-no second implementation to drift.
-
-## FFmpeg, in five places
-
-```mermaid
-graph LR
- P["probe_media"] -->|ffprobe| A["stream info"]
- F["extract_filmstrip"] -->|ffmpeg| B["clip thumbnails"]
- R["render_filtered_audio"] -->|ffmpeg| C["filtered preview audio"]
- E["export — picture"] -->|"relay-media pipe"| D["composited frames"]
- M["export — sound"] -->|"ffmpeg filter_complex"| G["mixed track"]
-```
-
-All five spawn FFmpeg as a **child process** rather than linking it. The
-reasoning, its real costs, and the exit criteria are in
-`engine/docs/decisions/0002-ffmpeg-over-a-pipe.md`.
-
-Short version: a pipe carries no presentation timestamps and cannot seek to an
-exact frame. Those are correctness limits, not performance ones, and they are
-why a linked decoder exists —
-
-### The FFI decoder (built, tested, **not yet used**)
-
-`relay-media`'s optional `ffi` feature builds `FfiDecoder`, which links
-libav\* directly and provides the two things the pipe cannot:
-
-- `position()` — the real presentation timestamp, as an exact rational
-- `seek()` — frame-accurate, via keyframe-seek plus decode-forward
-
-It is off by default and nothing in the app enables it. It exists so that
-playback can be rewritten onto it; until then the subprocess path is what runs.
-
-The seam that made this cheap: `FrameSource` is the trait both implement, and
-`SeekableSource` is deliberately *separate* so the pipe cannot pretend to offer
-seeking it does not have.
-
-## The edit model
-
-```mermaid
-graph TB
- PROJ["Project"]
- MED["MediaItem[]<br/>path · kind · duration"]
- TRK["Track[]<br/>name · visible · muted"]
- CLIP["Clip[]<br/>start · duration · sourceStart<br/>volume · fades · speed · filters"]
-
- PROJ --> MED
- PROJ --> TRK
- PROJ --> CLIP
- CLIP -->|mediaId| MED
- CLIP -->|trackId| TRK
-```
-
-Tracks are **untyped** — any media on any lane. A clip knows what it is; a
-track does not need to. Track order is bottom-first, matching the engine's
-compositing order, and the timeline draws it reversed.
-
-Every operation is a pure function `(project, args) => project`. That is the
-shape a command sent to the engine will have, so the call sites survive the
-migration when the engine takes ownership of the model.
-
-**This model is provisional.** `relay-core` already has a better version of
-these types — exact rational time, generational arena handles. The UI holds it
-only because the engine has no project *API* yet.
-
-## Time
-
-The engine works in **exact rationals**, never floats:
-
-```
-29.97 fps → Rational(30000, 1001) not 29.97
-frame 1800 → Rational(60060, 1000) exactly 60.06s
-```
-
-An `f64` accumulator drifts — add `1/29.97` for an hour and you are visibly
-off. `relay-core::time` is tested against exactly this: 107,892 accumulated
-frame durations still land on the right frame.
-
-The UI works in `f64` seconds, which is a real downgrade, and is acceptable
-only because nothing there is authoritative. **The conversion happens at the
-Rust boundary**, where `export.rs` quantises every value onto the frame grid.
-
-## Rendering the timeline
-
-The timeline is one `<canvas>` with a single `requestAnimationFrame` loop.
-A real edit is thousands of clips and keyframes; as DOM nodes that is thousands
-of elements restyled on every scrub, and layout — not React — is the wall.
-
-```mermaid
-graph LR
- RAF["rAF loop"] --> READ["read view ref"]
- READ --> LANES["lanes"] --> RULER["ruler"] --> CLIPS["clips + artwork"] --> PLAY["playhead"]
-```
-
-The loop reads props through a ref, so a prop change never tears it down. Clip
-artwork — waveforms and filmstrips — lives in a plain `Map` that the loop reads
-directly, so artwork arriving costs **no React render**.
-
-Canvas cannot resolve `var(--color-x)`, so the palette is copied out of the
-stylesheet whenever the theme changes.
-
-## Persistence
-
-```mermaid
-graph LR
- A["Project (memory)"] -->|"save_project"| B["relay.json"]
- B -->|"load_project"| A
- C["recents.json<br/>(app config dir)"] --- D["launch screen"]
- E["peaks · filmstrips · renders"] -.->|"regenerable"| F["cache"]
-```
-
-- **`relay.json`** lives in the project folder and holds the whole edit. Written
- to a temp file and renamed into place, because a half-written save is worse
- than no save.
-- **`recents.json`** lives in the *app config* directory, not in any project —
- copying a project to another machine should not drag your history along.
-- **Caches** are derived data and belong nowhere near either.
-
-## Layout of the repository
-
-```
-engine/
- crates/relay-core time, arena, frames, timeline model (no deps)
- crates/relay-media probe, decode, encode, optional FFI
- crates/relay-render frame plan, CPU compositor
- crates/relay-cli headless driver
- docs/decisions/ why the engine is the way it is
-
-desktop/
- src/App.tsx shell, window state, keyboard map
- src/components/ panels, timeline canvas, chrome
- src/lib/engine.ts the ONLY file that calls invoke()
- src/lib/project.ts the provisional edit model
- src/lib/filters.ts filter catalogue → ffmpeg strings
- src/lib/audio.ts preview playback and gain
- src-tauri/src/ commands, export pipeline, project files
- docs/decisions/ why the app is the way it is
-
-vendor/ FFmpeg dev build for the FFI feature (gitignored)
-BUILD.md how to build it
-```
-
-## Rules worth keeping
-
-1. **`lib/engine.ts` is the only file that calls `invoke`.**
-2. **The engine never learns about the UI.** If a command starts making
- decisions about the edit, that logic belongs in `relay-core`.
-3. **No time arithmetic in TypeScript.** `lib/time.ts` formats; it does not
- compute.
-4. **The timeline is not DOM.**
-5. **One source of truth per behaviour.** Where preview and export must agree,
- they read the same numbers or run the same string.
diff --git a/BUILD.md b/BUILD.md
deleted file mode 100644
index 02bf80dc..00000000
--- a/BUILD.md
+++ /dev/null
@@ -1,184 +0,0 @@
-# Building WolfCut
-
-Two independent pieces:
-
-- **`engine/`** — the Rust video engine. Builds and tests on its own, with no UI
- and no Node involved.
-- **`desktop/`** — the Tauri + React editor. Depends on the engine by path.
-
-You can work on the engine without ever touching the desktop app.
-
-## What you need
-
-| | Version | Why | Check |
-|---|---|---|---|
-| **Rust** | 1.93 | Pinned by `engine/rust-toolchain.toml`; rustup installs it automatically | `rustc --version` |
-| **Node** | 22+ | Vite 7 and the Tauri CLI | `node --version` |
-| **FFmpeg** | 7+ | Runtime dependency — the engine shells out to it | `ffmpeg -version` |
-| **MSVC Build Tools** | 2022 | Windows only; Rust's default toolchain links with it | — |
-
-For **development**, FFmpeg must be on `PATH` as both `ffmpeg` **and**
-`ffprobe`. Without it the app starts fine and then fails on first import with
-"could not run `ffprobe` - is FFmpeg installed and on PATH?".
-
-**Packaged builds ship their own FFmpeg** and never touch `PATH` - a `.app`
-launched from Finder does not see a shell's `PATH` at all, so relying on it
-there is a guaranteed failure. Stage the pair in `desktop/src-tauri/ffmpeg/`
-before `npm run app:build`: on Windows, download the artifact from
-`.github/workflows/ffmpeg.yml`; on macOS, build the same cut-down FFmpeg
-locally with that workflow's configure line (static x264, system frameworks
-only - verify with `otool -L`). A release build **fails** if the pair is not
-staged - `src-tauri/build.rs` checks, because an app once shipped without it
-and every media operation failed at runtime.
-
-Two lessons that trimmed build has already taught, encoded in the code and
-the `export_integration` test: modern FFmpeg resolves a bare `-` to the `fd:`
-protocol, which the trimmed build does not include, so every pipe is spelled
-`pipe:0`/`pipe:1`; and any filter used anywhere in the app must be in the
-build's `--enable-filter` list, which the integration test is there to catch.
-
-```
-winget install Gyan.FFmpeg # Windows
-brew install ffmpeg # macOS
-sudo apt install ffmpeg # Debian/Ubuntu
-```
-
-## Engine
-
-```sh
-cd engine
-cargo test --workspace # pure tests; none need FFmpeg
-cargo test --workspace --features relay-render/gpu # adds the wgpu compositor
-cargo clippy --workspace --all-targets
-cargo run -p relay-cli -- probe some-video.mp4
-cargo run -p relay-cli -- render in.mp4 out.mp4 --frames 120 --fade 30
-```
-
-The tests are pure — they exercise the timeline model, rational time and the
-compositor, and pass on a machine with no FFmpeg at all. The CLI is how you
-exercise the parts that do need it.
-
-The `gpu` feature of `relay-render` builds `WgpuCompositor`, a second
-implementation of the same `Compositor` trait. The desktop app enables it and
-uses it for export when the machine has an adapter, with `CpuCompositor` as
-the always-correct fallback and reference (its tests diff the two). The
-feature is off by default so engine-only work never pays for the wgpu tree.
-
-There is also an end-to-end suite that runs a real export — decoders,
-compositor, encoder, audio graph, mux — against the **bundled** FFmpeg pair
-when it is staged, so a component missing from the trimmed build fails in CI
-rather than in a user's export:
-
-```sh
-cd desktop/src-tauri
-cargo test --test export_integration # needs a system ffmpeg for fixtures
-```
-
-## Desktop app
-
-```sh
-cd desktop
-npm install
-npm run app # dev: builds the Rust host, opens the window, HMR for the UI
-npm run typecheck # tsc --noEmit
-npm run build # UI only, into dist/
-npm run app:build # production installers
-```
-
-**First `npm run app` takes several minutes** — it compiles ~360 Rust crates.
-After that only your own crates rebuild, so it is seconds. Editing anything
-under `src/` hot-reloads without a Rust rebuild at all.
-
-`npm run app:build` produces, under `desktop/src-tauri/target/release/`:
-
-```
-relay-desktop.exe standalone, no install needed
-bundle/nsis/WolfCut_0.1.0_x64-setup.exe installer
-bundle/msi/WolfCut_0.1.0_x64_en-US.msi installer
-```
-
-Release builds use `lto = true` and `codegen-units = 1`, so expect them to be
-several times slower than dev. That is deliberate; the final link is
-single-threaded and is most of the wait.
-
-## `vendor/` — not required
-
-Holds an FFmpeg **development** build (headers and import libraries), used only
-by the in-progress FFI decoder described below. It is gitignored, roughly
-150 MB, and nothing in the normal build path touches it. Delete it freely.
-
-## FFI decoder — optional, off by default
-
-The engine talks to FFmpeg as a subprocess
-(`engine/docs/decisions/0002-ffmpeg-over-a-pipe.md`). That is permanent for
-probing and export. Playback is different: a pipe carries no presentation
-timestamps and cannot seek to an exact frame, so there is a second decoder that
-links FFmpeg directly, behind the `ffi` feature.
-
-Nothing in the app enables it yet. **You do not need any of this to build or
-run WolfCut.**
-
-### Setup, exactly as verified
-
-1. **Get a development build** — headers plus `.lib` import libraries, which
- the ordinary runtime download does not include. From
- [BtbN/FFmpeg-Builds](https://github.com/BtbN/FFmpeg-Builds/releases), take a
- `win64-gpl-**shared**` archive and unpack it into `vendor/`:
-
- ```sh
- curl -L -o ff.zip https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-n8.1-latest-win64-gpl-shared-8.1.zip
- unzip ff.zip -d vendor/
- ```
-
- **The version has to match the bindings.** `rusty_ffmpeg` ships
- pre-generated bindings for a specific FFmpeg, currently 8.1 — avcodec 62,
- avformat 62, avutil 60. A different major version compiles fine and then
- misreads struct layouts at runtime, which corrupts silently rather than
- failing. `ffi::tests::links_against_the_expected_ffmpeg` checks this and is
- the first thing to look at if the decoder behaves strangely.
-
-2. **Nothing else.** No LLVM, no libclang, no bindgen run — the pre-generated
- bindings are used as-is. `engine/.cargo/config.toml` already points at
- `vendor/`, so no environment variables to set either.
-
- If you unpack a differently-named archive, update the paths in that file.
-
-3. **Build and test:**
-
- ```sh
- cd engine
- PATH="../vendor/ffmpeg-n8.1-latest-win64-gpl-shared-8.1/bin:$PATH" \
- cargo test -p relay-media --features ffi
- ```
-
- The DLLs must be on `PATH` at *run* time. Linking uses `lib/` (import
- libraries); running needs `bin/` (the DLLs themselves). Pointing either at
- the other is the most likely thing to go wrong — `LNK1181: cannot open input
- file 'avcodec.lib'` means the linker was aimed at `bin/`.
-
-### What it provides
-
-`FfiDecoder` implements `FrameSource` plus `SeekableSource`:
-
-- **`position()`** — the real presentation timestamp, as an exact rational. The
- subprocess decoder returns `None` here, honestly: raw video carries no
- timestamps, which is why variable-frame-rate material desyncs through a pipe.
-- **`seek()`** — frame-accurate, by seeking to the preceding keyframe and
- decoding forward. Deliberately a separate trait, so the subprocess decoder
- cannot pretend to offer it.
-
-`tests/ffi_decode.rs` proves both against a generated fixture, and skips
-entirely if FFmpeg is not installed.
-
-## Troubleshooting
-
-**"could not run `ffprobe`"** — FFmpeg is not on `PATH`. Restart the terminal
-after installing; a running shell keeps its old `PATH`.
-
-**Rust rebuilds everything on each `npm run app`** — something is changing
-`engine/`'s files. The desktop app depends on the engine by path, so a touched
-engine file invalidates the host too.
-
-**The window opens white** — the Vite dev server did not start. Check that port
-1420 is free; Tauri is configured with `strictPort`, so it will not silently
-pick another.
diff --git a/README.md b/README.md
index 8c2dde7d..dcd8f2f8 100644
--- a/README.md
+++ b/README.md
@@ -35,7 +35,7 @@ start cutting, no account, no extra downloads, no setup.
## 🚀 Get started
Grab a build from [Releases](https://github.com/jub0t/WolfCut/releases), or
-build it yourself — [BUILD.md](BUILD.md) has everything, and it boils down to:
+build it yourself:
```sh
cd desktop
@@ -43,8 +43,6 @@ npm install
npm run app
```
-Curious how it works inside? [ARCHITECTURE.md](ARCHITECTURE.md) is the tour.
-
## 📈 Growth
<a href="https://star-history.com/#jub0t/WolfCut&Date">
diff --git a/desktop/src-tauri/.gitignore b/desktop/src-tauri/.gitignore
index b21bd681..a330a67f 100644
--- a/desktop/src-tauri/.gitignore
+++ b/desktop/src-tauri/.gitignore
@@ -5,3 +5,6 @@
# Generated by Tauri
# will have schema files for capabilities auto-completion
/gen/schemas
+
+# Staged FFmpeg pair for bundled builds (downloaded in CI, ~100 MB)
+/ffmpeg/
diff --git a/desktop/src-tauri/build.rs b/desktop/src-tauri/build.rs
index 5967c2c6..5196c696 100644
--- a/desktop/src-tauri/build.rs
+++ b/desktop/src-tauri/build.rs
@@ -3,7 +3,7 @@ fn main() {
// without its FFmpeg pair has happened once already: everything media-
// shaped failed at runtime, launched from Finder with no PATH to fall
// back on. Fail the build instead - staging the binaries is part of
- // building for release (see BUILD.md).
+ // building for release.
if std::env::var("PROFILE").as_deref() == Ok("release") {
let suffix = if cfg!(target_os = "windows") { ".exe" } else { "" };
let staged = std::path::Path::new("ffmpeg");
@@ -12,8 +12,7 @@ fn main() {
assert!(
path.is_file(),
"release build without a bundled {binary}: stage the FFmpeg pair in \
- desktop/src-tauri/ffmpeg/ first (see BUILD.md), or the packaged app \
- will ship broken"
+ desktop/src-tauri/ffmpeg/ first, or the packaged app will ship broken"
);
}
println!("cargo:rerun-if-changed=ffmpeg");
diff --git a/engine/.cargo/config.toml b/engine/.cargo/config.toml
index f725608a..6ddf9d14 100644
--- a/engine/.cargo/config.toml
+++ b/engine/.cargo/config.toml
@@ -5,13 +5,13 @@
# them here is harmless even on a machine with no `vendor/` directory.
#
# `relative = true` resolves against this file's parent, so the paths follow
-# the repository rather than whoever checked it out. See BUILD.md.
+# the repository rather than whoever checked it out.
[env]
# Note the deliberate absence of FFMPEG_DLL_PATH. rusty_ffmpeg turns that one
# into the linker's /LIBPATH, which sends it hunting for `avcodec.lib` in
# `bin/` - where only the DLLs live. The import libraries are in `lib/`, so
# FFMPEG_LIBS_DIR is the one that matters at link time.
#
-# The DLLs still have to be findable at *run* time; see BUILD.md.
+# The DLLs still have to be findable at *run* time.
FFMPEG_INCLUDE_DIR = { value = "../vendor/ffmpeg-n8.1-latest-win64-gpl-shared-8.1/include", relative = true }
FFMPEG_LIBS_DIR = { value = "../vendor/ffmpeg-n8.1-latest-win64-gpl-shared-8.1/lib", relative = true }
diff --git a/engine/crates/relay-media/Cargo.toml b/engine/crates/relay-media/Cargo.toml
index 3d808b00..de873a88 100644
--- a/engine/crates/relay-media/Cargo.toml
+++ b/engine/crates/relay-media/Cargo.toml
@@ -21,5 +21,5 @@ workspace = true
# `ffmpeg` on PATH, while this one needs a development build with headers and
# import libraries. Building the engine must not require that.
#
-# See BUILD.md and docs/decisions/0002-ffmpeg-over-a-pipe.md.
+# See docs/decisions/0002-ffmpeg-over-a-pipe.md.
ffi = ["dep:rusty_ffmpeg"]
diff --git a/engine/crates/relay-media/src/ffi.rs b/engine/crates/relay-media/src/ffi.rs
index fedd13d8..c282c218 100644
--- a/engine/crates/relay-media/src/ffi.rs
+++ b/engine/crates/relay-media/src/ffi.rs
@@ -6,7 +6,7 @@
//! export, which is why the subprocess backend is not going anywhere.
//!
//! Only compiled with the `ffi` feature. See
-//! `docs/decisions/0002-ffmpeg-over-a-pipe.md` and BUILD.md.
+//! `docs/decisions/0002-ffmpeg-over-a-pipe.md`.
//!
//! ## On the unsafe in here
//!
@@ -478,7 +478,7 @@ mod tests {
// major version means the struct layouts we compiled against do not
// match the library that loaded - which corrupts silently rather than
// failing, so it is worth an explicit check.
- assert_eq!(avcodec_major(), 62, "linked libavcodec mismatch - see BUILD.md");
+ assert_eq!(avcodec_major(), 62, "linked libavcodec mismatch");
}
#[test]
diff --git a/website/src/sections/Showcase.tsx b/website/src/sections/Showcase.tsx
index 36d460c9..fef462b2 100644
--- a/website/src/sections/Showcase.tsx
+++ b/website/src/sections/Showcase.tsx
@@ -15,14 +15,6 @@ export default function Showcase() {
That&rsquo;s why WolfCut stays a few megabytes, opens instantly,
and scrubs smoothly where web-based editors stutter.
</p>
- <a
- href="https://github.com/jub0t/WolfCut/blob/main/ARCHITECTURE.md"
- target="_blank"
- rel="noreferrer"
- className="mt-6 inline-block text-sm text-accent hover:underline"
- >
- Read the architecture &rsaquo;
- </a>
</div>
<img
src={screenshotDark}