# Auto-Editor: Command Line Silence Cutting for Video and Audio

> Auto-Editor is a Nim command line tool that removes dead space from video and audio by analysing loudness or motion. It is fast to run, easy to script, and deliberately not a timeline editor.

**WyattBlue/auto-editor** — Effort free video editing!

- Repository: https://github.com/WyattBlue/auto-editor
- Website: https://auto-editor.com
- Stars: 5,274 · Forks: 653
- Language: Nim
- License: Unlicense
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/wyattblue-auto-editor

## The first-pass problem Auto-Editor was built for

Anyone who records long-form talking video knows the pattern. You record forty minutes, and twelve of those minutes are the sound of a room. Cutting that out by hand is not creative work, it is clerical work, and it is the part of the job most likely to be deferred until the edit stalls. Auto-Editor targets exactly that stage. The README describes it as a command line application for automatically editing video and audio by analysing a variety of methods, most notably audio loudness, and it frames the job as a first pass: cut the dead space first, then do the real editing.

The audience is therefore narrow but real. It suits podcast and interview producers, lecture and conference recorders, streamers with long VODs, and anyone already comfortable in a terminal. It does not suit someone who wants to drag clips around a timeline. There is no GUI in the repository; the top-level entries are a Nim source tree, docs, scripts, and an example.mp4. The project also points to a hosted online runner and a downloadable application, but the README states those use assets from this repository under the Unlicense while their own unique assets are under a separate proprietary licence. The open source thing here is the CLI.

## How the cutter decides what counts as dead space

The mechanism is a labelling pass over the media timeline. The README states that every moment gets an integer label, where 0 is silent and cut by default, and 1 is active and kept. The --edit option sets what qualifies as label 1. By default the tool uses --edit audio:threshold=0.04,stream=all, so it is measuring loudness per stream and marking anything below the threshold as inactive. Swap in motion:threshold=0.02 and it marks sections where total motion is under two percent instead, which is the right choice for screen recordings and silent footage.

Labels are not limited to two. You can add more classes with --edit:N and --when:N, with N up to 255, and where labels overlap the higher number wins. That is the part worth understanding before you write a long command: the tool is not making one binary decision, it is building a stack of overlapping classifications and resolving them by precedence. The README's example uses a third label to speed up loud sections while still cutting silence. Editing methods compose too, so an (or audio:0.03 motion:0.06) expression keeps a moment if either method considers it active. Thresholds accept percentages, raw decimals, or dB values such as audio:-19dB, and the README notes the dB unit is case-sensitive.

## Installing Auto-Editor and running a first cut

The README does not list package manager commands. It says to see the Installing page at auto-editor.com/installing for more information, so treat that page as the authoritative source for your platform rather than guessing at a Homebrew, pip or apt package name.

Once the binary is on your PATH, the smallest useful invocation takes one argument. The README gives this example:

```bash
auto-editor path/to/your/video.mp4
```

Run it and the tool analyses the audio streams, cuts the sections it labels silent, and writes an output file next to the input. The default margin is 0.2s, meaning it pads each side of a cut so the result does not sound clipped. If the edit feels abrupt, widen the margin. The README shows both a symmetric and an asymmetric form:

```bash
auto-editor example.mp4 --margin 0.2sec
auto-editor example.mp4 --margin 0.3s,1.5sec
```

The second command adds 0.3 seconds before a cut and 1.5 seconds after, which is a common shape for interview footage where you want a beat of room tone before the next sentence. If you are editing silent footage, switch the detector:

```bash
auto-editor example.mp4 --edit motion:threshold=0.02
```

Before building a long command, run auto-editor --help. The README lists it under More Options as the way to list all available options, and it is the only reliable way to confirm which flags your installed version supports.

## Handing the cut to Premiere, Resolve or Final Cut Pro

Rendering a flattened file is the obvious output, but it is often the wrong one for professional work, because a flattened export throws away the original frames. Auto-Editor instead offers XML and project export. The README gives this command for Adobe Premiere Pro:

```bash
auto-editor example.mp4 --export premiere
```

The same flag takes resolve for DaVinci Resolve, final-cut-pro for Final Cut Pro, shotcut for ShotCut, kdenlive for Kdenlive, and clip-sequence for individual media clips. This is the design decision that makes the tool useful rather than a novelty. The analysis and the cutting decisions are automated, but the result lands in an editor where you can trim, colour, mix and title. The project's own documentation links to a page on actions for the full behaviour of --when and --edit, which is where the label model is spelled out further.

One consequence worth noting: because the tool is producing a cut list rather than a rendered file, the quality of your source media matters more than the quality of the tool's output. If your audio has a noisy floor, the loudness detector has less room to separate speech from silence, and you will spend more time in the NLE cleaning up than you saved.

## Where Auto-Editor gets in the way

