Uppy is a modular, client-side JavaScript file upload library with a companion server (Companion) for remote provider integrations. It provides a plugin-based architecture where core functionality (file selection, upload strategies, UI components) is encapsulated in reusable packages. The client-side library supports drag-and-drop, webcam/screen capture, image editing, thumbnail generation, and multiple upload backends (tus resumable, AWS S3 multipart, XHR, Transloadit). The Companion server handles OAuth flows, remote file listing/download from providers like Google Drive, Dropbox, Box, OneDrive, Facebook, Zoom, Unsplash, and WebDAV, as well as S3 presigning and Transloadit Storage integration. The repository is a monorepo with over 50 packages, including framework-specific wrappers for React, Vue, Svelte, and Angular, plus headless controllers for custom UI. Key entry points are @uppy/core (Uppy class, plugin system), @uppy/dashboard (main UI), @uppy/companion (Express server), and @uppy/aws-s3 (S3 upload client). Data flows: user selects files via UI plugins, which are then uploaded via configured uploader plugins; remote sources are fetched through Companion using OAuth tokens. External dependencies include tus-js-client, AWS SDK, Transloadit API, and various OAuth providers. The codebase is well-tested with unit, integration, and browser tests, and uses modern TypeScript, ESM, and Preact for UI.
nette/http is a standalone PHP library providing HTTP abstraction for request/response handling, URL manipulation, session management, and file uploads. It is part of the Nette Framework ecosystem but is usable independently. The library offers immutable `Request` and `UrlImmutable` objects for safe processing, alongside mutable `Response` and `Session` for stateful operations. It includes security-focused features such as input sanitization, CSRF protection via `Sec-Fetch-*` headers (with fallback), SSRF protection via `UrlValidator` and `IPAddress`, and a proxy trust model for client IP resolution behind reverse proxies. The codebase is well-structured, with clear separation of concerns, comprehensive test coverage (Nette Tester), and strict static analysis (PHPStan level 8). It requires PHP 8.3-8.5 and depends on `nette/utils`. The repository is actively maintained with recent commits, CI on multiple OSes, and an issue tracker.
ShareX is a comprehensive screenshot, image editing, and file sharing application for Windows. It features a modular architecture with separate libraries for screen capture, image editing, uploading, helpers, history, and tools. The application supports capturing screenshots/recordings, applying annotations and effects, uploading to over 50 services, and includes various productivity tools. Built with .NET/C# using a mix of Windows Forms and Avalonia UI frameworks, it employs MVVM patterns, plugin architectures for extensibility, and cross-cutting helper libraries. The system handles data flows from capture through editing to upload/storage, with history tracking for user convenience.
VichUploaderBundle is a mature Symfony bundle that automates file upload management for Doctrine entities. It listens to Doctrine lifecycle events to inject uploaded files into entities on load, upload them on persist, clean up replaced files on update, and remove files when entities are deleted. The bundle supports ORM, MongoDB ODM, and PHPCR ODM through adapter classes, and provides pluggable storage backends for local filesystem, Flysystem, and Gaufrette (legacy). Configured via attributes, YAML, XML, or a shared PHP mapping configuration, it exposes services for naming, directory organization, metadata reading, and property mapping resolution, plus console commands for debugging mappings and cleaning orphaned files. The architecture is a classic extensible library: a bundle facade registers compiler passes, a dependency injection extension wires services from configuration, and interfaces such as StorageInterface, NamerInterface, DirectoryNamerInterface, and MetadataReaderInterface define seams for customization. Core orchestration lives in UploadHandler and DownloadHandler, while PropertyMappingFactory resolves entity fields to storage and naming strategies. The bundle also ships Twig helpers for rendering asset URLs and form types (VichFileType, VichImageType) with delete/download options, a profiler data collector, a FileRequired validator, and translations in 20+ locales. The codebase is well-tested with unit, integration, and functional tests, and shows deliberate design in areas like immutable namer configuration, a chain directory namer, event cancellation, and clever file-extension guessing. It is actively maintained, follows modern PHP (^8.3) and Symfony (^6.4/^7.4/^8.0), and has clear deprecation paths for legacy features. A few areas such as Gaufrette storage and the older ConfigurableInterface are in maintenance mode, but the core remains current and trustworthy.
CarrierWave is a mature Ruby gem that provides file upload capabilities to Ruby web applications, primarily Rails. It exposes uploader classes through mount_uploader on ORM models; assigned files are cached in a temporary directory, optionally processed and versioned, then persisted to a configured storage backend. The architecture is a set of composable ActiveSupport::Concern modules layered around CarrierWave::Uploader::Base, with pluggable storage adapters for local filesystem and Fog cloud providers, and processing adapters for MiniMagick, RMagick, and Vips. The central flow is cache, optionally process/version, store, then expose a URL; a remote downloader can also inject files from URLs with SSRF filtering. Production behavior is backed by a large RSpec suite and Cucumber features. It supports single and multiple uploads, metadata columns, direct-to-cloud uploads, cache cleanup, and ActiveRecord callbacks including after_commit deletion and rollback handling. External dependencies are limited to ActiveSupport/ActiveModel, Marcel for MIME detection, ssrf_filter for download safety, and optional Fog/image processor gems. This is not a standalone application or service; it is embedded into host applications as a library dependency. Maintenance is active, with ongoing 4.0.0.rc development and a Rails version matrix. Technical drift is moderate: the codebase still supports Ruby 2.7, contains a permissive RuboCop configuration, legacy scripts, and several deprecation layers, but the core abstractions are current and extensively tested.
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.
jQuery File Upload is a mature, feature-rich jQuery plugin for handling file uploads in web browsers. It provides multiple file selection, drag & drop support, progress bars, client-side image resizing, preview functionality, and supports cross-domain, chunked, and resumable uploads. The architecture follows jQuery widget patterns with a modular plugin system that separates concerns into core functionality, processing pipelines, media handling, validation, UI components, and transport mechanisms. The code demonstrates sophisticated handling of browser inconsistencies and edge cases while maintaining a clean, extensible design.
The Dropbox SDK for JavaScript (dropbox-sdk-js) is a lightweight, promise-based client library that provides a programmatic interface to the Dropbox v2 API. It supports both Node.js and browser environments, with full OAuth 2.0/PKCE authentication, file upload and download with resumable and parallel streaming, exponential backoff retries, progress reporting, and content hash validation. The library is auto-generated from Dropbox's API specification (Stone) and exposes hundreds of endpoint methods covering files, sharing, team management, users, and more. It is designed for production use with robust error handling, rate-limit awareness, and environment-aware binary types. The codebase demonstrates strong architectural separation of concerns: authentication logic is encapsulated in `DropboxAuth`, file transfer logic in dedicated uploader/downloader classes, and API request routing in generated route definitions. The SDK is well-tested with unit, integration, and TypeScript type tests, and includes comprehensive examples for both browser and Node.js usage patterns.
This repository is a Next.js library for Cloudinary integration, providing React components and utility functions for image/video optimization, uploads, and transformations. The library includes components like CldImage (Next.js Image wrapper), CldVideoPlayer, CldUploadButton/Widget, and CldOgImage, along with URL generation helpers. It supports both Pages and App Router, handles responsive images, placeholders, and Cloudinary-specific features like AI transformations. The architecture is modular with clear separation between components, helpers, loaders, and configuration. The library is actively maintained with semantic-release, comprehensive tests, and broad Next.js/React version support.
The Parcle Python client is a library for interacting with the Parcle Memory API, which provides long-term memory for AI agents. It enables developers to store conversational data and files per user, and then retrieve relevant information through natural language queries that return synthesized answers with citations. The client handles all aspects of communication with the API, including authentication, request retries, file uploads, and processing of Server-Sent Events for search operations. The architecture is straightforward: a synchronous HTTP client built on top of `httpx`, with methods corresponding to each API endpoint. Key features include robust error handling via a well-defined exception hierarchy, automatic retry logic for transient failures, and flexible file upload support that accepts various input types while enforcing size limits. The search method uniquely handles SSE streams to deliver incremental responses, ensuring compatibility with the API's streaming behavior. While the library is purpose-built for the Parcle API, it exhibits several reusable patterns. The exception mapping system in `exceptions.py` can be adapted for any HTTP API, and the file upload handling functions in `client.py` demonstrate a robust approach to processing diverse file inputs. The codebase is actively maintained, has low technical debt, and includes comprehensive tests that mock HTTP interactions to ensure reliability.
This repository is a Spring Guide tutorial demonstrating how to build a Spring Boot web application that accepts HTTP multipart file uploads. It contains four project variants: initial and complete versions in both Java and Kotlin, each with Maven and Gradle build files. The complete version adds a FileUploadController with endpoints for listing uploaded files, serving them as downloads, and handling uploads, plus a StorageService abstraction backed by a FileSystemStorageService that writes files to a configurable local directory (default 'upload-dir'). A Thymeleaf template provides a simple HTML upload form. The application is a small monolith: Spring MVC controllers handle GET / (list files), POST / (store uploaded file), and GET /files/{filename} (download with Content-Disposition). The storage layer uses java.nio.file APIs and includes a path traversal protection check that rejects filenames escaping the root directory. Upload size limits are configured via spring.servlet.multipart properties. Tests cover controller behavior with MockMvc, storage service security cases, and full integration tests using RestTestClient with redirect handling. This is educational sample code, not a production service. It demonstrates clean separation between web layer and storage abstraction, and the complete version includes meaningful security and testing patterns that can be reused in real projects. The code is actively maintained, uses current Spring Boot 4.0.x and Java 17, and is well-suited as a reference for implementing file upload endpoints.
ng2-file-upload is an Angular library providing drag-and-drop and file selection directives for file upload. It consists of two directives (ng2FileSelect and ng2FileDrop) and a core FileUploader class that manages a queue of FileItems, handles XHR uploads with multipart or streaming (disableMultipart), and offers filter-based validation (file size, mime type, file type, queue limit). The demo application showcases standard usage with a remote API. The library is actively maintained with support for Angular 21, but its code style predates modern standalone components and uses legacy Angular patterns (non-standalone directives, manual DI via inject()). Tooling uses Nx 22, Jest, and ng-packagr. While functional and battle-tested (1899 stars), the codebase shows medium technical drift due to reliance on deprecated Angular patterns and a monolithic FileUploader class.
This is a Preact single-page application that provides a user interface for uploading files to a backend API (DirectLink) that returns direct download links. The frontend handles file selection via drag-and-drop or file input, uploads with progress tracking, and maintains a history of uploaded files stored in localStorage. It uses valtio for reactive state management, Material UI and styled-components for styling, and axios for HTTP requests with retry logic. The application is cleanly structured with reusable custom hooks (useUnmountEffect, useProxyState) and a portal-based dialog system (DialogContainer). The backend is a separate binary not included in this repository. The codebase demonstrates modern frontend engineering with good separation of concerns and moderate complexity.
This repository is a simple Content Management System (CMS) built on the CodeIgniter 3.x PHP framework. It provides basic CRUD operations for news articles organized by channels, user authentication (login/registration), and file uploads via the deprecated Uploadify library. The system includes a REST API for news and authentication, and integrates CKEditor for rich text editing. However, the codebase is severely outdated, relying on deprecated PHP extensions (mysql_, mcrypt), an unmaintained framework version, and obsolete frontend libraries. There are no tests, no modern security practices, and the architecture is a straightforward monolithic MVC with tightly coupled components. It offers limited reuse potential and should be considered a legacy application requiring significant modernization.