Yazi is a blazing-fast terminal file manager written in Rust, built on async I/O and a modular crate architecture. It provides a full-featured TUI with file operations (copy, move, delete, rename, trash), multi-tab support, visual mode, and extensive plugin system via Lua scripting. The architecture is event-driven with an actor model, a generic task scheduler for background operations, and a virtual filesystem abstraction supporting local, SFTP, and custom Lua backends. It includes image preview via multiple protocols (Kitty, Sixel, Chafa, etc.), clipboard integration, and a distributed data service for cross-instance communication. The codebase is highly modular with over 30 internal crates, each with a single responsibility, and demonstrates strong engineering practices including custom serialization (Wire protocol), cross-platform abstractions, and lock-free data structures. It is actively maintained with frequent commits, comprehensive CI/CD, and a detailed coding style guide (AGENTS.md).
File Browser is a self-hosted web-based file manager written in Go with a Vue 3 frontend. It provides a complete file management interface (upload, download, preview, edit, share, search) within a specified directory, accessible via a web UI or CLI. The architecture is a monolithic single binary that embeds the frontend assets and serves both the API and static files. Key entry points: main.go (CLI), cmd/root.go (Cobra commands), http/http.go (HTTP router), frontend/src/main.ts (Vue app). Data flows: HTTP requests → middleware (auth, rules) → handlers (resources, shares, search, preview, upload) → storage layer (BoltDB via storm) → filesystem (afero with ScopedFs for symlink confinement). External dependencies: BoltDB (embedded KV store), gorilla/mux (routing), gorilla/websocket (shell), tus-js-client (resumable uploads), ace-builds (editor), video.js (media), vue-i18n (30+ languages). The project is in maintenance-only mode per README but shows active commits (last 2026-06-30), regular releases, and security fixes.
lf is a mature terminal file manager written in Go. It provides a full TUI built on tcell/v3, with navigation, previews, search/filter, marks/tags, visual mode, and async file operations that delegate actual file mutations to external shell tools. The application follows a client/server architecture: a daemon listens on a Unix socket while multiple client instances can connect, issue remote commands, and maintain per-client state. Entry points are main.go for CLI parsing, client.go/server.go for lifecycle and IPC, app.go/ui.go for the event loop and rendering, and eval.go for command evaluation. Platform-specific code supports Linux, BSD, and Windows, with filesystem watching via fsnotify and disk-free space queries via platform-specific df_*.go files.
Files is a modern, open-source Windows file manager built with WinUI 3 and .NET 10, featuring multitabbing, dual-pane navigation, file tags, cloud drive integration, FTP support, Git version control, and a widget-based home page. The architecture is a modular monolith with separate projects for the main app (Files.App), a server component (Files.App.Server), storage abstractions (Files.App.Storage, Files.Core.Storage), a source generator for CsWinRT interop (Files.Core.SourceGenerator), and custom UI controls (Files.App.Controls). The codebase makes heavy use of source-generated P/Invoke via CsWin32, Roslyn source generators for VTable functions and command managers, and the CommunityToolkit.Mvvm pattern with ObservableObject and dependency property source generation. The app supports MSIX packaging, sideload and Store distribution channels, and includes C++/COM components for custom open/save dialogs and a launcher. The last commit was on 2026-06-30, and the project has 44k stars with active CI/CD workflows.
Cloudreve is a production-grade, self-hosted file management system (v4) built with Go, Gin, and the ent ORM. It provides a full-featured cloud storage platform supporting multiple storage backends (local, S3, Aliyun OSS, Tencent COS, Huawei OBS, Qiniu, Upyun, OneDrive), WebDAV, WOPI for online Office editing, OAuth2, WebAuthn passkeys, full-text search via Meilisearch, thumbnail generation (vips, ffmpeg, LibreOffice), media metadata extraction (EXIF, ffprobe), and a background task queue for async operations like archive creation, remote downloads, and indexing. The architecture follows a layered pattern with dependency injection, a database-backed filesystem (DBFS) with navigators, an event hub for real-time file events, and a master-slave cluster for distributed nodes. The codebase is well-organized into reusable packages (e.g., pkg/request, pkg/queue, pkg/cache, pkg/auth) and includes a comprehensive admin panel for managing users, groups, storage policies, tasks, and nodes. While primarily an application, it also incorporates data engineering patterns like media metadata extraction and full-text indexing for user-facing features.
elFinder is a mature, full-featured web-based file manager with a client-server architecture. The client is built on jQuery and jQuery UI, providing a rich interface for file operations (browse, upload, download, copy, move, rename, delete, search, preview, edit, archive, etc.) with extensive internationalization and plugin support. The server-side is a PHP connector that abstracts storage backends via a volume driver pattern, supporting local filesystem, FTP, SFTP, MySQL, Dropbox, Google Drive, OneDrive, Box, and more. The codebase demonstrates strong engineering practices: a command pattern for file operations, a plugin system for both client and server, a session abstraction, and a UI widget factory. However, it carries legacy dependencies (jQuery UI, PHP 5.2+) and some cloud drivers have incomplete implementations or API drift. Overall, it is a well-crafted, production-ready application with several reusable patterns.
Twake Drive is a full-featured file management web application built on the Cozy platform. It provides a React-based single-page application for browsing, uploading, downloading, sharing, and editing files. Key features include shared drives, real-time collaborative whiteboarding with Excalidraw, document editing via OnlyOffice, PDF annotation, file versioning, a file picker service for external app integration, and comprehensive sharing capabilities (by link, by email, with permissions). The application communicates with a Cozy Stack backend via the cozy-client library and supports multi-instance sharing between Cozy users. Architecture is a frontend SPA with React, Redux for upload state, and numerous React context providers for sharing, selection, clipboard, and view settings. External dependencies include cozy-ui, cozy-sharing, twake-i18n, and cozy-flags. The codebase is well-structured with modular components, extensive unit and E2E tests, and demonstrates high craftsmanship in areas such as conflict resolution, virtualized file lists, and real-time collaboration.
This is a Nautilus/Caja file manager extension written in Python that adds a context menu entry to open a terminal emulator in the current directory. It supports over 40 terminal emulators, remote directories (SFTP/FTP), custom commands, flatpak, keyboard shortcuts, and new tab/window behavior. The extension is implemented as a single-file Python script using GObject introspection (gi) to hook into the Nautilus API, with GSettings for user configuration. It provides localized strings via gettext translations. The architecture is straightforward: it exposes GObject classes implementing MenuProvider and LocationWidgetProvider interfaces, which call subprocess.Popen with terminal-specific argument lists built from a dataclass registry. Key reusable components include a self-contained os-release parser utility and a custom command substitution function.
SpanFinder is a fully-featured Windows file explorer replacement built with WinUI 3 and .NET 8, implementing the macOS Finder Miller Columns paradigm. The application supports multiple view modes (Miller Columns, Details, List, Icons), multi-tab with tear-off, split pane, Quick Look preview, batch rename, archive handling (ZIP, RAR, 7z via native OtterZip engine), remote file access (FTP/SFTP/SMB), Git integration, cloud sync badges, and a file shelf for drag-and-drop staging. The architecture follows MVVM with dependency injection, extensive use of Win32 P/Invoke and COM interop for shell integration, and a separate thumbnail worker process for crash isolation. The codebase is well-organized into Services, Models, ViewModels, and Helpers, with over 150 unit tests and 40+ UI automation tests. However, it exhibits some mixed abstraction layers and a few large partial classes (MainWindow, MainViewModel), and many comments reference specific bug fixes, indicating ongoing refinement. The repository is actively maintained with recent commits, a single open issue, and regular versioned releases (v2.0.7).
Spacedrive is a cross-platform file manager and virtual distributed file system (VDFS) that unifies files across devices and cloud storage into a single, searchable library. The core engine is written in Rust and provides indexing, media processing (thumbnails, OCR, speech-to-text), P2P sync with conflict resolution, volume detection, file operations, and an extensible WASM plugin system. The codebase is a large monorepo with multiple frontends: a Tauri desktop app, React Native mobile app, CLI, and web interface, all communicating with a daemon process via a typed RPC protocol. The architecture follows CQRS/DDD patterns with auto-generated TypeScript types and a job/task system for background work.
Material Files is a sophisticated, open-source Android file manager built with Kotlin and Material Design principles. Its core architecture is a custom implementation of the Java NIO2 file system API (`java.nio.file.spi.FileSystemProvider`), providing a unified abstraction over multiple backends: the local Linux filesystem (accessed via JNI syscalls), Android's proprietary Documents/Content providers, and remote network protocols including SMB, SFTP, FTP, and WebDAV. The UI is constructed from Android Fragments, RecyclerView adapters, and custom Material Design widgets, orchestrated by a ViewModel/LiveData pattern for reactive state management. The application goes far beyond basic file browsing. It features a comprehensive background file job service for copy, move, delete, and archive operations with progress tracking and conflict resolution. It includes a built-in FTP server, an image viewer with EXIF support, a text editor, and deep file property inspection (APK metadata, audio/video tags, checksums, POSIX permissions, and SELinux context). Root access is achieved through a separate process communicated via AIDL (Android Interface Definition Language), demonstrating a sophisticated IPC architecture for privilege escalation. The codebase is actively maintained by a single developer, with recent commits and a clear version history. However, it suffers from high technical drift due to its heavy reliance on Android's internal, undocumented, and frequently changing APIs (e.g., `android.system`, `android.os.storage`). The extensive `compat` package is a testament to the constant battle against platform evolution. This makes the project fragile and high-risk for long-term maintenance without dedicated effort. Despite its overall complexity, the repository contains several genuinely reusable, high-craftsmanship components. Standouts include the `ByteString`/`ByteStringPath` classes for handling non-UTF-8 filesystem paths, a generic `ListDiffer` algorithm, a robust `Stateful`/`DataState` state machine pattern, and clean implementations of throttling/debouncing. These components are self-contained and could be extracted for use in other Kotlin or Java projects. The overall quality score is 7.5, reflecting strong engineering and feature depth, balanced against significant platform-specific technical debt.
ItemzFlow is a PlayStation 4/5 homebrew application suite consisting of a graphical file manager/installer (itemzflow), a background daemon for extended functionality (itemz-daemon), and a launcher/loader (itemz-loader). The system enables users to backup game data to USB/NFS shares, install PKG packages, apply custom patches via XML files, manage themes, and run homebrew applications. It integrates numerous third-party libraries including TagLib (audio metadata), cURL (network transfers), mbedTLS (cryptography), and libfuse (filesystem in userspace) to provide comprehensive system management capabilities on jailbroken PlayStation consoles. The application uses OpenGL ES 2.0 for its user interface and relies heavily on PS4/Orbis SDK-specific system calls.
AnExplorer is a native Android file-manager application (package dev.dworks.apps.anexplorer) that exposes a Storage Access Framework-compatible DocumentsProvider layer over many storage backends: external/internal storage, USB OTG, root shell, FTP/FTPS, cloud storage (Google Drive, Dropbox, OneDrive, Box via CloudRail), app management, zip archives, recent files, and a note editor. It is a heavily customized fork of AOSP DocumentsUI: the core browsing state-machine, document stack, roots cache, recents persistence, and loader/cursor stack are AOSP-derived, with substantial product-specific additions for monetization, multiple build flavors, PIN security, settings, and Wear OS/TV support. The marketing site in web/ is a static Firebase-hosted page, not part of the application logic. The architecture is a classic Android monolith: Activities and Fragments drive the UI, Loaders and custom Cursor wrappers feed RecyclerView adapters, and each storage backend is implemented as a DocumentsProvider ContentProvider. Main entry points are DocumentsActivity and StandaloneActivity for browsing, plus the provider authority intents for the Storage Access Framework. External dependencies include AndroidX, Firebase Analytics/AdMob/Crashlytics, CloudRail, libaums for USB, Apache Commons Net for FTP, and an in-app billing library. Quality is mixed. The provider and cursor abstractions are reasonably flexible and a few utility components are genuinely reusable, but the codebase carries heavy technical drift: AGP 3.3 alpha, targetSdk 28, deprecated android.app.Fragment/AsyncTask/PreferenceActivity usage, duplicated flavor-specific classes, hardcoded ad and analytics identifiers, and third-party SDKs that are no longer actively maintained. It remains a functional, feature-complete consumer app rather than a modern engineering showcase.