LosslessCut

Most video software wants to be a suite. It wants to color-grade, add transitions, mix audio, and render for six hours while laptop fans scream. LosslessCut wants none of that. Built by developer Mikael Finstad and released April 1, 2020, it is a graphical front-end for FFmpeg, the command-line media engine that quietly powers half the internet’s video pipeline. The pitch is simple and, once understood, compelling: cut, trim, and merge video and audio files without re-encoding them.

That distinction is the entire product. Traditional editors decode footage, apply changes, then re-encode a brand-new file—a process that burns time and shaves quality with every pass. LosslessCut instead performs a direct stream copy, lifting the exact original data between two points and dropping it into a new container. The result appears in seconds. A ten-minute cut from an hour of 4K drone footage that would leave a conventional editor rendering through a coffee break finishes here before the mug is reached.

Its market position is deliberately narrow, and that’s a strength. This is not a competitor to DaVinci Resolve or Final Cut. It’s the tool to reach for before those—the rough-cut station where raw footage gets triaged. Content creators can use it to strip dead air. Drone operators and dashcam owners can isolate the good thirty seconds from a forty-minute flight. Podcasters and archivists can remux, rotate, and extract streams. The community’s nickname—“the Swiss Army knife of lossless editing”—overstates the breadth but nails the spirit. It’s a specialist tool built to do one job, and do it well.

• Lossless Stream Copying: The headline act. Cuts and merges happen via direct FFmpeg data copies—zero re-encoding, zero generational quality loss, and export times measured in seconds rather than hours by design.
• Multi-Track Stream Management: Add, discard, or extract individual audio, video, and subtitle streams. Pull the isolated audio out of a clip, drop a rogue commentary track, or export a single subtitle file without ceremony.
• Remuxing & Container Support: Repackage media between container formats (MP4, MKV, MOV, and more) without altering the underlying codecs—invaluable for compatibility headaches.
• Metadata Rotation & Snapshots: Fix sideways mobile video by flipping the orientation flag instead of re-rendering, and pull full-resolution frame snapshots for thumbnails.
• Segment-Based Workflow: Mark multiple in/out points across a single file and export them all at once, batching a messy afternoon of edits into one keypress.

The Core Loop

The workflow in LosslessCut is a rhythm that clicks fast. Load a file. Scrub the timeline. Drop an in-point. Drop an out-point. Repeat for every segment to keep or kill. Hit export. That’s the loop, and its strength is how little friction sits between intent and result. There’s no timeline to build, no project to manage, no render queue to babysit. Functionally, it’s a visual interface for telling FFmpeg where to make its cuts—and that honesty about what it is keeps the whole experience fast and legible.

The multi-segment workflow is where power users live. Instead of exporting one cut at a time, a long recording gets littered with segment markers and batch-exported in one go. For anyone processing raw footage at volume—a streamer trimming a VOD, an editor pulling selects from a shoot—this collapses an hour of tedium into minutes. The stream-extraction tools extend that same logic sideways: need just the audio? Just the English subtitle track? Just the video with the music bed stripped? A few clicks, done, and again without re-encoding a single frame.

The Keyframe Catch

Here’s the trade-off, and it’s a real one to understand before trusting this tool with anything precision-critical. Because LosslessCut copies streams rather than re-encoding them, cuts snap to keyframes by default. Video compression only stores complete frames (keyframes) at intervals; the frames between them are mathematically derived from those anchors. To cut on an arbitrary frame, a re-encode would be required—which is exactly what LosslessCut refuses to do. So a cut lands on the nearest keyframe, which might be a fraction of a second off from where it was placed.

For rough-cutting raw footage, this is a non-issue. For frame-accurate work—cutting precisely on a beat, matching a hard sync point—it’s a genuine limitation. LosslessCut does offer a re-encoding mode to force frame accuracy, but that sacrifices the speed and losslessness that justify using it in the first place. The design is refreshingly honest about this tension, but it’s the single concept most likely to trip up newcomers who expect a conventional editor’s precision and get keyframe reality instead.

The Onboarding Friction

LosslessCut is powerful, and it is not always obvious. The interface assumes familiarity with streams, containers, and keyframes—vocabulary that’s second nature to an FFmpeg veteran and a wall of jargon to a hobbyist. The learning curve isn’t about complexity of use; the loop is dead simple once it clicks. It’s about the conceptual model. Nothing explains why a cut landed a half-second early, and features like stream extraction or metadata rotation tend to be discovered by accident or by trawling the documentation. This is a tool that rewards the curious and mildly punishes the impatient.

Aesthetically, LosslessCut is utilitarian and unbothered by trends. The interface is a dark, dense workspace: a preview pane, a timeline, a segment list, and a wall of controls that prioritize function over polish. It’s not ugly, but it’s not courting anyone either. Icons can be cryptic, and the information density means the first stretch of use involves a fair amount of hovering to learn what does what.

Performance, though, is the whole point—and the design delivers on it. Because the heavy lifting is a stream copy rather than a render, exports are effectively I/O-bound, limited by how fast a disk can write rather than how hard a CPU can churn. The application footprint stays light by construction. There’s no render pipeline to generate thermal drama or progress bars worth resenting. For large files, this design doesn’t just beat traditional editors at their own game—it operates in a different category. That’s the payoff for the interface’s austerity: every design decision serves throughput.

Now for the elephant: LosslessCut is not an iOS app. It is a cross-platform desktop application for Windows, macOS, and Linux, built on the Electron framework and wrapped around a desktop FFmpeg binary. The listing here tags it for iOS at $18.99, and that’s a category error worth flagging plainly, because it matters to anyone expecting to install it from the App Store and trim a clip on an iPhone.

The entire interaction model—precise timeline scrubbing, keyboard shortcuts for in/out points, drag-and-drop file handling, direct filesystem access to source and export folders—is built for a mouse, keyboard, and a real file system. iOS’s sandboxed storage and touch-first paradigm are fundamentally hostile to how this tool works. There is no touch-optimized build, no gesture layer, no mobile port. On iPhone or iPad, lossless trimming means entirely different apps. Judged as the desktop utility it actually is, LosslessCut is solid. Judged against the iOS label attached to it, it simply doesn’t exist there—and no review should pretend otherwise.

LosslessCut earns its standing by refusing to overreach. It picks one hard problem—removing footage without degrading it—and solves it well enough that render-and-wait editing for simple cuts feels wasteful by comparison. The keyframe limitation is real but honestly disclosed, the interface demands patience, and the specialist appeal is genuine. The firm correction to the record is the platform: this is a desktop utility, not an iOS app, and buyers deserve that clarity up front. Take it for what it is—a fast, focused blade for desktop video—and it’s a solid pick for exactly the audience it was built for.