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.
ProjectSend is a self-hosted, multi-user file sharing application with a client portal. Staff upload files into folders, assign them to clients or groups, and govern access through download limits, expiry dates, share links, and ClamAV virus scanning. Clients get a themed portal for browsing, downloading, previewing, and commenting on files, while anonymous users can reach public listings and token-based share links. The system also provides file versioning, chunked resumable uploads, zip batch downloads, thumbnails, quarantine handling, comprehensive audit logging, notification digests, and GDPR account erasure workflows.
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.
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.
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.
VichUploaderBundle is a Symfony bundle for attaching uploaded files to Doctrine-managed entities (ORM, MongoDB ODM, PHPCR). In production, it listens to Doctrine lifecycle events, pulls UploadedFile objects from form-bound properties, runs them through configurable namers, stores them via pluggable storage backends (local filesystem, Flysystem, Gaufrette), and keeps file metadata in sync on the entity/embeddable. It also provides the vich_uploader_asset Twig function, VichFileType/VichImageType form widgets, and console commands for mapping introspection and orphaned-file cleanup. The core data flow is: HTTP upload -> form type -> UploadHandler -> namer -> storage -> Doctrine listener metadata -> Twig URL resolution. The bundle is interface-driven: StorageInterface, NamerInterface, DirectoryNamerInterface, MetadataReaderInterface, and AdapterInterface let integrators swap implementations. It is a library, not an application or data-research repo; the only data-like artifact is the cleanup command that reconciles stored files against database references. It remains actively maintained with support for modern Symfony (6.4-8.0) and PHP 8.3, though it still carries legacy Gaufrette support and a deprecated ConfigurableInterface for backward compatibility.
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 the official Dropbox Python SDK (v2), providing a comprehensive, typed client for the Dropbox REST API. The core functionality is defined in `dropbox/dropbox_client.py` (concrete client) and `dropbox/base.py` (auto-generated abstract base for all API routes). The SDK includes full OAuth2 support (`dropbox/oauth.py`), robust file upload/download helpers with progress tracking and retry logic (`dropbox/file_transfer.py`), a content hash algorithm for file integrity verification (`dropbox/content_hash.py`), SSL-pinned HTTP sessions (`dropbox/session.py`), and a well-structured exception hierarchy (`dropbox/exceptions.py`). The bulk of the codebase (API data types, route definitions) is auto-generated by the Stone framework from the Dropbox API spec, ensuring consistency with the server endpoints. The repository includes examples for backup/restore, OAuth flows, and file transfer, making it a practical resource for integrating with Dropbox.
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.
FileRise is a self-hosted web file manager and storage hub with WebDAV, sharing, and per-folder ACLs. The backend is PHP 8.3+ with Apache, using flat-file storage (no database) and a REST API. The frontend is a modular vanilla JS SPA with i18n, dark mode, and drag-and-drop. It supports multi-source storage (local, S3, SFTP, WebDAV, etc.), encryption at rest (libsodium), TOTP 2FA, OIDC SSO, and background workers for transfers and ZIP creation. A commercial Pro add-on provides AI chat, client portals, automation, and advanced storage sources. The codebase is actively maintained with frequent releases and a comprehensive security regression test suite. While the architecture is clean with well-defined interfaces (storage adapter, ACL, encryption), there is some legacy debt from a namespace migration and monolithic domain models.
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.
This repository is the official collection of runnable examples for the Gin HTTP web framework for Go. It is not a single application or library, but a set of ~40 independent Go programs, each demonstrating a specific Gin feature or integration: basic routing, route grouping, request binding, custom validation, cookies, CORS, reverse/forward proxies, TLS and HTTP/2, automatic TLS, server-sent events, WebSockets, gRPC bridging, graceful shutdown, file uploads, OIDC login, OpenTelemetry, New Relic, and App Engine deployment. Most examples are compact self-contained main packages; some have their own go.mod/README while others share the root module.
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.