LibreCuts: an Android video editor that keeps the work on the device

Editing that never leaves the phone

The pitch of LibreCuts is a video editor where the media never leaves the device. The project describes itself as a free, open source video editor for Android built around simplicity, efficiency and privacy, and the concrete claim is that you select, edit and export watermark free videos locally. That is a meaningful difference for a tool that handles personal footage, because there is no upload step, no project sync and no rendering farm account. It also means the performance story is tied to the device rather than to a server, which shapes what the software can and cannot do. The feature list is a mobile editor's feature list, and it is long: trim with a real time timeline control, overlays for text, stickers, images, GIFs and video with continuous looping support, mask shapes applied to overlays, a chroma key for green screen removal, keyframes for animating overlays across the screen, layer reordering, crop, merge with drag to rearrange, transitions with animated previews, a speed slider, brightness, contrast, saturation and colour filters, a canvas background that fills mismatched aspect ratios, reverse playback and freehand drawing on top of the footage. The missing entry in that list is as telling as the present ones, since there is no multi camera editing, no nested or compound clip structure and no advanced colour grading panel.

Subtitles, custom fonts and audio that behaves

Three areas go further than a typical phone editor. Subtitles can be imported as `.srt` files, and they are placed by touch directly on the video preview rather than through a position dialog, with a dedicated slider for resizing and full interactive positioning. Text overlays can use custom typography, because `.ttf` and `.otf` font files can be imported and are then available for the text overlay layer. The audio pipeline is the third area. You can import custom music or audio tracks, record a voice over, apply ducking so background music drops under speech, apply fades, amplify volume up to 200 percent, and mute the original clip audio entirely. The whole mix can be exported on its own as a standalone MP3, which is a small feature that saves a step when the point of the edit is a podcast clip or an audio snippet. Layer management is part of the same group of features: overlay layers can be reordered to control what renders on top, and overlay duplication is available from the timeline.

The .lcprj project file and non destructive editing

The editing model is non destructive, and the unit that is saved is a project file with the extension `.lcprj`. The documentation describes it as a way to save the project state and reopen editable projects at any time, and the app also supports importing such a file. This is the feature that separates LibreCuts from a tool that only exports finished video, and it matters for anyone who edits in sessions. A project that can be reopened means a caption fixed on a Tuesday is still a caption on a Friday, and a different crop does not require the trim to be repeated. The saving side is described as non destructive, so the source media is presumably retained and the edits are recorded as operations over it. The project file is a LibreCuts specific format rather than a documented interchange standard, and the documentation does not describe its internal structure, so the practical scope is sharing projects between LibreCuts installations rather than moving an edit into another editor. For a long project, the readme notes that the app is built for Android 13 themed icons and supports a fullscreen preview mode with an expanded timeline, which is a hint that the editing surface is single project focused.

Hardware accelerated export with a software fallback

Export is handled with device hardware accelerated `h264_mediacodec` encoding, and the documentation says there is an automatic fallback to software encoding for device compatibility, plus a mention of accurate FFmpeg progress calculation. This combination is the practical core of a phone editor, because the alternative is an export that either fails on some devices or takes ten minutes. The fallback is the part worth understanding rather than celebrating. A device where the hardware codec is unavailable or misbehaves will silently run a slower path, so a slow export is not necessarily a bug in your project, and there is no documented way to tell which path a given export took. The output format is h264, and the documentation does not describe HEVC, HDR handling or a bitrate control, nor does it mention frame rate conversion. For a tool aimed at clips destined for social platforms that is a workable scope. For anything that needs a different codec, a target bitrate, or an HDR source preserved, this is the boundary of what it does.

Getting the app onto a phone without a store account

