Memos is a lightweight, self-hosted note-taking application built for developers, writers, and self-hosters who want to capture thoughts instantly without the clutter of folders or proprietary formats. It prioritizes total data ownership by storing notes in plain Markdown files and running entirely on your infrastructure with no tracking or cloud dependency. Built with Go and React, it offers a timeline-first UI that eliminates navigation overhead and focuses on rapid input.
Memos deploys in minutes via Docker, native binaries, or Kubernetes, using SQLite, MySQL, or PostgreSQL as backends. Its MIT license and open development model ensure transparency and community-driven evolution. With a ~20MB Docker image and no paid tiers, it’s designed for minimal overhead and maximum control over personal data.
What You Get
- Instant Capture - Timeline-first UI lets you open the app, type a note, and hit enter—no folders, templates, or menus to navigate. Ideal for quick thoughts, ideas, or logs.
- Total Data Ownership - All notes are stored as plain Markdown files on your server. No telemetry, no cloud dependency, and no vendor lock-in—your data is yours to back up, move, or delete.
- Markdown-Native - Notes are written and stored in standard Markdown, ensuring long-term readability and compatibility with any text editor or tool that supports Markdown.
- Runs Anywhere - Deployable via a ~20MB Docker image, native binaries for Linux/macOS/Windows, or Kubernetes. Runs on a Raspberry Pi or a cloud VPS with one command.
- Open & Extensible APIs - Full REST and gRPC APIs allow integration with custom tools, automation scripts, or third-party apps for data export or synchronization.
- Private by Default - Notes are not shared or indexed publicly. Access is controlled via local authentication, ensuring your thoughts remain confidential and secure.
Common Use Cases
- Developers logging code snippets - A developer uses Memos to capture debugging logs, API responses, or code fragments directly from their terminal, storing them in plain Markdown for later reference.
- Self-hosters managing infrastructure docs - A sysadmin maintains server configs, deployment steps, and network diagrams in Memos, keeping them private and accessible without relying on SaaS tools.
- Writers capturing daily ideas - A novelist or journalist uses Memos to jot down story ideas, quotes, or observations in Markdown, with full control over storage and no risk of platform shutdowns.
- Family sharing private memories - A family uses Memos to record shared moments, travel logs, or milestone notes on a home server, ensuring their memories are never owned by a third party.
Under The Hood
Architecture
- Clear separation of concerns with distinct layers for API handlers, services, and data access, enforced via domain-specific repositories and interface-based design
- Dependency injection through constructor-based patterns enhances testability and reduces coupling between components
- Event-driven real-time updates implemented via Server-Sent Events with decoupled publishers and subscribers
- Modular directory structure isolates concerns across API, service, storage, and domain packages, promoting maintainability
Tech Stack
- Go 1.21+ backend leveraging standard HTTP server and custom middleware for routing and request processing
- SQLite as the primary embedded database, managed with sqlx and go-sqlite3 for robust query execution and migrations
- golangci-lint with multiple linters enforcing strict code quality, including resource cleanup and deprecated package bans
- Next.js 14 frontend with App Router and TypeScript, tightly integrated with backend APIs for server-rendered UI
- Docker-based containerization and Go modules for consistent build and deployment workflows
Code Quality
- Extensive test coverage with table-driven unit and integration tests using testify for expressive assertions
- Robust error handling with graceful degradation for malformed inputs and database failures, avoiding panics
- Consistent, domain-aligned naming conventions and explicit struct definitions ensure clarity and type safety
- Comprehensive linting and multi-database test support ensure reliability across environments
What Makes It Unique
- Native protobuf-based API design aligned with Google AIPs enables type-safe, scalable service contracts across frontend and backend
- Focus mode overlay dynamically alters UI state without full re-renders, creating an immersive writing experience
- MemoViewContext deeply integrates protobuf types and real-time relationship tracking, eliminating external state libraries
- ChunkLoadErrorFallback and ErrorBoundary provide seamless recovery from code-splitting failures during deployments
- Built-in blur functionality for sensitive content offers context-aware visibility control without plugins