Self-hosted service
writefreely/writefreely avatar
writefreely/writefreely

WriteFreely's compose file expects a config.ini you have to write yourself

A clean, Markdown-based publishing platform made for writers. Write together and build a community.

5,293 stars410 forksGoAGPL-3.0

At a glance

What is it?
WriteFreely is a single static Go binary for publishing, with ActivityPub federation, OAuth 2.0 and a SQLite or MySQL backend. Its deployment files show where the sharp edges are: a placeholder database password, a build tag that decides whether SQLite is compiled in, and cross-compile targets that drop static linking.
Who is it for?
WriteFreely is a good fit when a single self-hosted binary, a plain editor and federation to Plume matter more than a plugin ecosystem or a hosted admin. It is a poor fit if you need configuration you can discover from the repository, because the compose file mounts a config.ini that the repository does not ship.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository last received commits 3 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • writefreely/writefreely5,293 ★ · +36
Star history
Repository2026-09-232026-11-15
writefreely/writefreely5.3k5.3k

36 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The compose file mounts config.ini by hand and leaves the database password as changeme

Getting WriteFreely onto a machine means editing the deployment files before the first request, and the one in the repository ships with a placeholder in it. `docker-compose.yml` mounts the host's `./config.ini` into `/go/config.ini` and a named volume `web-keys` at `/go/keys`, publishes port `8080:8080`, and joins two networks: `external_writefreely`, plus `internal_writefreely` declared `internal: true`, so the database container has no route off the host.

The database service is `mariadb:latest` with `db-data` on `/var/lib/mysql/data`, and its environment sets `MYSQL_DATABASE=writefreely` and `MYSQL_ROOT_PASSWORD=changeme`. That password is the literal value committed to the repository, so anything past a local trial needs it replaced before the stack starts. Both services carry `restart: unless-stopped`, which means Docker restarts them automatically unless you stopped them by hand.

yaml
  writefreely-db:
    container_name: "writefreely-db"
    image: "mariadb:latest"

    volumes:
      - "db-data:/var/lib/mysql/data"

    networks:
      - "internal_writefreely"

    environment:
      - MYSQL_DATABASE=writefreely
      - MYSQL_ROOT_PASSWORD=changeme

    restart: unless-stopped

The image compiles on golang:1.25-alpine3.22 and ships on alpine:3.18.4

Build stage and runtime stage are pinned to different Alpine releases, and the gap is visible in the Dockerfile rather than hidden. The build starts `FROM golang:1.25-alpine3.22 AS build`, installs `nodejs npm make g++ git` through apk, and pulls `less` and `less-plugin-clean-css` from npm, because the stylesheets under `less/` have to compile before the binary can serve them.

Two settings exist to keep older crypto paths alive during that compile: the build overwrites the system OpenSSL configuration with `ossl_legacy.cnf`, and `NODE_OPTIONS=--openssl-legacy-provider` handles the same problem on the Node side. The final stage is `FROM alpine:3.18.4`, so the runtime userland trails the toolchain userland by several releases. It copies the staged tree with `--chown=daemon:daemon`, declares `VOLUME /go/keys` and `EXPOSE 8080`, switches to `USER daemon`, and runs `cmd/writefreely/writefreely` as the entrypoint. Liveness is a `wget` spider against `http://localhost:8080/`, with a 5 second start period and a 15 second interval.

SQLite is a compile-time decision, not a line in config.ini

Whether SQLite support is compiled in is decided by a build tag, so the same source tree produces two different binaries. The repository keeps both variants of the database layer side by side: `database-sqlite.go` and `database-no-sqlite.go`, alongside `database.go`, `database-lib.go` and `database_activitypub.go`, with `migrations/` and `db/` next to them.

The default target enables both `netgo` and `sqlite`, and `build-no-sqlite` swaps that tag out and writes the result under the plain binary name. Version strings are captured with backticks around `git describe | cut -c 2-` and injected into the binary through linker flags, so a release build needs a checkout that has tags, which an archive download does not have.

sh
make build
make ui
make
build: deps
	cd cmd/writefreely; $(GOBUILD) -v -tags='netgo sqlite'

build-no-sqlite: deps-no-sqlite
	cd cmd/writefreely; $(GOBUILD) -v -tags='netgo' -o $(BINARY_NAME)

The darwin cross-builds drop the static linker flag the others keep

The cross-compile targets are not uniform. `build-linux` and `build-windows` both pass `$(LDFLAGS)`, which ends in `-extldflags '-static'`, while `build-darwin-arm64` and `build-darwin` pass `$(BASELDFLAGS)` instead. That variable carries the same `-s -w` stripping and the same `softwareVer` injection, but no `-extldflags` line, so the macOS artifacts are built as ordinary dynamically linked binaries.

Every one of those targets first checks for the cross-compiler with `hash xgo` and installs `src.techknowlogick.com/xgo@latest` when the check fails, then pins the toolchain with `-go go-1.25.x`. Note the trailing comma in the target lists, as in `--targets=linux/amd64,` and `--targets=windows/amd64,`. Packages land in `build/` under the name `writefreely`, and the image name is `writeas/writefreely`, which is the same image the compose file pulls with the `:latest` tag rather than a version.

