GoLab
The world's first privacy-first developer community platform on encrypted messaging.
GitLab-style collaboration meets Twitter-style activity feeds - over SimpleX SMP.
No accounts. No tracking. No admin reads your posts. E2E encrypted by design.
"Every developer community platform works the same way: you create an account, the server stores your data, the admin can read everything, and your activity profile follows you forever. GitLab, GitHub, Discourse, Reddit - they all assume that the server is trustworthy. GoLab assumes it is not."
GoLab is a developer community platform that combines GitLab-style project collaboration (repositories, issues, merge requests, wikis) with Twitter-style social features (activity feeds, posts, follows, reposts) - but every message travels through SimpleX SMP queues with full E2E encryption. The server that relays your posts cannot read them, cannot identify you, and cannot build a profile of your activity.
Your identity is not an account on a server. It is an Ed25519 certificate issued by GoUNITY - a cryptographic proof that you are who you claim to be, without revealing who that is. Moderation is handled by GoBot, which enforces community rules without ever seeing message content in its hardware-secured mode. And if you want physical proof of identity, plug in a SimpleGo device and verify with a hardware challenge-response that no software can fake.
This architecture has no precedent. No existing platform combines anonymous transport, persistent pseudonymous identity, scalable community features, and hardware-backed verification in a single system.
GoLab Phase 1 is live at lab.simplego.dev. A fully functional developer community platform built with:
- Backend: Go 1.24, chi router, PostgreSQL 16
- Frontend: Server-rendered HTML with HTMX + Alpine.js
- Editor: Quill.js 2.0.3 WYSIWYG with emoji picker
- Real-time: WebSocket notifications and live updates
- Search: PostgreSQL full-text search
- Auth: bcrypt with rate limiting and security headers
- Deploy: Docker Compose on Debian VPS
- 8 thematic Spaces (SimpleX Protocol, Matrix / Element, Cybersecurity, Privacy, Hardware, SimpleGo Ecosystem, Dev Tools, Off-Topic / Meta)
- Post Types (Discussion, Question, Tutorial, Code, Showcase, Link)
- Tag system with autocomplete
- Rich text editor with image upload and syntax highlighting
- Real-time notifications via WebSocket
- Threaded conversations with reply chains
- Admin dashboard with user management and power levels
- User moderation (pending / active / rejected approval system)
- Account security (password change, username change with availability check, session revocation)
- Fullscreen mobile menu (dark / cyan, slide-in)
- Responsive design from 375px to ultrawide
- Rate limiting and HTML sanitization
- Zero npm dependencies, zero CDN calls, self-hosted everything
[Browser] --> [Nginx reverse proxy]
|
[Go Application Server]
|
[PostgreSQL 16]
Phase 1 uses standard HTTPS transport. Posts are stored in PostgreSQL. The server CAN read content. This is the foundation that will be replaced by SMP transport in Phase 2.
The sections below describe the Phase 2 vision: a server that is blind to content, routes encrypted SMP blocks, and authenticates users by certificate rather than by account. Phase 1 exists so Phase 2 has a real community to migrate, not an empty shell.
GoLab is two things in one:
A social platform (like Twitter): Post updates, follow people, build an activity feed, react to posts, repost content, discover communities. Every interaction is an ActivityStreams 2.0 object transported over SMP queues - standardized, extensible, and fully encrypted.
A collaboration platform (like GitLab): Create projects, track issues, review code, discuss in threads, manage teams with role-based permissions. Every collaboration artifact is signed by the author's Ed25519 certificate - verifiable, tamper-proof, and independent of any server.
What makes it different from everything else:
| Feature | GitHub/GitLab | Twitter/X | Mastodon | Nostr | GoLab |
|---|---|---|---|---|---|
| Project management | Yes | No | No | No | Yes |
| Activity feeds | Limited | Yes | Yes | Yes | Yes |
| E2E encrypted | No | No | No | No | Yes |
| No user accounts on server | No | No | No | No | Yes |
| Server cannot read content | No | No | No | No | Yes |
| Persistent identity | Server account | Server account | Server account | Public key (visible) | Ed25519 cert (anonymous) |
| Metadata protection | No | No | No | No | SMP queues |
| Hardware identity | No | No | No | No | Optional (GoKey/SimpleGo) |
| Ban evasion resistant | Weak | Weak | Weak | None | Certificate-based |
The architecture below is the Phase 2 target. Phase 1 (today) uses standard HTTPS to a Go server with PostgreSQL; see the "What GoLab is today" section above. Phase 2 replaces the transport layer with SMP queues and swaps account-based auth for GoUNITY certificates.
[Browser / GoLab Client]
|
| ActivityStreams messages (Create/Note, Follow, Like, ...)
| signed with Ed25519 certificate from GoUNITY
|
v
[simplex-js / SMP Transport]
|
| E2E encrypted, no user IDs, queue-based
| Server sees only encrypted 16 KB blocks
|
v
[GoBot Community Relay]
|
| Receives encrypted blocks
| Fans out to all channel subscribers
| Enforces permissions and moderation
| In GoKey mode: cannot read any content
|
+---> [Subscriber A via SMP queue]
+---> [Subscriber B via SMP queue]
+---> [Subscriber C via SMP queue]
Each subscriber has a unique queue pair
Relay cannot correlate subscribers across channels
1. User writes "Fixed the memory leak in GoChat" in #gochat-dev
2. GoLab client creates ActivityStreams object:
{"type": "Create", "object": {"type": "Note", "content": "..."}}
Signs it with Ed25519 private key from GoUNITY certificate
3. simplex-js encrypts and sends via SMP queue to GoBot relay
4. GoBot receives encrypted block
In GoKey mode: forwards to ESP32 for decryption and command check
GoBot itself never sees the plaintext
5. GoBot fans out the encrypted message to all #gochat-dev subscribers
Each subscriber receives via their own SMP queue
Subscriber queues are pairwise - relay cannot link users
6. Subscriber clients decrypt, verify Ed25519 signature, display post
Signature proves: this post is from "CryptoNinja42"
Certificate proves: "CryptoNinja42" is GoUNITY-verified
1. User registers at id.simplego.dev (GoUNITY)
Receives Ed25519 certificate + private key
2. User joins GoLab community
Sends certificate to GoBot via DM (E2E encrypted)
3. GoBot/GoKey verifies CA signature (local, offline)
Sends challenge nonce
User signs nonce with private key
Proof: user holds the key, sharing impossible
4. User is verified as "CryptoNinja42"
Can post, create projects, moderate (based on role)
GoLab server never knows the real identity
- Activity feeds - personalized timeline of followed users and channels
- Posts - short-form updates with text, links, code snippets
- Reposts - share others' posts to your followers (ActivityStreams Announce)
- Reactions - like, upvote, or custom reactions on any post
- Follows - subscribe to users or channels
- Threads - reply chains with nested conversations
- Discovery - find communities, users, and projects by topic
- Profiles - pseudonymous identity with bio, activity history, reputation
- Projects - repositories with description, README, team members
- Issues - bug reports, feature requests, discussions with labels and milestones
- Merge requests - code review workflow with inline comments
- Wikis - collaborative documentation per project
- Teams - role-based access control (owner, maintainer, developer, reporter, guest)
- Milestones - group issues and MRs into release targets
- Labels and tags - organize and filter across projects
- GoUNITY certificates - verified pseudonymous identity, ban-evasion resistant
- GoBot moderation - automated rule enforcement without reading content
- Role-based permissions - Matrix-style power levels per channel and project
- Reports - community members flag content, moderators review
- CRL enforcement - revoked certificates are rejected across all communities
- Hardware verification - optional GoKey/SimpleGo challenge-response for physical trust
Phase 1 is a single Go binary + PostgreSQL container; the multi- component composition below applies once Phase 2 migrates the transport layer to SMP. The Phase 1 stack lives in this repository.
GoLab is not a monolith. It is composed of existing SimpleGo ecosystem components:
| Component | Role in GoLab | Repository |
|---|---|---|
| GoLab | Community application server + browser client | This repo |
| GoBot | Community relay + moderation engine | GoBot repo |
| GoKey | Hardware crypto for GoBot (optional) | SimpleGo repo |
| GoUNITY | Certificate authority for identity | GoUNITY repo |
| simplex-js | SMP transport for browser clients | GoChat repo |
+------------------------------------------------------------------+
| |
| GoLab Application Server (Go) |
| Community logic, channel registry, post persistence, |
| activity stream aggregation, search index |
| |
+---------------------------+--------------------------------------+
|
internal API
|
+---------------------------v--------------------------------------+
| |
| GoBot (Go service on VPS) |
| Community relay: SMP connections, fan-out, moderation, |
| permission enforcement, GoUNITY certificate verification |
| |
+---------------------------+--------------------------------------+
|
SMP queues (E2E encrypted)
|
+---------------------------v--------------------------------------+
| |
| GoLab Browser Client (TypeScript) |
| Built on simplex-js + GoChat widget architecture |
| Activity feeds, project views, post composer, profiles |
| |
+------------------------------------------------------------------+
+-------------------------------+ +-------------------------------+
| | | |
| GoUNITY (separate server) | | GoKey (ESP32, optional) |
| Certificate issuance | | Hardware crypto for GoBot |
| CRL distribution | | Hardware identity for users |
| id.simplego.dev | | Challenge-response verify |
| | | |
+-------------------------------+ +-------------------------------+
GoLab uses ActivityStreams 2.0 as its message vocabulary, transported over SMP queues instead of HTTP. Every message is a signed JSON object:
{
"@context": "https://www.w3.org/ns/activitystreams",
"type": "Create",
"actor": "did:key:z6Mkf5rGMoatrSj1f4CyvuHBeXJELe9RPdzo2PKGNCKVtZxP",
"published": "2026-04-16T10:30:00Z",
"to": ["golab:channel:gochat-dev"],
"object": {
"type": "Note",
"content": "Fixed the memory leak in GoChat v1.0.1"
},
"proof": {
"type": "Ed25519Signature2020",
"proofValue": "z..."
}
}Standard ActivityStreams types mapped to GoLab features:
| ActivityStreams type | GoLab feature |
|---|---|
| Create + Note | Post / Comment |
| Create + Article | Long-form post / Wiki page |
| Announce | Repost |
| Like | Reaction / Upvote |
| Follow | Subscribe to user or channel |
| Block | Ban (moderator action) |
| Remove | Delete content (moderator action) |
| Update | Edit post / Update issue |
| Add | Add member to project / Assign issue |
The zero-knowledge properties below describe the Phase 2 target. Phase 1 uses HTTPS + PostgreSQL, so today the server DOES see content, DOES store user identities (bcrypt-hashed), and DOES know the social graph. Phase 1 security is covered in docs/ARCHITECTURE_AND_SECURITY.md under the Phase 1 section.
| Data | Visible to server? |
|---|---|
| Post content | No (E2E encrypted via SMP) |
| User identity | No (only queue addresses) |
| Who posted what | No (GoBot relay mode) |
| Who follows whom | No (pairwise SMP queues) |
| Channel membership list | Queue addresses only, not identities |
| IP addresses | SMP server sees them, GoLab does not |
Most platforms that claim encryption still have a server that manages accounts, stores metadata, and knows the social graph. GoLab has none of that:
- No accounts on the server. Your identity is a certificate in your browser/device.
- No social graph on the server. Follow relationships exist as SMP queue pairs that the server cannot correlate.
- No content on the server. Posts are encrypted in transit and only stored on subscribers' devices (or optionally on encrypted persistence nodes).
- No metadata correlation. Each channel subscription uses a separate SMP queue pair. The relay cannot link your activity across channels.
See Architecture and Security for the full threat model.
| Component | Status |
|---|---|
| GoLab concept and architecture | Season 1 - this document |
| GoLab Phase 1 application server | LIVE at lab.simplego.dev (Go 1.24 + PostgreSQL 16) |
| GoLab Phase 1 browser client | LIVE (Go html/template + HTMX + Alpine.js, no TypeScript) |
| GoLab Phase 1 content features | LIVE (8 Spaces, post types, tags, editor, notifications, search) |
| GoLab Phase 1 moderation | LIVE (power levels 0-100, ban system, approval queue) |
| GoLab Phase 1 deployment | LIVE (Docker Compose on Debian VPS, Nginx, Let's Encrypt) |
| GoLab Phase 2 SMP migration | Planned (after GoBot Season 2-3) |
| GoLab Phase 2 certificate identity | Planned (after GoUNITY Season 4) |
| GoBot community relay extensions | Planned (after GoBot Season 2-3) |
| GoUNITY certificate integration | Planned (after GoUNITY Season 4) |
| simplex-js transport layer | Available (npm: simplex-js@1.0.0) |
| GoKey hardware identity | Planned (after GoKey Season 3) |
GoLab builds on components that are in active development:
| Dependency | Required for | Status |
|---|---|---|
| GoBot Season 2-3 | Community relay + moderation | In development |
| GoUNITY Season 4 | Certificate-based identity | Planned |
| simplex-js | Browser SMP transport | Published (1.0.0) |
| GoChat widget architecture | Browser client foundation | Published (1.0.0) |
| GoKey | Hardware identity (optional) | Planned |
git clone https://github.com/saschadaemgen/GoLab.git
cd GoLab
docker-compose up -dGoLab is now running at http://localhost:3000.
Requirements:
- Docker and Docker Compose
- That is it. No Go, no Node, no npm.
The first user to register becomes the Owner (power level 100).
All subsequent users are regular Members (power level 10). Admins
can approve / reject new accounts if the require_approval
setting is enabled.
git clone https://github.com/saschadaemgen/GoLab.git
cd GoLab
# GoLab application server
make build
make run
# Or with Docker
docker-compose up -dPhase 2 requirements:
- GoBot instance (community relay)
- GoUNITY instance (certificate authority)
- SMP server with WebSocket support (e.g., smp.simplego.dev)
| Document | Description |
|---|---|
| Architecture and Security | Technical architecture, threat model, security analysis |
| Concept | High-level vision, design decisions, technology choices |
| Season Index | Links to all season documentation |
| Document | Description |
|---|---|
| GoBot System Architecture | Full GoBot + GoKey + GoUNITY system design |
| GoBot Concept | GoBot technical concept with GoLab integration |
| GoKey Wire Protocol | Communication protocol between GoBot and GoKey |
| GoUNITY Architecture | Certificate authority design and security |
| Project | What it does |
|---|---|
| SimpleGo | Dedicated hardware messenger on ESP32-S3 |
| GoRelay | Encrypted relay server (SMP + GRP) |
| GoChat | Browser-native encrypted chat widget |
| GoBot | Hardware-secured moderation bot |
| GoKey | Hardware crypto engine for GoBot (ESP32-S3) |
| GoUNITY | Certificate authority for identity verification |
| GoLab | Privacy-first developer community platform |
| GoShop | End-to-end encrypted e-commerce |
| GoTube | Encrypted video platform |
| GoBook | Encrypted publishing platform |
| GoOS | Privacy-focused Linux (Buildroot, RK3566) |
AGPL-3.0
GoLab is part of the SimpleGo ecosystem by IT and More Systems, Recklinghausen, Germany.
Your server relays the messages. Your certificate proves your identity. Nobody reads your posts.