Slink

Slink is a self‑hosted image sharing platform that lets developers deploy a fully functional, privacy‑first media server without relying on third‑party cloud services. Built with Symfony (PHP) for the backend and SvelteKit for a reactive, single‑page frontend, it exposes a rich set of APIs and hooks that enable programmatic access to uploads, tagging, analytics, and storage management. The architecture is deliberately modular: the core Symfony services handle authentication, file handling, and business logic while SvelteKit consumes a JSON‑only API, enabling easy replacement of the UI or integration into existing frontends.

• Multi‑format image support (PNG, JPG, WEBP, SVG, BMP, ICO, GIF, AVIF, HEIC, TIFF) with automatic transcoding and validation.
• Concurrent multi‑file uploads with per‑file progress, retry logic, and server‑side deduplication based on hash comparison.
• Hierarchical tag system that supports nested tags, full‑text search, and bulk operations via API.
• Flexible storage backends: local disk, SMB/CIFS shares, and AWS S3 are all first‑class options; the storage layer is abstracted through Symfony’s Filesystem component.
• Public and private galleries with customizable share links that can enforce size limits or expiration dates.
• Role‑based access control and optional user approval workflows for moderated uploads.

• Programmatic Uploads: POST /api/images accepts multipart form data; returns image metadata and public URL.
• Tag Management: CRUD endpoints for tags, including bulk association/dissociation.
• Analytics API: Endpoints expose per‑user storage usage, upload counts, and access logs.
• Webhooks: Configurable outbound events (e.g., image.uploaded, user.approved) that can trigger CI/CD pipelines or external services.
• CLI Tools: Symfony console commands for user management, cleanup of orphaned files, and cache purging.

Slink ships with Docker images for both the web server and database, making it trivial to spin up a production instance:

• Self‑hosting: Requires PHP 8.1+, Node.js (for SvelteKit build), and a relational database.
• Scalability: The stateless API layer can be horizontally scaled behind a load balancer; file storage is externalized, so multiple instances can share the same backend.
• High Availability: The storage layer’s abstraction allows swapping to a distributed file system (e.g., MinIO) without code changes.
• CI/CD Friendly: The Dockerfile is minimal and supports multi‑stage builds; CI pipelines can publish new images to registries automatically.

• Plugin System: Custom Symfony bundles can hook into events (e.g., image.preUpload, user.postLogin) to extend functionality.
• API Hooks: Developers can consume the public API from any language; the OpenAPI spec is auto‑generated.
• Custom Storage Providers: Adding a new provider involves implementing the FilesystemInterface; existing code remains untouched.
• Theming: SvelteKit’s component architecture allows swapping themes or integrating with existing CSS frameworks.

• Configuration: All settings are exposed via environment variables; the docs provide a comprehensive reference for each variable.
• Documentation: The official site hosts detailed guides, API references, and a “Getting Started” tutorial that covers both Docker and manual setups.
• Community: Active issue tracker, pull‑request guidelines, and a Slack/Discord channel for quick support.
• Licensing: MIT license encourages internal use and commercial deployment without licensing fees.

• Team Collaboration: Internal design teams can host a shared gallery with role‑based permissions and audit logs.
• Developer Portfolios: Embed Slink in personal blogs or GitHub READMEs to host screenshots and diagrams.
• Educational Platforms: Institutions can provide a private image repository for student projects, leveraging the deduplication feature to save storage.
• Automated CI Artifacts: Use webhooks to publish build screenshots or test coverage images directly to Slink for easy sharing with stakeholders.

• Performance: Symfony’s HTTP cache and SvelteKit’s SSR reduce latency; the storage abstraction allows using SSDs or high‑throughput object stores.
• Flexibility: The modular