Damast – Every commit a layer

Why Damast

Your team learned git on GitHub. Your forge should know that.

Pull requests, Co-authored-by trailers, packages that sit next to the code they came from, workflows that publish with their own token. Nobody calls these features anymore. They are habits.

When a team moves to a self-hosted forge, every habit that doesn't carry over becomes a small daily papercut. Someone pairs on a fix and their name disappears. A collaborator can push code but can't publish the package it builds. A workflow needs a personal token for something GitHub does out of the box. None of it is a big deal alone. Together, it's why teams drift back.

Forgejo is a great forge with ideas of its own: independence, community governance, federation. It deliberately doesn't try to be GitHub, and that's a good choice for Forgejo.

Damast makes the other choice. Where Forgejo and GitHub work differently, Damast leans toward GitHub.

Not the look or the logo. The way things work: who gets credit, who can publish, what a token may do. That is an opinion, and plenty of Forgejo users won't share it. Damast doesn't ask you to give up Forgejo. It is Forgejo with a different set of defaults on top, and you can take them off again.

Why the name? Forgejo is Esperanto for forge. Damast is German for Damascus steel: what comes out of a good forge when you fold layers together until each one shows in the blade. Every Damast release is a Forgejo release with a thin, visible layer on top. Every commit a layer.

Co-authors

Pair programming gets the credit it deserves.

On Forgejo, Co-authored-by trailers are plain text at the bottom of the message, and pair programming, mob sessions and suggested changes all end up credited to one person. Damast reads the trailers and puts every co-author next to the author, with avatar and profile link, the way GitHub does.

On commit pages and in every commit list.
Co-authors without an account still show, with an avatar from their email.
Nothing to configure: write the trailer, Damast does the rest.

A commit list where each author has small co-author avatars next to their name.

Commit list: co-author avatars next to each author

Repo-bound packages

Packages belong to their repository.

On Forgejo, a package belongs to the user or organisation, and only owners can publish. A collaborator who can push to a repository can't publish what it builds, and workflows need a personal token. On Damast, a package belongs to the repository it was built from, like on GitHub.

New packages link to their repository by themselves: from the Actions run, the repo URL in the metadata, or the name.
Write on the repository lets you publish. Read lets you download, even from a private organisation.
Actions workflows publish with their built-in token. Pull requests from forks can only read.
No access means 404, so names of private packages don't leak.
One switch per package turns it off. Existing packages keep Forgejo's rules.

The package rocket 1.4.0, published by jonas in acme/rocket and linked to that repository.

Jonas is a repo collaborator, not an org member, and still publishes

Package settings with the switch: Inherit access from the linked repository.

One switch per package

Drop-in, both ways

Same data. Same config. A way back, any time.

An opinionated fork is only fair if you can leave it. Damast vX.Y.Z-damast.N is built on Forgejo vX.Y.Z and follows every release. It never changes Forgejo's tables or migrations; its extras live in separate damast_* tables that Forgejo ignores. CI rejects any change that breaks this.

Switch inSwap one image name

Back up, then replace codeberg.org/forgejo/forgejo:17 with ghcr.io/damast-dev/damast:17. Same data, same app.ini.

Stay currentFollows Forgejo

Every Forgejo release arrives as a pull request within a day and ships as a Damast release of the same version.

Switch backStart Forgejo again

Same Forgejo version or newer, same data. Co-authors become plain text again, and packages fall back to Forgejo's owner rules.

Feature	Forgejo	Damast
Co-authored-by trailers	Plain text in the message	Shown with avatar and link on every commit
Who can publish a package	Owners of the user or organisation	Also anyone with write on the linked repository
Who can download a package	Anyone who can see the user or organisation	Also anyone with read on the linked repository
Actions token	Publishes to the owner	Publishes and links to its own repository
Everything else	Identical

Is it for you?

An honest answer.

Damast is new and opinionated. It's right for some teams and wrong for others.

Try Damast if

You work the GitHub way

Your team came from GitHub, or still works there too, and wants its own forge without relearning how to collaborate.
The papercuts are real for you: pairing without credit, collaborators who can't publish, workflows that need personal tokens.
You already run Forgejo and want to try this without a migration you can't undo.

Stay on Forgejo if

Any of these sound like you

You chose Forgejo because it isn't GitHub. Damast is heading the other way, and you won't like where it goes.
You want a long track record. Forgejo has years of releases, upgrade tests and a security team. Damast started in November 2026, with a small team.
You need security fixes the hour they're out. Fixes pass through our sync and release first, so they reach you later.
You don't need any of the changes. The most common reason, and a good one. Forgejo is leaner, and more people look at its code.

Roadmap

Where Damast is going.

Toward GitHub's way of working, inside one hard limit: nothing ships that would break the way back to Forgejo.

Shipped

Co-authors on commits and in commit lists
Repo-bound packages with Actions token
Damast's own name and logo
Release candidates, amd64 and arm64 binaries, Docker images

Co-authors in the contribution graph and on profiles
An automated switch-in, switch-back test on every Forgejo sync
mast commands for Damast features, starting with packages

Your idea

What do you miss from GitHub? Open an issue and tell us what your team trips over.

CLI

What `gh` is to GitHub.

On GitHub, half the workflow happens in the terminal. mast brings that to your own forge. It's a soft fork of forgejo-cli (fj) and follows its releases the way Damast follows Forgejo.

Today mast is fj with a new name, on purpose: every fj command works, and both share their logins, so you can use either. Commands for Damast's features come next.

# install from source
$ cargo install --git https://github.com/damast-dev/mast
$ mast version
mast v0.7.0
$ mast auth login
$ mast whoami

Get started

One line in your compose file.

Docker tags follow Forgejo's, so switching means changing the registry. Back up first, as you would for any upgrade. Binaries for amd64 and arm64 are on the releases page, and the Forgejo admin docs apply to Damast unchanged.

# docker-compose.yml
services:
  server:
-   image: codeberg.org/forgejo/forgejo:17
+   image: ghcr.io/damast-dev/damast:17
    volumes:
      - ./forgejo:/data   # your existing data, unchanged

Built on Forgejo

Thanks, Forgejo.

Damast exists because Forgejo exists. The forge, the Actions runner, the package registry, the security work and every release we build on come from the Forgejo contributors, and from Gitea before them. If Damast is useful to you, support Forgejo and Codeberg e.V. too. Damast is not affiliated with or endorsed by the Forgejo project.