# EiBlog: a Go blog engine with six storage backends and a Typecho admin panel

> EiBlog is a Go blog system whose v3 line keeps the feature set deliberately small, with a Typecho admin panel embedded for writing, GORM across six database backends, Elasticsearch for search, and Qiniu for attachments and backups. The README is candid that deployment is easy and going live is the hard part, and it warns against installing it without some computer knowledge.

**eiblog/eiblog** — a fast blog system in golang

- Repository: https://github.com/eiblog/eiblog
- Website: https://deepzz.com
- Stars: 691 · Forks: 158
- Language: Go
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/eiblog-eiblog

## A blog that refuses to grow features

The project's origin story is a sentence: the author used other blog systems, did not like them, found them not light enough and not fast enough, and built a second one. The positioning of EiBlog is stated as a fairly stable blog system that the author has used for years, and the 3.0 version is the current one, with a v2 branch kept for people still on it. What follows is the constraint that defines the project. On the principle that a blog exists to share knowledge, EiBlog will not have strong customisation features, including themes and CDN support, and it keeps only the common simple pages and functions: home, topics, archive, links, about and search. That is a deliberate ceiling rather than a gap in the work, and it is the reason the remaining features are tuned. The project is MIT licensed, the primary language is Go, the default branch is v3, and the homepage of the running instance is deepzz.com.

## Three ways to run it, and a warning about going live

The README calls out that the system is simple to deploy and complex to put online, in parentheses, and says it is not recommended for people without computer knowledge. That framing matters more than usual for a self-hosted blog, because the interesting work is the certificate chain, the reverse proxy and the CDN, not the install. Three routes are documented. The binary route is to download the archive for your system from the releases page, unzip it, and start the service with ./backend. The Docker route publishes three images: the blog service at deepzz0/eiblog, the blog search at deepzz0/elasticsearch and the data backup at deepzz0/backup, and the blog image alone runs like this:

```bash
$ docker run --name eiblog \
    -p 9000:9000 \
    deepzz0/eiblog:latest
```

The Compose route references a docker-compose.yml in the project root, asks you to adjust the configuration, and then runs docker-compose up -d. Afterward you visit localhost:9000, and the admin is at localhost:9000/admin/login with the default account deepzz/deepzz. Those defaults are published in the README, so change them before the blog is reachable by anyone else.

## Six database backends through GORM

The storage layer is the part of the project with the most visible engineering, and the README tabulates the supported drivers with a source example for each. MongoDB uses the mongodb scheme against a local port, MySQL uses a user and password with a tcp host and utf8mb4 charset plus parseTime and loc parameters, PostgreSQL uses a key-value style host, port, user, password and dbname string with sslmode disabled, SQLite is a plain file path, SQL Server uses a sqlserver scheme, and ClickHouse uses a tcp source with database, username, password and read and write timeouts. The go.mod file confirms this is a first-class arrangement rather than an aspiration: gorm.io/gorm is the ORM, and there is a separate driver module for each of clickhouse, mysql, postgres, sqlite and sqlserver, plus the official MongoDB driver. The practical consequence is that the storage choice is a configuration decision made at deploy time, and switching to a different backend does not mean rewriting the application.

## Search needs a second service you have to start yourself

Site search is built on Elasticsearch, and the README adds the Google OpenSearch option on top of it. The catch is in the note under the Docker instructions: by default the blog search, elasticsearch, is not enabled, and if you want it you need to start the ES service and modify the app.yml configuration. So the single-container run gives you a blog without search, and search is a second service plus a configuration edit. The compose file in the repository shows what the fuller setup looks like, with a deepzz0/elasticsearch image versioned at 2.4.1 and a separate data volume, and the eiblog service linked to both it and mongodb. Two details in that file are worth flagging for anyone running it today. The MongoDB image is pinned at version 3.6, and the service publishes its port as 127.0.0.1:9000:9000, so the blog is bound to loopback rather than to every interface.

## A Typecho admin panel, TOTP, and a Markdown editor

The admin side is where the project borrows rather than invents, and the README says so directly. The admin panel embeds a full-featured Typecho backend, with a full-featured Markdown editor, and the author frames it as making you feel what clean and simple means. The v3 feature list also adds support for TOTP two-factor authentication, which is configured and then bound in the backend, custom pages supporting both standalone and embedded pages, and a project structure optimisation so each app keeps its own configuration independently. The storage of the TOTP secret comes from the dependency list, where github.com/pquerna/otp appears alongside gin-contrib/sessions for the session handling, which is consistent with a two-factor flow layered on top of a session cookie. The API documentation is generated in the standard Go way, with swaggo/swag, swaggo/gin-swagger and swaggo/files all present, and the Makefile has a swag target that runs scripts/swag_init.sh.

## Qiniu for attachments and backups, and the caching tricks

