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.
ProjectSend is a self-hosted secure file sharing platform built as a modular Laravel application with an Inertia.js + React frontend. The codebase is organized into domain modules — Files, Clients, Groups, Identity, Comments, Notifications, Audit, Platform, and Api — each containing controllers, services, policies, models, and event hooks. Staff members upload and share files with clients or groups, manage roles and permissions, enforce download limits, expire or version files, and monitor activity through a detailed audit log. Clients access their own portal with four switchable themes (default, compact, drive, gallery), and public share links support additional presentation themes with pagination, previews, and controlled downloads. The application is a monolith with strong modular boundaries rather than microservices. Authentication supports local accounts, LDAP, social login/SSO via OIDC, two-factor authentication, CAPTCHA, and password policies. A REST API protected by Sanctum tokens offers scoped abilities, RFC 7807 problem details, polling-based pagination, and an OpenAPI contract that is drift-tested against the live route surface. Background jobs handle zip downloads, email digests, thumbnails, file cleanup, and scheduled maintenance. The system persists settings, activity logs, notification preferences, and upload metadata in a relational database, while file payloads can be stored on local disks, S3-compatible storage, or Google Cloud Storage. The code is notably security-conscious: secrets are encrypted at rest, old input flashing excludes credentials, CSRF cookie naming is customized to avoid collisions, download paths are never exposed in API responses, and regression tests cover disclosure boundaries, permission scoping, token revocation, and account erasure. The test suite is extensive, using Pest feature tests to exercise permissions, file lifecycle edge cases, version chains, comment visibility, API contracts, and authentication flows. The architecture favors event-based extension points and registry patterns, making modules independently testable and partially reusable, though the project remains an application rather than a framework or library. Overall this is a well-crafted, actively maintained application with clean engineering practices, clear separation of concerns, and unusually thorough security regression coverage. Its main complexity is the large surface area of interchangeable themes, editions, authentication backends, and storage drivers, which creates some ongoing drift risk, but current CI, recent commits, and dependency management show the project is keeping pace with its ecosystem.
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.
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.
trash-cli is a command-line interface implementing the FreeDesktop.org Trash specification. It provides five primary commands: trash-put (move files to trash), trash-list (list trashed files), trash-restore (interactively restore files), trash-empty (empty trash directories), and trash-rm (remove specific trashed files). The architecture is modular, with separate packages for each command (trashcli/put/, trashcli/list/, trashcli/restore/, trashcli/empty/, trashcli/rm/) sharing common utilities from trashcli/lib/, trashcli/fslib/, and trashcli/fstab/. Key entry points are the main() functions in each command's main.py module, invoked via shell scripts (trash, trash-put, etc.). Data flows involve reading trash directories (per the spec's rules for $XDG_DATA_HOME/Trash, .Trash/$uid, .Trash-$uid), parsing .trashinfo files, and performing file operations (move, delete, restore) with security checks (sticky bits, symlinks, world-writable directories). External dependencies include psutil (for volume detection), six (Python 2/3 compatibility), and optionally shtab (shell completion). The codebase is well-tested with a comprehensive fake filesystem for unit tests and integration tests covering edge cases.
TiddlyDesktop is a desktop application that serves as a custom web browser for working with locally stored TiddlyWiki files and folders. Built on nw.js (formerly node-webkit), it provides a native windowing system to open, edit, save, and manage multiple TiddlyWiki instances. The application includes a backstage configuration wiki for managing settings, a wiki list window for organizing wikis, and support for both single-file HTML wikis (TiddlyWiki 5 and Classic) and wiki folder formats. It implements file saving via a TiddlyFox-like protocol, automatic backups, and drag-and-drop wiki registration. The architecture is modular, with separate window classes for wiki files, wiki folders, and backstage tiddlers, all managed by a central window list. The codebase is well-structured and demonstrates solid engineering practices for an nw.js application.
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).
Maid is a Ruby command-line tool and library that automates file organization and cleanup based on user-defined rules expressed in a Ruby DSL. It provides a suite of operations (move, trash, copy, rename, etc.) that can be combined with file metadata predicates (age, size, content type, download source, etc.) to systematically manage filesystems. The architecture is a traditional Ruby gem with a Thor-based CLI (bin/maid), a central Maid::Maid class that orchestrates rule loading and execution, and a set of tool methods mixed into the Maid instance for use in rule blocks. It also supports daemon mode using Listen (file system watcher) and rufus-scheduler (timed repeats). The code is well-structured with modular components, extensive test coverage, and modern Ruby practices, though it carries some legacy from supporting older Ruby versions. There is no data research or analytic component; it is purely an application for file automation.
mpiFileUtils is a suite of MPI-based command-line tools for managing large datasets on parallel file systems (Lustre, DAOS, GPFS, NFS). It provides parallel equivalents of common file operations: dcp (copy), dsync (sync), drm (remove), dcmp (compare), dtar (archive), dfind (find), dchmod (chmod), dbcast (broadcast), ddup (dedup), and others. The tools are built atop a common library (libmfu) that implements a distributed file list (mfu_flist) with collective operations, path manipulation, I/O wrappers with retry logic, progress reporting, and work distribution via libcircle. The architecture follows a walk->filter->act pattern where the file system is traversed in parallel, metadata is aggregated into a distributed list, and work is distributed across MPI ranks. The tools are designed for high-throughput operations on millions of files and are used in HPC environments. While the codebase shows signs of legacy (dcp1, Python 2 tests), it is actively maintained and includes advanced features like DAOS object-level copy and tar indexing for parallel extraction. The repository is primarily an application (CLI tool suite) with a strong library component (libmfu) that could be reused in other HPC data-movement projects.