Open-source project
GNOME/nautilus avatar
GNOME/nautilus

GNOME Files (nautilus): The Default File Manager as a Platform, Not Just an App

Read-only mirror of https://gitlab.gnome.org/GNOME/nautilus

424 stars146 forksCGPL-3.0

At a glance

What is it?
GNOME Files, the project known as nautilus, is the default file browser for GNOME. This review covers its runtime dependencies, extension API, and the strict design process that shapes it, and it concludes that it is the right choice for GNOME desktop users and extension developers, not for those seeking a standalone file manager.
Who is it for?
Adopt GNOME Files if you are a GNOME desktop user who wants a file manager that integrates with the desktop's search, metadata, and design language, or if you plan to write extensions using the libnautilus-extension API. Do not adopt it if you need a standalone file manager with frequent feature additions outside GNOME's design approval process.
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 received new commits within the last day.
What is it written in?
Mainly C, 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.

From daily snapshots

Star history

  • GNOME/nautilus424 ★ · +10
Star history
Repository2026-08-212026-11-15
GNOME/nautilus414424

10 Stars in the last 86 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The Problem It Solves and Who It Is For

GNOME Files, internally named nautilus, is the default file browser for the GNOME desktop. It solves the problem of providing a consistent file management experience that follows the GNOME design guidelines. It is not a generic file manager for all Linux users; it is a core component of the GNOME desktop. The intended audience is GNOME users who expect a file manager that integrates with the desktop's other components, such as search and metadata extraction. It is also for developers who want to extend file management capabilities through the libnautilus-extension API. The README explicitly states that Files is a core component of the GNOME desktop experience, and any changes in behavior or appearance only happen in accordance with the GNOME design team. That means the project is not driven by individual feature requests but by a coordinated design process.

How It Works: Dependencies and Data Flow

The repository is a read-only mirror of the upstream GitLab project, so the code itself is C, but the README focuses on runtime dependencies that shape how the file manager operates. The first dependency is Bubblewrap, used for security reasons. This suggests that file operations, possibly previews or thumbnail generation, are sandboxed to prevent malicious files from affecting the system. The second dependency is LocalSearch, which must be properly set up with all features enabled. LocalSearch powers fast search, metadata extraction, starred files, and batch renaming. That means Files does not implement its own search index; it delegates to a system-wide service. The third dependency is xdg-user-dirs-gtk, which creates default bookmarks and updates localization. The data flow is therefore: Files calls LocalSearch for any search or metadata operation, uses Bubblewrap to isolate risky operations, and relies on xdg-user-dirs-gtk for initial user directory setup. This architecture makes Files a front-end to a set of GNOME services rather than a self-contained utility.

Getting It Running: Installation and Dependencies

The README does not provide build instructions, but it does give clear guidance on how to get a working version. It says that only the latest version of Files as provided upstream is supported. The recommended way to try it is the Flatpak nightly installation, available from the GNOME welcome page. The README advises installing the nightly build before filing issues, to ensure the installation is reproducible and does not have downstream changes. This is a practical approach: you avoid distribution-specific patches and get the exact upstream behavior. For runtime, you need Bubblewrap installed, LocalSearch set up with all features enabled, and xdg-user-dirs-gtk installed. If you are on a standard GNOME distribution, these are likely present, but if you are on a minimal system, you must install them manually. The README does not list build dependencies or compilation commands, so if you want to build from source, you must look elsewhere. For most users, the Flatpak nightly is the simplest path.

The Extension API: A Platform for Customization

Files exposes an extension API called libnautilus-extension. The README points to generated documentation for this API and mentions a separate project, nautilus-python, for developing extensions in Python. This is a significant aspect of the project: it is not just a file manager but a platform that third-party developers can extend. The extension mechanism allows adding context menu items, column types, and other file management features without forking the application. The documentation is hosted on GNOME's GitLab pages, and the Python bindings are documented separately. For developers, this means you can write extensions in C or Python, but you must follow the API's conventions. The existence of a Python binding suggests that the API is stable enough to support high-level language bindings. However, the README does not provide examples or a tutorial, so you must consult the linked documentation. This is a concrete way to customize Files, but it is not trivial; you need to understand the API and possibly the GNOME extension model.

A Genuine Limitation: Design Approval as a Gate

