The truly free, open-source, local-first, cross-platform CapCut replacement. Scriptable through a JSON-RPC API & MCP.
Rust ffmpegfree-video-editormodel-context-protocolnon-linear-editoroffline-firstopen-source-video-editorself-hostedvideo-editingvideo-editing-automationvideo-editing-softwarevideo-editing-toolsvideo-editorvoice-cloningyoutube-automationyoutube-shorts
updates
Jareer258a99dfc41e
diff --git a/.github/workflows/build.yml b/.github/workflows/build.ymlindex 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 ciworking-directory: desktop@@ -64,12 +102,54 @@ jobs:- run: npm run app:buildworking-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@v4with:name: WolfCut-${{ matrix.platform }}path: |- desktop/src-tauri/target/release/bundle/macos/*.app/**desktop/src-tauri/target/release/bundle/dmg/*.dmgdesktop/src-tauri/target/release/bundle/msi/*.msidesktop/src-tauri/target/release/bundle/nsis/*.exeif-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/**/*.exediff --git a/ARCHITECTURE.md b/ARCHITECTURE.mddeleted file mode 100644index 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["<video> element"]- AUD["<audio> + 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.mddeleted file mode 100644index 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.mdindex 8c2dde7d..dcd8f2f8 100644--- a/README.md+++ b/README.md@@ -35,7 +35,7 @@ start cutting, no account, no extra downloads, no setup.## 🚀 Get startedGrab 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:```shcd desktop@@ -43,8 +43,6 @@ npm installnpm 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/.gitignoreindex 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.rsindex 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.tomlindex 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.tomlindex 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.rsindex 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.tsxindex 36d460c9..fef462b2 100644--- a/website/src/sections/Showcase.tsx+++ b/website/src/sections/Showcase.tsx@@ -15,14 +15,6 @@ export default function Showcase() {That’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 ›- </a></div><imgsrc={screenshotDark}