NFile is an Android-only Flutter file manager that indexes media natively instead of scanning folders
A Beautiful File Manager
At a glance
- What is it?
- A GPL-3.0 Flutter app that started as a plain file explorer and now ships built-in video, audio and image viewers, a text editor and native media indexing. The catch is distribution: the README documents only a source build, and there is no published package for an end user to install.
- Who is it for?
- NFile makes sense for an Android developer who wants a readable reference implementation of a native-indexed media browser in Flutter, or who intends to fork it and ship their own build, since GPL-3.0 suits exactly that kind of derivative work. It does not suit an end user looking for a file manager to install today, because the only documented route is compiling it yourself against an API 21 or newer device.
- Can I use it commercially?
- Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository last received commits 96 days ago.
- What is it written in?
- Mainly Dart, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- Senzme/NFile447 ★ · +36
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| Senzme/NFile | 411 | 447 |
36 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
MANAGE_EXTERNAL_STORAGE sits next to three granular READ_MEDIA permissions
The permission list is the clearest statement of how this app works, and it is split in two. MANAGE_EXTERNAL_STORAGE is the broad one, requested for file operations across the entire device, which is what makes copy, cut, paste, rename and delete possible anywhere in shared storage rather than inside an app sandbox. The other three are the scoped media permissions: READ_MEDIA_IMAGES, READ_MEDIA_VIDEO and READ_MEDIA_AUDIO, requested for high-speed native media indexing. Holding both families at once is deliberate rather than accidental. The broad permission covers the file manager half of the product, and the scoped ones cover the media half, so the gallery can be built from the platform's own index without walking the filesystem. A reader evaluating this app should know that the broad storage permission is the one that has to be granted through system settings rather than through a normal runtime prompt, which changes what the first-run experience looks like on a modern Android device.
The build path is clone, pub get, flutter run, with an API 21 floor
There is no distribution story here, only a build story. The documented sequence has three steps: clone the repository, install dependencies, then run the app on an Android device. The dependency and run commands are the standard Flutter pair:
flutter pub get
flutter runThe device requirement is stated as API 21 or newer, which is a low floor and means the project is not tied to recent platform behaviour. Nothing in that sequence builds a release artifact, nothing points at a store listing, and the repository has no homepage set, so an interested user has no download to try. For a contributor this is workable but manual: you need a Flutter SDK, an Android device or emulator, and a run cycle per change. For anyone who merely wanted the file manager, it is a dead end. The repository does carry a fastlane directory and a metadata directory next to android/, lib/, assets/ and test/, which is the layout a store submission process expects, but no step in the instructions uses them.
Native indexing replaces the recursive scan of the earlier explorer
The clearest statement of what changed in this project is a line in the feature list: gallery views for images, video and audio are built using native device indexing, and the phrase that follows is that there are no more slow recursive scans. That is the whole architectural pitch, and it explains why two specific packages are in the dependency list. photo_manager backs the image and video side of the index, and on_audio_query backs audio, which is why each has its own corresponding permission above. A recursive directory walk gets slower as storage grows, and on a phone that storage grows without anyone deciding to grow it. Querying the platform index instead turns a linear filesystem problem into a database lookup the system already maintains. The rest of the browsing surface follows from the same assumption that the app knows the device's media up front: quick categories give one-tap access to the indexed libraries, and the sorting control offers newest, oldest and date-wise order over the same index.
media_kit plays the media, photo_view and open_filex open the files
The dependency list reads as a map of the feature list. media_kit is named as the media engine for video and audio playback and is credited with smooth playback of high-resolution video, while the audio player is described separately as a clean interface with album art and precise seeking. Viewing files outside the app is handled by photo_view for the pinch-to-zoom image viewer and open_filex as the companion opener, which is what lets the text editor hand a file to an external application rather than trying to render every format. The built-in editor itself covers .txt, .md, .json and other code files, a narrow scope that suits quick edits rather than an editor replacement. State is managed with provider, and permissions go through permission_handler. The only piece of the stack with a stated version floor is Flutter itself, at API 21 on the platform side; nothing in the visible dependency set pins the Dart SDK or Flutter release, so a contributor targeting a very new Flutter release should expect to resolve that themselves.
An AMOLED dark mode and a Broken icon pack carry the identity
The visual argument is made in a handful of lines and deserves to be read as design decisions rather than adjectives. Dark mode is described as dynamic and AMOLED-friendly, which on a phone means the interface is expected to render true black areas rather than a dark grey, so that pixels switch off on an OLED panel. The icon pack is called Broken and described as exclusive to this app, so the iconography is a distinguishing feature rather than a stock set. The surfaces themselves use texture and alpha blending to produce what the text calls a modern glassmorphic feel, and the motion is described as iOS-style bouncy physics with smooth transitions throughout. That last detail is interesting against the platform target: an Android-only app is borrowing its interaction vocabulary from iOS on purpose. Storage usage gets the same treatment as a feature, with a visual representation of internal storage rather than a numeric figure, which suggests the intent is a file manager that reads as a consumer app rather than as a utility.
Android is the only target the instructions mention
Flutter is a cross-platform framework and this project is written as one, yet every instruction, permission and platform requirement in the documentation is Android-specific. The run step names an Android device, the permissions listed are all Android permissions, and MANAGE_EXTERNAL_STORAGE has no counterpart outside that platform. The repository root matches that story: android/ is present and there is no ios/, web/, linux/, macos/ or windows/ directory among the top-level entries. That is a deliberate scope decision rather than an oversight, and it has consequences for anyone evaluating the code. The media packages, the permission handling and the storage assumptions all sit inside that boundary, so porting means replacing rather than configuring. There is also no home page, no changelog and no configuration section in the documentation, so the .metadata file, analysis_options.yaml and the committed pubspec.lock are the only clues about how the project is set up for analysis and dependency pinning.
GPL-3.0 with no published build and a release trail that stops in July
Two facts frame any decision about this project. The first is the licence: the README states GNU GPL v3 and a LICENSE file sits at the repository root, which is the permissive-to-copy, share-alike choice and suits a project intended to be forked rather than consumed as a dependency. The full terms are in that file, and anyone deriving a build from this source needs to read it before publishing anything. The second is the release trail. Three releases are on record: v1.0.42 on 2026-06-07, v1.0.43 on 2026-07-04 and v1.0.44 on 2026-07-12, a monthly cadence that then stops. The last push to the repository was on 2026-08-11, about a month after the newest tag, so there is work in the tree that no release carries. Version numbering in the 1.0 range with patch bumps and no minor or major move also suggests an app being iterated rather than a library settling on an API.
Editorial conclusion
NFile makes sense for an Android developer who wants a readable reference implementation of a native-indexed media browser in Flutter, or who intends to fork it and ship their own build, since GPL-3.0 suits exactly that kind of derivative work. It does not suit an end user looking for a file manager to install today, because the only documented route is compiling it yourself against an API 21 or newer device. Before you fork it, check that your target devices grant the broad storage permission it asks for, and read the LICENSE file at the root to see what that licence obliges you to publish.
Frequently asked questions
What permissions does NFile request on Android?
Two families. MANAGE_EXTERNAL_STORAGE covers file operations across the entire device, and READ_MEDIA_IMAGES, READ_MEDIA_VIDEO and READ_MEDIA_AUDIO are requested for high-speed native media indexing.
Which platforms can I build NFile for?
The instructions cover Android only, on an API 21 or newer device. No iOS, desktop or web build is described, and the repository has no corresponding platform directory at the top level.
How do I build and run NFile from source?
Clone the repository, run flutter pub get to install dependencies, then run flutter run against an Android device. The documentation does not describe producing a release artifact.
Which Flutter packages does NFile use for media handling?
media_kit handles video and audio playback, photo_manager and on_audio_query handle indexing, photo_view and open_filex back the viewers, permission_handler handles permissions, and provider handles state.
Is there a downloadable build or store listing for NFile?
None is documented. The README gives only the source build path, the repository has no homepage set, and although a fastlane directory sits at the root, no instruction uses it to publish a package.
What licence is NFile released under?
GNU GPL v3, stated in the README and recorded in the LICENSE file at the repository root.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/senzme-nfile)Star history chart for your README
[](https://hysenlabs.com/projects/senzme-nfile)Was this useful?