Cryptgeon is a secure, self-hostable platform for sharing encrypted notes and files that vanish after being viewed or after a set time. Designed for privacy-conscious users, it eliminates server-side access to content by performing all encryption and decryption in the browser or CLI client. The service is ideal for developers, journalists, and teams needing to share sensitive information without trusting the server.
Built with Rust for the backend and Svelte for the frontend, Cryptgeon uses AES-256-GCM encryption on the client side and stores data exclusively in Redis memory with no disk persistence. It supports deployment via Docker, NGINX, Traefik, Synology, or bare metal, and includes a CLI client and Raycast extension for seamless integration into developer workflows.
What You Get
- Client-Side AES-256-GCM Encryption - All notes and files are encrypted in the browser or CLI before being sent to the server; the server never receives the encryption key and cannot decrypt content.
- Self-Destructing Notes - Notes automatically expire after a set number of views or a time limit (configurable up to 360 minutes), ensuring temporary, traceless sharing.
- In-Memory Storage Only - Data is stored exclusively in Redis with no disk persistence, eliminating risk of data leaks from file system breaches.
- File and Text Sharing - Supports both plain text notes and file uploads up to 512 MiB, with frontend warnings for encoding overhead.
- CLI and Raycast Integration - Send encrypted notes via command line using
npx cryptgeon send text "..." or through the official Raycast extension for quick access from macOS.
- Configurable Limits and Themes - Customize max views, expiration time, file upload limits, logo, favicon, and imprint page via environment variables for private deployments.
Common Use Cases
- Sharing sensitive API keys or passwords - A developer uses Cryptgeon to send a one-time encrypted note containing credentials to a colleague, ensuring no trace remains on the server after viewing.
- Securely sending confidential documents - A journalist shares an encrypted PDF leak with a source using Cryptgeon’s file upload feature, knowing the file self-destructs after one view.
- Running a private internal knowledge base - A startup deploys Cryptgeon on their internal network to share temporary team notes that auto-delete after 24 hours, avoiding data hoarding.
- Quick secure note sharing from terminal - A sysadmin uses the CLI tool to send an encrypted command output or log snippet to a teammate without leaving traces on shared servers.
Under The Hood
Architecture
- Modular monorepo structure cleanly separates backend, frontend, and CLI components with dedicated dependencies and build pipelines
- Backend employs a plugin-style adapter pattern to abstract encryption and persistence logic, enabling extensibility without tight coupling
- Dependency injection is achieved through runtime adapter selection based on payload type, promoting loose coupling and testability
- Frontend uses a component-based SvelteKit architecture with static generation, isolating UI state from cryptographic operations via workspace-linked packages
- RESTful API endpoints follow metadata-first patterns with explicit contracts validated through tooling
- Docker and pnpm ensure consistent, isolated environments across services for scalable development and deployment
Tech Stack
- Node.js 22-alpine powers the frontend with modern Svelte and Vite tooling, compiled to static assets via SvelteKit
- Backend is built in Rust with Alpine Linux, leveraging system libraries for cryptographic operations with release optimizations
- Redis runs in-memory with tmpfs to enforce RAM-only storage, enhancing both performance and security
- Playwright enables comprehensive end-to-end testing across major browsers with parallel execution
- Docker multi-stage builds produce a minimal Alpine runtime image with reduced attack surface and explicit port exposure
- API interactions are defined and validated via Postman, ensuring consistent JSON responses with compression
Code Quality
- Extensive test coverage spans CLI, web, and cross-platform workflows with reusable utilities for validation and file operations
- Clear separation of concerns in test code promotes DRY principles and maintainability across domains
- Robust error handling and custom assertions ensure graceful degradation for invalid inputs and edge cases
- Consistent naming and TypeScript interfaces enhance type safety and IDE support, reducing runtime failures
- Comprehensive integration tests validate bidirectional flows between CLI and web interfaces, reflecting real-world usage
- Clean, modular test structure implies a mature development workflow with implicit linting and code standards
What Makes It Unique
- End-to-end encryption is handled entirely in-browser using a custom AES implementation, eliminating server-side key exposure
- A unified adapter interface enables seamless encryption of text, files, and blobs with identical user experience
- Dynamic theme and configuration injection from server metadata allows branding and feature toggling without code changes
- Client-side payload size enforcement provides real-time feedback to prevent server overload
- Reactive Svelte stores tightly couple UI state to user actions, minimizing boilerplate while maintaining performance
- Zero-dependency encryption core (occulto) minimizes attack surface, contrasting sharply with bloated crypto libraries in competing tools