The most significant limitation is the design process. The README states that any changes in behavior or appearance only happen in accordance with the GNOME design team, and mockups must be approved by the design team to be considered for implementation. This means that if you have a feature request that is not already aligned with the design team's vision, it may never be implemented. The README advises starting a discussion on Discourse and reaching out to the #gnome-design Matrix room before involving the issue tracker. For enhancements that are limited in scope and well-defined, you can open an issue directly using a shortcoming template. This is a barrier to contribution: it is not enough to have a good idea; you must convince the design team first. This is a deliberate trade-off to maintain a cohesive user experience, but it makes Files a poor choice for users who want rapid feature additions or a file manager that follows community whims. If you need a file manager with a more permissive feature process, you would look elsewhere.

Alternatives: The Different Approaches

The obvious alternative is a file manager like Dolphin, which is the default for KDE Plasma. Dolphin takes a different approach: it is more feature-rich out of the box, with split views, tabs, and extensive customization options, and it does not require a central design team approval for every change. Dolphin is also built on Qt, while Files is GTK-based, so the choice often comes down to your desktop environment. Another alternative is to use a terminal-based file manager like ranger, which is entirely different in interaction model, focusing on keyboard navigation and scripts. The key difference in approach is that Files prioritizes integration with GNOME services and design consistency, while Dolphin prioritizes feature completeness and user control. If you are not on GNOME, or if you dislike the design gate, Dolphin or ranger may be more suitable. The README does not mention alternatives; this comparison is based on general knowledge of the ecosystem.

Maintenance and Upgrade Cost

The README states that only the latest version of Files as provided upstream is supported. This means you must stay on the latest release to receive bug fixes and security updates. The project is not archived, and it is actively developed as part of GNOME, but the read-only mirror on GitHub is not the primary development location; the upstream is on GitLab. This has implications for maintenance: if you use a distribution that packages an older version, you are on your own for support. The README explicitly says that if you cannot reproduce an issue in the nightly Flatpak, you should file an issue in your distribution. That places the burden on the user to test the latest version. The license is GPL-3.0, which means if you modify and distribute the code, you must make your changes available under the same license. This is standard for GNOME projects and should not be a surprise, but it is worth noting if you plan to embed or fork the code. The extension API is documented, but there is no mention of API stability guarantees, so upgrading Files might break extensions if the API changes.

Editorial conclusion

Adopt GNOME Files if you are a GNOME desktop user who wants a file manager that integrates with the desktop's search, metadata, and design language, or if you plan to write extensions using the libnautilus-extension API. Do not adopt it if you need a standalone file manager with frequent feature additions outside GNOME's design approval process. Before adopting, verify that your distribution provides the latest upstream version, that Bubblewrap and LocalSearch are installed and configured, and that your extension ideas align with the GNOME design team's approval requirements.

Frequently asked questions

Is the GNOME/nautilus GitHub repository the place to report bugs?

No. It is a read-only mirror, and issues go to the GNOME issue tracking system at gitlab.gnome.org/GNOME/nautilus/issues. The README also says that if you cannot reproduce a problem on the Flatpak nightly, you should file it in your distribution instead.

What runtime dependencies does nautilus, the Files app, require?

Bubblewrap installed for security reasons, LocalSearch properly set up with all features enabled, and xdg-user-dirs-gtk installed. LocalSearch supplies fast search, metadata extraction, starred files and batch renaming, while xdg-user-dirs-gtk creates the default bookmarks and updates localization.

How do I get a Nautilus build I can reproduce a bug on?

Use the Flatpak nightly. The project asks you to try it before filing an issue, because it makes the installation reproducible and free of downstream changes. If the problem does not appear there, the report belongs in your distribution rather than in the GNOME issue tracker.

Can I propose a change to how Files looks through an issue?

Not on its own. Files is a core component of the GNOME desktop, so changes to behavior or appearance happen only in accordance with the GNOME design team, and mockups must be approved by that team to be considered for implementation. Major changes start on Discourse and in the gnome-design matrix room.

How do I write an extension for nautilus?

There are two documented paths. The libnautilus-extension API covers the C side and its library is a top-level directory in this repository, while Python developers are directed to the separate nautilus-python project and its own documentation.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/gnome-nautilus.svg)](https://hysenlabs.com/projects/gnome-nautilus)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/gnome-nautilus.svg)](https://hysenlabs.com/projects/gnome-nautilus)

Was this useful?