# lazycut: trimming video from the terminal with in and out points

> lazycut is a Go terminal application that renders a preview of your video, lets you mark in and out points by keyboard, and exports the trimmed result with FFmpeg. It suits people who cut short clips from long recordings and want to stay inside a terminal, but it is deliberately narrow and depends on external tools.

**ozemin/lazycut** — A simple terminal UI for video trimming

- Repository: https://github.com/ozemin/lazycut
- Stars: 881 · Forks: 30
- Language: Go
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/ozemin-lazycut

## The narrow job lazycut takes on: cutting one clip out of one file

The README describes lazycut as a terminal-based video trimming tool that marks in and out points and exports trimmed clips with aspect ratio control. That is the whole scope. It is not an editor with a project timeline, no effects, no transitions, no multi-file composition. One input file goes in, one or more trimmed sections come out.

The audience is people who already know how a video file should be cut but do not want to open a timeline application for a two-second clip. Someone pulling a highlight from a long screen recording fits. Someone converting a wide desktop capture into a vertical clip for a phone fits, because the README lists 9:16 among the supported output ratios. Someone assembling a short film does not.

The interface decision is the interesting one. Instead of a scrubber timeline, lazycut renders a preview of the video inside the terminal and binds every action to a single key. The README's shortcut table includes frame-level stepping with the comma and period keys, and it notes that Vim-style repeat counts work, so 5l seeks five seconds forward and 10. steps ten frames. That makes fast scrubbing possible without a mouse, which is the case a mouse-driven editor handles badly inside a terminal window anyway.

## How the pieces fit: Cobra commands, a Bubble Tea interface, FFmpeg underneath

The dependency list in go.mod gives a fairly clear picture of the architecture. The application uses spf13/cobra v1.10.2 for the command line, so the subcommands you see in the usage examples are real cobra commands rather than hand-parsed flags. The interactive screen is built on charmbracelet/bubbletea v1.3.10, with charmbracelet/lipgloss v1.1.0 for layout and styling and muesli/termenv v0.16.0 for terminal capability and colour detection. The go.mod file requires Go 1.26.

The repository layout matches that split. There is a cmd/ directory for the cobra command definitions, a ui/ directory for the Bubble Tea model and its views, and a video/ directory that holds the media handling. The top-level main.go and the module path github.com/ozemin/lazycut sit above those.

Two external programs do the actual work. FFmpeg performs decoding, frame extraction and encoding, and Chafa renders image frames so they can be shown as text and colour inside the terminal. The README lists both as requirements and the install section asks for the ffmpeg and chafa development packages when building from source, which means the preview path shells out to Chafa rather than decoding pixels in Go itself. That is why a terminal with limited colour support still shows something usable rather than failing outright.

## Installing lazycut and making a first trim

On macOS the README gives a Homebrew formula as the short path:

```bash
brew install lazycut
```

That installs the binary only. FFmpeg and Chafa still have to be present on your system, because lazycut calls out to both at runtime.

Building from source needs the latest Go, plus ffmpeg and the chafa development packages. On Fedora the README installs the Chafa library alongside the runtime:

```sh
sudo dnf install -y ffmpeg chafa chafa-devel
```

With the prerequisites in place, the README builds and runs the tool like this:

```bash
go install github.com/ozemin/lazycut@latest 
./lazycut video.mp4
```

The first argument is always the input file. Running it with no flags opens the interactive screen; the other subcommands in the README are for scripted use, and the frame rate flag controls how often the preview refreshes:

```bash
lazycut video.mp4              # interactive TUI
lazycut video.mp4 --fps 12     # custom preview frame rate
lazycut trim --in 00:01:00 --out 00:02:00 -o out.mp4 video.mp4
lazycut probe video.mp4
```

A sensible first session is to run the interactive form on a file you already know, mark one in point with i and one out point with o, press Enter to export, and then confirm the result with the probe subcommand. The trim subcommand is the one to reach for when the cut points are already known from a previous session, which is the fastest path for repeated work on the same file.

## Marking sections and undoing mistakes inside the preview

The shortcut table is more than a list of convenience keys. Seeking comes in three granularities: h and l move one second, H and L and the left and right arrows move five seconds, and the up and down arrows jump a full minute. The comma and period keys move a single frame, which is what you need when a cut has to land on an exact frame boundary. Zero jumps to the start and G or the dollar sign jumps to the end.

Selection is managed with i and o for the in and out points, X to remove the last section, and d or Escape to clear the selection. The preview keys p and P show all sections or just the last one. Undo is bound to u, mute toggles with m, and the help overlay is on the question mark.

