QuickShare

QuickShare is a lightweight, self‑hosted file transfer service that exposes a modern web UI for uploading, downloading, and managing files across multiple devices. Built in Go (≥1.17) with a Vue.js front‑end, it runs as a single binary that can be deployed in Docker or executed directly. At its core, QuickShare implements a REST‑like API for file operations while providing a rich browser experience with drag‑and‑drop, resumable transfers, and QR‑code sharing. The service is designed for small to medium teams or personal use cases where a private, GDPR‑friendly file server is preferred over cloud providers.

Technical Stack

• Backend: Go (standard library + Gorilla Mux for routing, net/http for streaming). The server exposes endpoints for CRUD operations on files and directories, user authentication, quota enforcement, and speed limiting. It leverages Go’s io.Pipe and context cancellation for efficient streaming uploads/downloads.
• Front‑end: Vue.js (3.x) with Vite for bundling. The UI is a single‑page application that consumes the backend API via Axios, using WebSockets for real‑time progress updates during large uploads.
• Storage: Native file system. All user data is stored under a configurable root directory (e.g., /quickshare/root). No external database is required; user metadata and settings are persisted in JSON files (users.json, config.yaml), making the deployment footprint minimal.
• Containerization: Official Docker image (hexxa/quickshare) is built on Alpine Linux, exposing port 8686. The image supports environment variables (DEFAULTADMIN, DEFAULTADMINPWD) for initial user creation and mounts a host directory for persistent storage.

Core Capabilities

• File Operations: Upload (single/multiple), download, delete, move, and rename files/folders via REST endpoints. Supports resumable uploads/downloads using HTTP range requests and chunked transfer encoding.
• Search & Streaming: Fuzzy search across the file tree with instant results; streaming uploads allow clients behind CDNs or reverse proxies to continue sending data without re‑establishing connections.
• User & Permission Model: Role‑based access (user/admin), per‑user home directories, and configurable limits on upload/download speed and storage quota.
• Sharing: Generate public URLs for directories, including anonymous access. QR code generation is available server‑side and can be consumed by any mobile client to open shared folders directly.
• OS Integration: The quickshare CLI can mount the storage directory as a local folder via FUSE (Linux/macOS) or use sftp/scp for remote management.

Deployment & Infrastructure

QuickShare is intentionally lightweight, making it ideal for edge devices, home routers, or small‑scale cloud instances. Its single binary and filesystem storage eliminate the need for a database server, reducing operational overhead. Docker Compose or Kubernetes deployments are straightforward; the container can be scaled horizontally behind a load balancer, with each instance pointing to a shared NFS or S3‑compatible object store if high availability is required. The service includes built‑in rate limiting and quota enforcement, which can be tuned via environment variables or a simple config file.

Integration & Extensibility

While QuickShare ships with a fully functional UI, developers can consume its API directly from custom clients. The JSON‑based endpoints are documented in the repository’s docs/doc.md. Webhooks can be triggered on file events (upload, delete) by exposing a simple callback URL. For advanced workflows, the CLI exposes hooks for pre‑ and post‑processing scripts, allowing integration with CI/CD pipelines or automated backup solutions. The modular design of the Go codebase makes it straightforward to add new authentication backends (OAuth, LDAP) or extend storage adapters.

Developer Experience

The project follows idiomatic Go practices and includes a comprehensive Go Report Card badge, indicating high code quality. Documentation is split between the README (quick start) and detailed API docs (docs/doc.md). The community is active on GitHub Issues, with frequent CI checks via GitHub Actions. Configuration is minimal—environment variables and a single YAML file control most aspects, enabling quick experimentation without deep configuration.

Use Cases

• Personal File Server: Individuals who want a private, GDPR‑compliant way to share files between devices without relying on third‑party cloud services.
• Team Collaboration: Small teams that need a lightweight internal file repository with fine‑grained quota and speed controls.
• IoT & Edge Deployments: Devices that generate logs or media (e.g., security cameras) can stream data to a local QuickShare instance for easy retrieval.
• Educational Labs: Instructors can provide students with a shared folder that supports resumable uploads, useful for large assignment submissions.

Advantages

• Zero‑DB Footprint: Eliminates database maintenance, reducing attack surface and simplifying backups.
• High Performance: Go’s native concurrency and streaming APIs deliver low latency, even for large files.
• Flexibility & Licensing: MIT‑licensed, allowing unrestricted modification and redistribution in commercial or open‑source projects.
• Cross‑Platform: Runs on Linux, macOS, and Windows with the same binary; Docker images are available for all platforms.
• Community & CI: Continuous integration with Docker, binaries, and Go vetting ensures that new releases are stable and production‑ready.

QuickShare’s blend of minimalism,