Attachments and backups both go to Qiniu, and the qiniu/go-sdk/v7 dependency explains how. The README lists Qiniu CDN support with the pitch that you can upload attachments directly in the Markdown editor, so you only have to think about the content, and automatic backup, where backup data is saved to Qiniu CDN. The backup is a separate process, which is why there is a dedicated backup image and a Makefile target that runs it, and the compose file shows the backup service with its own app.yml and a commented-out restore command. Speed is pursued through several tricks that are worth knowing about before you go looking for a plugin. The article comment count, described as not important, is fetched by a background task on the backend, so the count is sometimes wrong, and this reduces API calls. The whole site content is cached in memory with all Markdown documents converted to HTML and cached, which removes the conversion cost from the request path. Static files such as .js and .css are cached in the browser, small images are inlined into CSS as base64, and a version control update invalidates them.

## The nginx configuration is treated as part of the product

The README spends a paragraph on server configuration, which is unusual for a blog project and tells you something about its priorities. There is a best-practice nginx configuration in the repository, in eiblog.conf, and it enables compression to reduce transfer size, serves the certificate chain, and turns on Session Resumption, Session Ticket and OCSP Stapling to speed up the certificate handshake. The site in question scores A+ on both ssllabs and myssl according to the README. The remaining piece of the stack is Disqus for comments, and because the well-known connectivity problem in China makes Disqus unusable there, the project implements an alternative Disqus comment approach. The README also notes that Google Analytics is implemented with an asynchronous backend API because of Google API speed problems, so the blog page loads quickly. A Makefile target named protoc runs make protoc inside pkg/proto, which is how the protocol buffer definitions are regenerated.

## Maintenance, the v3 line, and what to read next

The releases are v3.1.1 on 2026-06-18, v3.0.11 on 2026-01-04 and v3.0.10 on 2025-11-12, and the last push to the repository was on 2026-08-14. The v3 line is on a stable patch cadence with a single minor release so far, which matches a project whose author describes using it himself for years. The module requires Go 1.25.0, and the dependency set is the standard Gin stack: gin-gonic/gin for the HTTP layer, gin-contrib/sessions for sessions, a fork of blackfriday for Markdown, google/uuid, sirupsen/logrus for logging and yaml.v3 for configuration. The README points to a documentation site with pages on installation and deployment, on writing, on what the project considers amusing features, and on how to back up, and a CHANGELOG.md sits at the repository root. The one item still open in the feature list is multi-engine search support, covering the native database, zincsearch and bleve, which is a good indicator of where the author expects search to go next.

## Conclusion

EiBlog suits a writer who wants a self-hosted blog with a fast Go backend, a familiar admin panel and a choice of database, and the v3 line is a project its author says he has used stably for years. It is the wrong tool if you want themes, a plugin ecosystem or CDN control at the front end, since the README states the system will not have strong customisation features such as themes or CDN support, and it is the wrong tool if you need multi-engine search, because support for alternatives such as zincsearch and bleve is still an unchecked box. Verify first which database driver and search backend you will run, note that the default admin credentials are deepzz/deepzz and must be changed, and check the app.yml configuration because the blog search service is off by default and the compose file still pins MongoDB 3.6 and an Elasticsearch 2.4.1 image.

## FAQ

### How do I start EiBlog with Docker?

Run docker run --name eiblog -p 9000:9000 deepzz0/eiblog:latest. The site is then at localhost:9000 and the admin at localhost:9000/admin/login with the default credentials deepzz/deepzz.

### Which databases does EiBlog support?

Six drivers are documented with source examples: mongodb, mysql, postgres, sqlite, sqlserver and clickhouse. The go.mod file lists gorm.io/gorm together with a driver module for each of the SQL backends and the official MongoDB driver.

### Is search enabled by default?

No. The README states that the blog search, elasticsearch, is not enabled by default, and that you need to start the ES service and modify the app.yml configuration if you want it.

### What admin panel does EiBlog use?

The README says the admin panel embeds a full-featured Typecho backend with a full-featured Markdown editor. The v3 line also adds TOTP two-factor authentication and custom pages, with each app keeping its own configuration.

### Where are attachments and backups stored?

Both go to Qiniu. The README lists Qiniu CDN support for uploading attachments directly from the Markdown editor, and automatic backup that saves backup data to Qiniu CDN, with a separate backup service and image in the compose setup.

## Sources

- [eiblog/eiblog on GitHub](https://github.com/eiblog/eiblog)
- [License: MIT](https://github.com/eiblog/eiblog/blob/v3/LICENSE)
- [Project website](https://deepzz.com)
- [README](https://github.com/eiblog/eiblog/blob/v3/README.md)
- [Releases](https://github.com/eiblog/eiblog/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/eiblog-eiblog