Preview | Official Site & Documentation | Ech0 Hub

Ech0

A self-hosted personal microblog where your timeline can be shared, discussed, and fully owned.

Tools like Memos are great for capturing quick thoughts. Ech0 is built for what comes next: publishing those ideas to a personal timeline that others can follow and interact with. Run it on your own server, keep full control of your content, and keep a personal space that still feels connected through optional comments and sharing. It stays lightweight, easy to deploy, and fully open-source.

Great fit if you want to:

• run a personal public or semi-public timeline on your own domain
• publish short posts, links, and media from one clean interface
• keep data ownership while still getting RSS and optional comments
• keep a personal space that supports lightweight social interaction without becoming a full social network

Probably not for you if you need:

• a bi-directional knowledge base workflow (for example Obsidian-style PKM)
• a team-first collaborative docs workspace (for example Notion-style docs)
• a private-only memo app with no publishing or timeline focus

docker run -d \
  --name ech0 \
  -p 6277:6277 \
  -v /opt/ech0/data:/app/data \
  -e JWT_SECRET="Hello Echos" \
  sn0wl1n/ech0:latest

Then open http://ip:6277:

1. Register your first account.
2. The first account becomes Owner (admin privileges).
3. By default, publishing is restricted to privileged accounts.

See Quick Deployment for Docker Compose and Helm options.

• 📝 Built for personal publishing: Timeline-first microblog flow for thoughts, links, and short writing.
• 🤝 Lightweight social by design: Posts can be shared and discussed through optional comments and interactions.
• 🧘 Clean reading experience: Zen-like timeline browsing with minimal distraction.
• ⚡ Markdown and media in one place: Markdown editor, rich cards, and embedded video support.
• 🔒 Personal first with full ownership: Best as a personal instance with optional multi-user roles, while staying self-hosted, RSS-ready, and AGPL-3.0 open-source.

docker run -d \
  --name ech0 \
  -p 6277:6277 \
  -v /opt/ech0/data:/app/data \
  -e JWT_SECRET="Hello Echos" \
  sn0wl1n/ech0:latest

💡 After deployment, access ip:6277
🚷 For better security, replace Hello Echos in -e JWT_SECRET="Hello Echos" with your own secret
📍 The first registered account becomes administrator (currently only admins can publish)
🎈 Data is stored under /opt/ech0/data

Create a new directory and place your docker-compose.yml file there.

Run the following command in that directory:

docker-compose up -d

If you want to deploy Ech0 in a Kubernetes cluster, you can use the Helm Chart provided by this project.

Since this project does not currently provide an online Helm repository, you need to clone the repository locally and install from the local directory.

1. Clone the repository:

   git clone https://github.com/lin-snow/Ech0.git
   cd Ech0

2. Install with Helm:

   # helm install <release-name> <chart-directory>
   helm install ech0 ./charts/ech0

   You can also customize the release name and namespace:

   helm install my-ech0 ./charts/ech0 --namespace my-namespace --create-namespace

⚠️ Direct upgrade from v3 to v4 is not supported. Please export a snapshot in the v3 panel first, redeploy v4, then use "v3 Migration" in the v4 panel to import your existing data.

# Stop current container
docker stop ech0

# Remove container
docker rm ech0

# Pull latest image
docker pull sn0wl1n/ech0:latest

# Start new version
docker run -d \
  --name ech0 \
  -p 6277:6277 \
  -v /opt/ech0/data:/app/data \
  -e JWT_SECRET="Hello Echos" \
  sn0wl1n/ech0:latest

# Enter compose directory
cd /path/to/compose

# Pull latest image and recreate
docker-compose pull && \
docker-compose up -d --force-recreate

# Clean old images
docker image prune -f

1. Update repository: Enter your local Ech0 repository and pull latest changes.

   cd Ech0
   git pull

2. Upgrade Helm release: Use helm upgrade to update your release.

   # helm upgrade <release-name> <chart-directory>
   helm upgrade ech0 ./charts/ech0

   If you used a custom release name and namespace, use matching values:

   helm upgrade my-ech0 ./charts/ech0 --namespace my-namespace

1. What is Ech0?
   Ech0 is a lightweight open-source self-hosted platform designed for quickly publishing and sharing personal thoughts, writing, and links. It provides a clean interface and distraction-free experience, with your data remaining under your control.

2. What is Ech0 not?
   Ech0 is not a traditional professional note-taking app (such as Obsidian or Notion). Its core usage is closer to a social feed / microblog stream.

3. Is Ech0 free?
   Yes. Ech0 is fully free and open source under AGPL-3.0, with no ads, tracking, subscriptions, or service lock-in.

4. How do I back up and import data?
   Ech0 supports data recovery/migration through "Snapshot Export" and "Migration Import". At deployment level, regularly back up your mapped data directory (for example /opt/ech0/data). By default, core data is stored in the local database; if object storage is enabled, media assets are written to the configured storage backend.

5. Does Ech0 support RSS?
   Yes. Ech0 supports RSS subscriptions so you can follow updates in RSS readers.

6. Why does publishing fail with "contact administrator"?
   Publishing is restricted to privileged accounts by default. During initialization, the first account becomes Owner (with management privileges). Regular users cannot publish until explicitly granted permission by a privileged account. If this is your first setup, review Try in 60 Seconds and confirm which account is Owner.