The tool is a threshold classifier, and thresholds do not understand content. A pause for effect during a monologue is acoustically identical to a pause while someone checks their notes, and the loudness detector will cut both. Raising the threshold keeps more, lowering it cuts more, but there is no semantic layer that knows the difference. That is a real limitation, not a tuning problem.

The reverse export is the workaround the README documents. Setting --when-active cut and --when-inactive nil inverts the default behaviour, so instead of exporting the kept material you export what the tool would normally throw away:

```bash
auto-editor example.mp4 --when-active cut --when-inactive nil
```

That is useful for auditing the detector's decisions, and it is also a reminder of how the tool thinks: it is always classifying every moment, and the flags only decide which class gets discarded.

Three other constraints are visible in the repository. There is no documented rollback or undo, because the tool writes a new file rather than modifying in place; the README does not document rollback. There is no documented GUI in the repository. And the README does not document any accuracy guarantees or benchmarks, so treat the threshold values as starting points to tune per recording setup rather than as calibrated defaults. If your footage is short and heavily scripted, the time spent tuning thresholds will exceed the time spent cutting by hand.

## Auto-Editor compared with a general-purpose NLE and with FFmpeg scripting

The obvious alternative is doing the first pass manually in DaVinci Resolve or Premiere Pro, and the difference is not speed alone. In an NLE you make every cut with intent, which is why the result is better on short, dense material. Auto-Editor trades that intent for coverage: it will process a three-hour recording without fatigue, and it will do so identically every time you run it. The two are not competitors so much as stages, which is exactly why the --export resolve and --export premiere flags exist.

The other alternative is writing your own silence detection with FFmpeg's silencedetect filter and a script that assembles a cut list. That gives you total control over the detection logic and no extra dependency. What it does not give you is the label system, the multi-method composition, the margin handling, or the project-file exporters. Auto-Editor's value is in the plumbing around the detection: turning per-moment labels into a valid Premiere or Resolve project is the tedious part, and that is the part the project has already built. If you only ever need a single loudness threshold and a flattened output, a short FFmpeg script is genuinely competitive. If you need the cut to land in an editor, Auto-Editor saves you the file-format work.

## Licence, maintenance and what upgrading costs you

The repository is under the Unlicense, which places everything in it in the public domain. That is about as permissive as it gets: no attribution requirement, no copyleft obligation, no restriction on commercial use. The README adds one qualification that matters if you plan to redistribute binaries rather than build from source. It states that binary artifacts in the Releases section may be under various open source licences, so the Unlicense on the source tree does not automatically describe the executable you download. Check the licence attached to the specific artifact you ship. This is a factual note about the project's own statement, not legal advice.

Maintenance activity is visible in the release history. Versions 31.4.2, 31.5.0 and 31.6.0 were published between 2026-07-31 and 2026-09-06, and the last push to the repository was on 2026-09-19. The version numbering has reached the 31.x line, which tells you the project has been through a lot of iteration, and the README documents a --help flag as the way to enumerate options. That matters for upgrade cost: because the flag surface is broad and the label system is expressive, a version bump can change how an existing command is interpreted. Pin the version you have validated, and re-run auto-editor --help after an upgrade rather than assuming a saved command still means the same thing.

## Conclusion

Adopt Auto-Editor if your footage is long, talk-heavy, and already destined for a real NLE: the --export premiere and --export resolve paths mean you keep full editorial control after the first pass. Skip it if you need frame-accurate creative cutting, colour, or titles, because it is a cutter, not an editor. Before committing, run auto-editor --help on your own build to confirm the --edit and --when flags your version ships with, and check the LICENSE file at the repository root, since the README states binary artifacts in the Releases section may carry different open source licences than the Unlicense source.

## FAQ

### How do I install Auto-Editor?

The README does not list install commands. It points to the Installing page at auto-editor.com/installing for more information, so that page is the place to get platform-specific steps.

### How do I use Auto-Editor on a video?

Run auto-editor followed by the path to your file, for example auto-editor path/to/your/video.mp4. It analyses the audio by default and cuts the sections it labels silent, using a 0.2s margin.

### How do I install Auto-Editor on my machine?

The README does not give install steps and directs readers to auto-editor.com/installing. It also notes that a hosted online runner and a downloadable application exist, but those use their own assets under a separate proprietary licence.

### What is Auto-Editor?

It is a command line application for automatically editing video and audio by analysing methods such as audio loudness, primarily to cut out dead space like silence as a first pass before real editing.

## Sources

- [License: Unlicense](https://github.com/WyattBlue/auto-editor/blob/master/LICENSE)
- [Project website](https://auto-editor.com)
- [README](https://github.com/WyattBlue/auto-editor/blob/master/README.md)
- [Releases](https://github.com/WyattBlue/auto-editor/releases)
- [WyattBlue/auto-editor on GitHub](https://github.com/WyattBlue/auto-editor)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/wyattblue-auto-editor