The existence of an undo key and a remove-section key says something about the editing model. A trim is a list of sections rather than a single range, and the README states that multiple sections per video can be exported separately or concatenated. Sections are additive: you mark an in and an out, then another pair, and the export step decides whether to write them as separate files or join them. The trade-off is that the interface gives you no way to move a boundary once it is set except by removing and re-adding the section, which is where undo earns its single key.

## Export behaviour and the aspect ratio conversions it supports

Export is where the actual encoding work happens, and the README keeps the description short. It supports multiple sections per video, separate or concatenated export, and aspect ratio conversion into 16:9, 9:16, 1:1 and 4:5. Those four ratios cover the common delivery targets: widescreen, vertical phone video, square feed posts and the slightly taller 4:5 used by some social platforms.

Nothing in the README documents a codec choice, a bitrate flag, a quality setting or a scaling policy. That is a real limit on what you can predict. If you need a specific CRF value, a fixed bitrate, a particular audio codec or a burn-in of some kind, the documented surface does not offer it. The pragmatic read is that lazycut hands the re-encode to FFmpeg with the timing and the target ratio, and leaves the rest to FFmpeg defaults.

The same applies to audio. Mute toggles during preview with m, but the README does not say whether the export preserves the original audio stream, re-encodes it, or drops it when a section boundary does not align with an audio packet. If the audio matters, check the first exported file before trusting a batch run.

## Where lazycut is the wrong tool

The most obvious limit is that lazycut handles exactly one source file per invocation. The README documents no scene list, no second input and no compositing, so a project that pulls three camera angles into one sequence is out of scope by design rather than by omission.

Second, the preview is rendered through Chafa into text and colour blocks. On a terminal with a small window or a limited colour palette, the picture you scrub against is an approximation of the frame, not the frame itself. Judging colour accuracy, gradients or subtle motion from that preview is unreliable, so a clip that depends on visual detail may need a check in a real player after export.

Third, the project is young and moving quickly. The release list shows v0.3.8 and v0.3.9 both published on 2026-03-26, then v0.4.0 on 2026-09-18, and the last push to the repository was on 2026-09-18. Several releases in a single day suggest an active release cadence rather than a stable, slow-moving interface. That is good news for a tool you use occasionally and a reason to pin a version if you depend on a specific key binding or export flag in a script.

## How lazycut differs from running ffmpeg by hand

The closest alternative is plain ffmpeg on the command line, using a seek and a duration to cut. The difference in approach is interactive feedback. Hand-written ffmpeg means specifying the cut before you see it, then waiting for the encode, then inspecting the result and guessing at a better offset. The trim subcommand expresses the same operation as a script:

```bash
lazycut trim --in 00:01:00 --out 00:02:00 -o out.mp4 video.mp4
```

That is roughly the equivalent of an ffmpeg seek and copy or re-encode, wrapped in one command with consistent flag names, and it is the right choice for unattended work.

What lazycut adds on top is the preview loop: scrub, watch, mark, export, without leaving the shell. The price is a dependency chain of FFmpeg, Chafa, Bubble Tea, Lipgloss and termenv, and a narrower set of encoding controls than ffmpeg exposes. For a scripted pipeline that runs nightly, plain ffmpeg is simpler. For a person deciding where a clip should start, the preview is the difference that matters.

## Conclusion

Adopt lazycut if you cut short clips from screen recordings or long takes and prefer keyboard-driven work over a desktop timeline. Do not expect it to replace a non-linear editor for anything with layered audio, titles or multiple source files. Before the first export, verify that FFmpeg and Chafa are on your PATH, that the source file plays correctly in the preview, and that the exported clip has the audio and duration you expected.

## FAQ

### How do I install lazycut and what does it need to run?

On macOS the README gives a single command, brew install lazycut. Building from source needs the latest Go plus ffmpeg and the chafa development packages, then go install github.com/ozemin/lazycut@latest. Both FFmpeg and Chafa must be present at runtime because lazycut calls them for decoding and for rendering the preview.

### How do I trim a video to a specific time range with lazycut?

Use the trim subcommand with --in and --out timestamps and an output path, for example lazycut trim --in 00:01:00 --out 00:02:00 -o out.mp4 video.mp4. The README also lists an interactive mode where you set in and out points with the i and o keys and press Enter to export.

### Can lazycut convert a video to vertical or square formats?

Yes. The README states that export supports aspect ratio conversion into 16:9, 9:16, 1:1 and 4:5, and that multiple sections can be exported separately or concatenated. The README does not document a codec or bitrate option for the conversion.

## Sources

- [Issues](https://github.com/ozemin/lazycut/issues)
- [License: MIT](https://github.com/ozemin/lazycut/blob/main/LICENSE)
- [ozemin/lazycut on GitHub](https://github.com/ozemin/lazycut)
- [README](https://github.com/ozemin/lazycut/blob/main/README.md)
- [Releases](https://github.com/ozemin/lazycut/releases)

---

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