GoGalaxy

Open libraries · Shared prefix · Public proxy

Go modules, held in common.

GitHub stays the workshop. GoGalaxy is the commons — a stable import path for small libraries written in the open, reviewed together, and kept alive by more than one person.

See the shelf Propose a module 
$ go get gogalaxy.dev/logger

A prefix is only as good as the people behind it.

github.com/you/mod already installs. A vanity path is worth using when the name means something: reviewed code, a public history, and maintainers who answer. That is the whole product.

We are not a marketplace and we are not the Go project. We are a shared shelf. If a library belongs here, anyone can read it, import it, and help keep it.

What we promise

Who this is for

GoGalaxy is a home for small libraries that want a stable name and a public trail — not for product marketing pages or one-person experiments that never leave a laptop.

Authors with a sharp API

You already ship focused packages: a logger, a tree, a proof helper. The vanity path is the front door; GitHub remains where the work happens.

Teams that want a shared shelf

Import paths that do not hinge on one employer’s GitHub org. When people move on, the modules and their names stay findable.

Readers who check provenance

You care that source is public, versions are tagged, and docs land on pkg.go.dev like every other honest Go module.

On the shelf

Real modules, already fetchable. Browse docs on pkg.go.dev, then import the vanity path — not the GitHub URL.

data structure

btree

In-memory B-tree with an ordered, mutable API. Used as a live index in stores and schedulers.

$ go get gogalaxy.dev/btree

logging

logger

A small leveled logger: debug, info, warn, error. Options for output and minimum level.

$ go get gogalaxy.dev/logger

crypto

merkletree

Build a Merkle tree, mint proofs, verify leaves. Pluggable hash, including SHA-256.

$ go get gogalaxy.dev/merkletree

More modules will land here as they clear review. Each card links to live docs on pkg.go.dev — that is the catalog of record.

Try it in a fresh module

Same workflow as any other vanity path. The toolchain talks to gogalaxy.dev once, then follows git like usual. 

$ mkdir demo && cd demo
$ go mod init example.com/demo
$ go get gogalaxy.dev/logger@latest
$ go doc gogalaxy.dev/logger
$ # import "gogalaxy.dev/logger" in your code, then:
$ go build ./...

How a path resolves

One domain, two visitors. Browsers go to docs. The toolchain gets go-import meta and never treats pkg.go.dev as a module proxy.

  1. 01

    Name on the commons

    A module root such as gogalaxy.dev/logger is registered. Source lives under github.com/gogalaxyteam/ (or a linked public repo). go.mod declares the vanity path.

  2. 02

    The toolchain asks nicely

    go get hits ?go-get=1 and receives go-import pointing at git. A normal browser visit redirects to pkg.go.dev. That query is never redirected.

  3. 03

    The ecosystem carries it

    The public proxy fetches, the sum database checksums, pkg.go.dev indexes. Versions are git tags (vX.Y.Z). We do not host zip content on this site.

Source
github.com/gogalaxyteam
Download
proxy.golang.org
Integrity
sum.golang.org
Docs
pkg.go.dev

Publish checklist

Before a path goes live, we look for the same basics any careful Go user would: a clear module line, tests, and a license people can trust.

  1. Module path matches

    go.mod starts with module gogalaxy.dev/yourname. Imports inside the tree use that same prefix.

  2. Public GitHub home

    Default branch builds. README explains the API in a few paragraphs. Issues are open. License is OSI-friendly (MIT, Apache-2.0, BSD, and kin).

  3. Tagged releases

    Semantic versions as git tags (v0.1.0, v1.0.0). No force-pushing published tags once people depend on them.

  4. Tests that run

    go test ./... is green on a current Go release. CI is welcome; it is not a substitute for a package others can reason about.

  5. A steward contact

    Someone answers mail or GitHub. If you step away, say so — the commons works when handoffs are possible.

  6. Scope stays small

    One job per module beats a kitchen-sink toolkit. Split large surfaces into separate paths rather than growing forever under one name.

Stewardship, not ownership theater

A vanity prefix is a promise about continuity. Modules on GoGalaxy should be easy to adopt: clear CONTRIBUTING notes, reviewable history, and APIs that do not depend on tribal knowledge. We will help find a new steward when a maintainer needs to step back — silence is the failure mode we try to avoid.

Keep the path. Keep the tests. Keep the door open for the next person who will care about the code.

FAQ

Short answers to the questions that show up first. If yours is missing, write hello@gogalaxy.dev.

Is GoGalaxy part of the Go project?

No. The Go language, toolchain, and go.dev stay with the Go project. We are an independent commons that uses the same public proxy, sum database, and pkg.go.dev everyone else does.

Why not just use github.com/…?

You can. A vanity path is optional. It is worth it when you want a stable, brand-light import that outlives a single org rename or employer account — and when the name itself signals review and shared upkeep.

Do you host module zips?

No. Source is on GitHub. Downloads go through proxy.golang.org. Checksums through sum.golang.org. This site only serves the vanity meta and this front door.

What happens if I visit gogalaxy.dev/logger in a browser?

You are redirected to the package docs on pkg.go.dev. The Go toolchain uses ?go-get=1 and receives go-import meta instead — that query is never redirected.

Can I keep my existing GitHub repo?

Often yes. The repo must be public, and go.mod must declare the gogalaxy.dev path. We wire the vanity mapping; you keep committing where you already work.

How do versions work?

Ordinary Go modules: semantic import versions and git tags. Major breaks belong on a new path or a /v2 (and friends) following the Go modules rules — not a silent rename of a live path.

What will you reject?

Private source, malware or credential helpers with no clear legitimate use, modules that are only ads, and paths that impersonate the Go standard library or well-known projects.

Three ways to show up

Import it

Prefer the vanity path in new code. That is how the commons stays visible, and how pkg.go.dev learns who actually uses a module.

Patch it

Issues and pull requests go to the source repo. Tests, docs, and stewardship all count. A library here should be easy to hand off.

Propose one

Small, focused modules with a clear API and a license. If it already lives on GitHub, we can point the prefix at it — the go.mod module line has to match.

Write hello@gogalaxy.dev with a repo, a proposed path, and why it belongs on the shelf.

Clear limits