One login, several blogs, and pen names the public cannot connect

A single account can run several blogs, and the project frames that as a privacy property rather than an account feature: writers create multiple blogs from one account for different pen names or purposes, and the association between them is not publicly revealed.

The organizing tools are small and text-first. Posts are categorized with hashtags, a normal post can be pinned so it becomes a static page on the blog, drafts can be held back, and one post can be published to more than one blog. The editor is described as plain and auto-saving, with the writing surface kept free of decoration and the published post put front and center. Localization is treated as a first-class concern too: blog elements are localized in more than 20 languages, with stated support for non-Latin and right-to-left scripts.

Federation, mail, payments and background jobs all sit in one process

The Go files at the repository root give a fair map of what a single binary handles. Federation lives in `activitypub.go` with its own `activitypub_test.go` and `database_activitypub.go`; discovery endpoints are split into `nodeinfo.go`, `hostmeta.go` and `handle.go`. Identity and access are `auth.go`, `keys.go`, and the `key/` and `keys/` directories, which is what the `web-keys` volume in the compose file is for. Outbound mail is `email.go` plus a `mailer/` package, and `github.com/mailgun/mailgun-go v2.0.0+incompatible` is a direct requirement in `go.mod`, so a hosted delivery path is wired in rather than bolted on.

`oauth.go`, `oauth_generic.go` and the `oauth/` directory cover the OAuth 2.0 support advertised for bringing members across from existing platforms, and the stated federation target is Plume and other ActivityPub-powered software. Alongside those sit `monetization.go`, `invites.go`, `jobs.go`, `feed.go`, `export.go` and `account_import.go`. `gorilla/mux v1.8.1` handles routing and `microcosm-cc/bluemonday v1.0.27` sanitizes HTML, since the editor accepts markup. The project describes one static binary for all of this.

Three tags inside a month, with a hosted service as the easy path

Release cadence in 2026 was tight: v0.17.0 on 2026-07-17, v0.17.1 three days later on 2026-07-20, and v0.17.2 on 2026-08-10. The default branch is `develop`, while the contribution links in the README point at `master`, so the two names coexist in the project's own documentation. The last push to the repository was on 2026-10-26.

For running it, the recommendation is a package rather than a compile. Pre-built static binaries are published for common platforms, there is an Arch User Repository package, and a Nanos repository entry as well. Underneath all of those sits Write.as, a hosted service from the team behind WriteFreely, which sells managed installation, backup, upgrades and maintenance. The trade is plain: the hosted route removes the `changeme` password problem and the config.ini guesswork. Self-hosting keeps the data on hardware you control, under AGPL-3.0 with copyright held by Musing Studio LLC and contributing authors from 2018 to 2026.

Editorial conclusion

WriteFreely is a good fit when a single self-hosted binary, a plain editor and federation to Plume matter more than a plugin ecosystem or a hosted admin. It is a poor fit if you need configuration you can discover from the repository, because the compose file mounts a config.ini that the repository does not ship. Before deploying, replace the compose file's database root password, decide whether the sqlite build tag is what you want, and read the installation guide linked from the project site rather than inferring settings from the container files.

Frequently asked questions

Where can I write freely?

WriteFreely points three ways: try the writing experience at write.as/new, find an existing instance through the instance list at writefreely.org/instances, or deploy your own binary on any platform Go supports, using built-in SQLite or a MySQL or MariaDB database.

writefreely vs ghost

The repository does not document a comparison with Ghost. What it states about itself: a single static Go binary, AGPL-3.0 licensed, SQLite or MySQL/MariaDB backends, OAuth 2.0 for existing platforms, and ActivityPub federation aimed at Plume and other ActivityPub software.

writefreely vs wordpress

No comparison with WordPress appears in the repository. WriteFreely describes a plain auto-saving editor, hashtag categories, pinning posts into static pages, multiple blogs from one account, and blog elements localized in 20 or more languages with non-Latin and right-to-left support.

What is the best free blogging platform?

The repository does not rank platforms. It calls WriteFreely a clean, minimalist publishing platform made for writers, deployable as a static binary with SQLite by default or MySQL or MariaDB added, and available as pre-built binaries, an Arch package, a Nanos package, or the hosted Write.as service.

Can I get paid to write for us?

The repository does not describe a payment program. It does contain monetization.go at the root of the tree, and it presents the hosted Write.as service as the way to fund the project's free software work, alongside installation, backup, upgrades and maintenance.

Official sources

  1. License: AGPL-3.0
  2. Project website
  3. README
  4. Releases
  5. writefreely/writefreely on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/writefreely-writefreely.svg)](https://hysenlabs.com/projects/writefreely-writefreely)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/writefreely-writefreely.svg)](https://hysenlabs.com/projects/writefreely-writefreely)

Was this useful?