7. Why is there no detailed permission matrix?
   Ech0 currently uses a lightweight role model (Owner / Admin / regular user) to keep operation simple and predictable. The permission model will continue to evolve based on community feedback.

8. Why can't others see their Connect avatar?
   Set your current instance URL in System Settings - Service URL, for example https://memo.vaaat.com (must include http:// or https://).

9. What is the MetingAPI option in settings?
   It is the API endpoint used by music cards to resolve playable stream metadata. You can provide your own trusted endpoint; when left empty, Ech0 falls back to a default resolver endpoint. For production, a self-controlled endpoint is recommended.

10. Why does a newly added Connect show only partial results?
    The backend tries to fetch instance information for all Connect entries. If an instance is down or unreachable, it is discarded, and only valid/accessible Connect data is returned to the frontend.

11. How do I enable comments?
    Enable comments in the panel comment manager, then configure moderation and captcha toggles as needed. Ech0 now embeds gocap for captcha verification, so no standalone captcha service deployment is required.

12. How do I configure S3 storage?
    Fill in provider, endpoint, bucket, access key, secret key, and related fields in storage settings. It is recommended to provide endpoint without http:// or https://. If media is accessed directly by browsers, ensure objects are readable through your chosen policy (for example public-read or equivalent CDN/gateway setup).

13. How do I enable passkey login?
    In SSO - Passkey, configure WebAuthn RP ID and WebAuthn Origins. After saving and seeing "Passkey ready", follow browser prompts to bind biometrics or a security key.

• If you encounter bugs, report them in Issues.
• For feature ideas or improvements, join discussions in Discussions.
• Official QQ Group: 1065435773

Official QQ Community	Other Groups
	N/A

• Contribution Guide
• Code of Conduct
• Security Policy
• License

• The backend event bus has switched to Busen: it uses a typed-first in-process architecture, and improves stability through explicit backpressure, hooks, and drain shutdown.

📌 Go 1.26.0+

📌 C Compiler When using CGO-dependent libraries such as go-sqlite3, install:

• Windows:
  • MinGW-w64
  • Add the bin directory to PATH after extraction
• macOS: brew install gcc
• Linux: sudo apt install build-essential

📌 Google Wire Install wire for dependency injection file generation:

• go install github.com/google/wire/cmd/wire@latest

📌 Golangci-Lint Install Golangci-Lint for linting and formatting:

• Run golangci-lint run in the project root for linting
• Run golangci-lint fmt in the project root for formatting

📌 Air (Optional, Backend Hot Reload)

• Recommended via Makefile: make air-install
• Or install manually: go install github.com/air-verse/air@latest

📌 Swagger Install Swagger to generate/use OpenAPI docs:

• Run swag init -g internal/server/server.go -o internal/swagger in project root to generate or update Swagger docs
• Visit http://localhost:6277/swagger/index.html in your browser to view and use docs

📌 Event Runtime Parameters (Busen)

• ECH0_EVENT_DEFAULT_BUFFER / ECH0_EVENT_DEFAULT_OVERFLOW
• ECH0_EVENT_DEADLETTER_BUFFER / ECH0_EVENT_SYSTEM_BUFFER
• ECH0_EVENT_AGENT_BUFFER / ECH0_EVENT_AGENT_PARALLELISM
• ECH0_EVENT_INBOX_BUFFER
• ECH0_EVENT_WEBHOOK_POOL_WORKERS / ECH0_EVENT_WEBHOOK_POOL_QUEUE

📌 NodeJS v25.5.0+, PNPM v10.30.0+

Note: if you need multiple Node.js versions, use fnm to manage them.

Step 1: Backend (in Ech0 root directory)

make run # normal backend start (equivalent to go run main.go serve)
make dev # backend hot reload with Air

If dependency injection relationships change, run wire first in ech0/internal/di/ to regenerate wire_gen.go.

Step 2: Frontend (new terminal)

cd web # enter frontend directory

pnpm install # run if dependencies are not installed

pnpm dev # start frontend preview
# or run from project root: make web-dev

Step 3: After both are running Frontend preview: http://localhost:5173 (actual port shown in terminal after start)
Backend preview: http://localhost:6277 (default backend port is 6277)

When importing packages in a layered architecture, use standardized alias names:
model layer: xxxModel
util layer: xxxUtil
handler layer: xxxHandler
service layer: xxxService
repository layer: xxxRepository

Thanks to everyone who has supported this project! Your support keeps Ech0 moving forward 💡✨

• Thanks to all users for suggestions and feedback.
• Thanks to all contributors and supporters in the open-source community.

🌟 If you like Ech0, please give this project a Star! 🚀

Ech0 is fully open-source and free. Ongoing maintenance and improvements rely on community support. If this project helps you, sponsorship is always appreciated. You can donate via the QR code and leave your GitHub name in the note; your contribution will be displayed publicly on the README.md homepage.

Platform	QR Code
Afdian

███████╗     ██████╗    ██╗  ██╗     ██████╗
██╔════╝    ██╔════╝    ██║  ██║    ██╔═████╗
█████╗      ██║         ███████║    ██║██╔██║
██╔══╝      ██║         ██╔══██║    ████╔╝██║
███████╗    ╚██████╗    ██║  ██║    ╚██████╔╝
╚══════╝     ╚═════╝    ╚═╝  ╚═╝     ╚═════╝