Waking the server…
It naps when nobody’s around. Give it a few seconds.
DemiWaking the server…
It naps when nobody’s around. Give it a few seconds.
Case study
Voice and chat for squads who play together. A gaming communication app with end-to-end encrypted DMs, voice channels, and self-hostable community Spheres — built as a monorepo with native apps for iOS, Android, and desktop.
AetherHub is a gaming communication app designed for squads of four — friends who play together regularly and need reliable voice chat, encrypted messaging, and community spaces. It's built around the idea that gaming teams deserve better than Discord's bloat or Slack's corporate feel.
The product spans three platforms: a desktop app (Electron), native iOS (Swift 6), and native Android (Kotlin). Each platform shares the same feature set — voice channels, encrypted DMs, Spheres (communities), and friend management — with UI adaptations for each device type. Foldable phones, flip covers, and tablets get special attention in the mobile apps.
Spheres are the heart of AetherHub: self-hostable community servers that run on your own infrastructure or on AetherHub's cloud. Each Sphere has channels (text and voice), members, and moderation tools. The desktop and mobile apps connect to any Sphere — self-hosted or cloud-hosted — using a unified protocol.
It's for gaming squads who want privacy (end-to-end encrypted DMs), communities that own their data (self-hostable Spheres), and a product built for how gamers actually communicate.
Gaming communication tools force a choice: Discord is feature-rich but invasive, TeamSpeak is reliable but dated, and Slack doesn't understand gaming culture. Meanwhile, community servers are locked into single platforms — you can't self-host your own Discord server without building an entire company.
How might we give gaming communities a tool that works great for small squads, scales to large communities, and lets owners keep control of their data?
Next project
Ingle
AetherHub is built as an npm monorepo with three app directories (apps/desktop, apps/android, apps/ios), two service directories (services/cloud-api, services/sphere), and shared packages. Each app shares the same feature set but uses platform-native technologies: Electron for desktop, SwiftUI for iOS, Jetpack Compose for Android.
The backend splits into two layers: Cloud API (Supabase on Vercel) handles auth, join codes, DMs, and friends; Sphere server (SQLite + Docker) handles channels, messages, and voice per community. This separation means self-hosters only need to run the Sphere server — they don't need Supabase or a cloud backend.
Self-hostable community servers (Docker + SQLite) or cloud-hosted on AetherHub. Each Sphere has channels (text and voice), members, and moderation tools. Join via code or URL.
Real-time voice chat in Spheres using WebRTC mesh topology with Socket.IO signalling. Mute, join, leave. TURN relay for strict NATs.
End-to-end encrypted direct messages using XChaCha20-Poly1305 (swift-sodium). Encrypted groups with selective message export for reporting.
Built-in support for teams of four. Ready checks, squad voice, and squad-specific features.
Privacy mode: non-friends can't message you or find you in lists. Group chats require everyone to be your friend.
Run a Sphere server on your own infrastructure. Single docker compose up. No Supabase required. Owner terms acceptance for legal clarity.
Report messages, people, Spheres, or DMs. Reports go to Sphere owners/admins; serious reports (illegal content, child safety, threats) also route to AetherHub. Encrypted DM reporting exports only selected messages.
Challenge
A single monorepo with shared documentation (docs/mobile/PROTOCOL.md for the server contract), shared package references (@aetherhub/legal for legal text), and parallel release trains. Each platform has its own CLAUDE.md with technology-specific instructions, but all three share the same version numbers and feature roadmap. The desktop app uses Electron's web technologies; mobile apps use native APIs — but they talk to the same servers using the same protocol.
Challenge
XChaCha20-Poly1305 via swift-sodium on iOS and the equivalent on Android/Desktop. Keys are generated and stored on-device. Messages are encrypted before leaving the device and decrypted after arrival. The server only sees ciphertext. For reporting in encrypted DMs, users select which messages to export — only those specific messages leave the device encrypted, not the entire conversation.
Challenge
A dual-mode architecture. Cloud-hosted Spheres use Supabase Auth + Cloud API for join codes and DMs. Self-hosted Spheres use their own JWT secret + optional Supabase tokens via JWKS. The apps detect which mode a Sphere is in based on configuration and adapt accordingly. The desktop app works with VITE_SPHERE_URL pointing to any Sphere server — self-hosted or cloud.
Challenge
Adaptive layouts using Jetpack Compose's responsive APIs. The UI adapts to window size and shape — two panes on foldables when open, controls on the bottom half in tabletop mode, quick glances on flip covers. The iOS app uses SwiftUI's adaptive views with Liquid Glass effects that respond to device orientation and size. Both platforms share the same feature set but present it differently based on the available screen real estate.
Challenge
WebRTC mesh topology for small groups (up to 4 players in a squad). Socket.IO signalling for connection setup and management. Optional TURN relay (turn.aetherhub.chat) for clients behind strict NATs. The Sphere server handles signalling; media flows peer-to-peer when possible, through TURN when necessary.
Challenge
npm workspaces for the JavaScript/TypeScript parts (apps/*, packages/*, services/*). Docker for the Sphere server. XcodeGen for iOS project generation (not committed to git). Gradle for Android with pinned versions in libs.versions.toml. A root-level package.json with a build script that runs all app builds in sequence. The monorepo structure keeps everything in one place while respecting each technology's build requirements.
15+ releases
since first launch (early 2026 → November 2026)
3 Apps
Desktop (Electron), iOS (SwiftUI), Android (Jetpack Compose)
2 Services
Cloud API (Supabase on Vercel), Sphere server (SQLite + Docker)
Self-hostable
run a Sphere server with docker compose up
End-to-end encrypted
DMs using XChaCha20-Poly1305
V0.3.4
voice, encrypted DMs, reporting, teen accounts, and formatting