Because the project is FOSS oriented, the distribution story matters as much as the feature list. The readme carries badges for a GitHub releases build, an F-Droid listing under the package name `com.tharunbirla.librecuts`, an Obtainium redirect, a Discord invite and a Weblate translation widget. Two paths are worth spelling out. The F-Droid listing is the standard route for a free software Android app, since F-Droid builds from the source tree and signs its own packages. Obtainium is the route for tracking a GitHub release directly, since it turns a repository URL into an installable app that updates when a new tag appears. Both avoid the app store, and that is not incidental here. The readme devotes a section to the Keep Android Open campaign, arguing that a mandatory developer verification policy taking effect in September 2026 will require independent developers to submit government ID and register centrally, which the project frames as a threat to sideloading freedom and to the distribution of free and open source software on Android. A sideloadable, store independent editor is a reasonable thing to want on a platform where that policy is landing. A translation workflow hosted on Weblate also means the interface is not English only.

Building from source for a first run

The source build path assumes a normal Android development setup. The stated prerequisites are Android Studio and the Android SDK, and the repository is structured as a standard Gradle project, with `build.gradle`, `settings.gradle`, `gradle.properties`, the `gradlew` and `gradlew.bat` wrappers, an `app/` module, a `src/` directory and a `fastlane/` directory for release automation. The first step of the documented install is to clone the repository.

git clone https://github.com/tharunbirla/LibreCuts.git

After that, Android Studio is opened and the existing project is selected through the Open an existing Android Studio project option, and the app is run on a device or emulator from there. The clone step is the only command the documentation gives, and there is no build command to copy, since the Gradle wrapper and the IDE do that work. Note the `fastlane/` directory: it suggests release notes and store listings are produced through that tooling, which is consistent with a project publishing to more than one channel. A `.vscode/` directory is also present for editor configuration, and the test files sit at the repository root as `test_exo.kt`, `test_ext.kt` and `test_heavy.kt`, with the names suggesting playback, extension and heavier load cases rather than a conventional `app/src/test` layout.

Where LibreCuts is the wrong tool

The clearest case against it is a project that outgrows a phone. There is no timeline zoom with track heights beyond what the phone screen allows, no clip nesting, no compound sequence, no proxy workflow and no integration with a desktop editor, so a multi camera interview or a ten minute narrative edit is not realistic here. The second limit is output control, since the documented encoder is h264 with a hardware path and a fallback, and there is no documented control over bitrate, resolution presets, HDR or frame rate conversion. The third is where the projects sit in their maturity. The newest published tags are v1.0-beta7 from 2026-08-17, v1.0-beta6 from 2026-07-24 and v1.0-beta5 from 2026-07-18, so this is pre 1.0 software in beta, which usually means features still move and file formats may still change. A project file written by one beta may not open in a later one, and the documentation does not promise otherwise. The counterweight is that the feature set is wide for a beta, the licence is MIT, and the last push was on 2026-10-19, so the work is current even if the version number is not yet final.

Licence and the shape of the code

The licence is MIT, stated in the `LICENSE` file at the repository root and reflected in the badge on the readme. That is a permissive licence with no copyleft obligation and no source disclosure requirement, which is the low friction case for a project that a vendor might want to fork, and it is a change from the norm for applications that carry a video editor engine. The code itself is Kotlin, and the repository layout suggests a single Android application module rather than a library that others consume. The `src/` directory at the top level sits next to the `app/` module, and the presence of `gradle.properties` and `gradle/` suggests a normal single project setup rather than a multi module build. There is no published API documentation, no changelog in the readme, and no stated support policy for older Android versions beyond the Android 13 themed icon feature, which applies only to the launcher icon. For a team that wants to extend the editor rather than use it, the absence of a documented plugin or extension point is the first thing to check, since the feature list is long and the extension story is absent from the documentation.

Editorial conclusion

LibreCuts fits a creator cutting short clips on an Android phone who wants a free editor with no watermark, no account and a reopenable `.lcprj` project file. It does not fit a multi camera project, a long form edit, or a workflow that depends on a desktop timeline. Before installing, check three things: that the F-Droid or Obtainium build matches the version you want, since the newest tags are v1.0-beta7 from 2026-08-17 and beta releases can change behaviour, that your device can fall back to software encoding if the hardware `h264_mediacodec` path fails, and that the MIT terms in the `LICENSE` file match what your organisation expects from a fully local editor. The last push was on 2026-10-19.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. tharunbirla/LibreCuts on GitHub