Open-source multi-messenger platform unifying Matrix, Telegram, SimpleX and WhatsApp in one secure inbox.
Free desktop client with native Tor and I2P routing, plus dedicated hardware messenger devices with secure elements and verified boot.
Built with Rust, Tauri v2 and Svelte. All cryptography runs natively - encryption keys never touch the WebView.
Early development (pre-alpha). SimpleGoX is under active development. Features are incomplete, APIs will change, and bugs are expected. Not ready for daily use. Contributions and feedback are very welcome!
SimpleGoX is a multi-messenger platform that brings Matrix, Telegram, SimpleX and WhatsApp together in one app. All your chats from all protocols appear in a single list, sorted by last activity. You never switch between apps.
Each protocol runs as its own isolated native process on your machine. Your Telegram keys stay in the Telegram process. Your Matrix encryption runs in Rust outside the browser. Nothing is bridged through a server. Nothing leaves your device.
SimpleGoX is the first multi-messenger to offer both native Tor and I2P routing. With one click, your Matrix traffic can travel through the Tor network or the invisible I2P network - no external tools required, no configuration needed.
The long-term vision goes beyond desktop: SimpleGoX is designed to run on dedicated hardware terminals with secure elements, tamper detection and hardened Linux - a physical messenger device you own and control. See ARCHITECTURE_AND_SECURITY.md for the complete security architecture spanning from silicon to user interface.
Unlike Beeper which bridges everything through Matrix on a cloud server, SimpleGoX connects to each protocol natively on the client side using isolated sidecar processes that communicate over gRPC. Zero shared memory between protocols. No server-side bridges. No cloud proxy.
| Product | Description | Status |
|---|---|---|
| SimpleGoX Desktop | Multi-messenger client for Windows, Linux and macOS | Pre-alpha |
| SimpleGoX Hardware | Dedicated messenger devices in 3 security classes | Planning |
| SimpleGoX Chat | Embeddable E2E-encrypted website chat widget | In development |
| SimpleGoX ESP | ESP32 IoT devices that speak Matrix natively | In development |
SimpleGoX is the successor to SimpleGo (ESP32 hardware messenger) and GoChat (browser chat widget), now built on the Matrix protocol with multi-messenger support.
| Protocol | Status | Implementation |
|---|---|---|
| Matrix | Working | Native Rust via matrix-rust-sdk 0.16 + vodozemac |
| Telegram | Working | TDLib 1.8.61 via tdlib-rs in isolated sidecar process |
| SimpleX | In Development (pre-alpha) | Native Rust SMP v9 via sgx-simplex sidecar - queue creation working, AgentConfirmation received |
| Planned | Official EU DMA interoperability path |
| Mode | Status | Implementation |
|---|---|---|
| Direct | Working | Standard HTTPS connection to homeserver |
| Tor | Working | Native Arti 0.41 (Rust Tor) with exit IP verification |
| I2P | Working | i2pd 2.56.0 (C++) sidecar with hidden service routing |
One inbox, four protocols. Matrix and Telegram chats appear side by side in a single chat list, sorted by last activity. Protocol badges (MX, TG) and chat type badges (Grp, Ch) show where each chat lives and what kind it is. You never need to switch apps.
Three routing modes. Switch between Direct, Tor and I2P with one click. Tor hides your IP via onion routing with exit IP verification. I2P routes your traffic through the invisible network with zero exit nodes - traffic never leaves the encrypted overlay. Live I2P dashboard shows routers, tunnels, bandwidth in real time.
Native cryptography. Element Desktop runs vodozemac as WASM inside Chromium. SimpleGoX runs vodozemac natively in Rust, outside the WebView process. Keys never enter the browser context. This is a measurable reduction in attack surface.
Process isolation. Each messenger backend runs as a separate OS process communicating over gRPC. A crash in TDLib cannot take down your Matrix session. Telegram credentials are isolated from Matrix key material.
No server bridges. Your Telegram session runs locally via TDLib. Your keys and credentials never leave your machine. This is fundamentally different from server-mediated bridge architectures like Beeper or mautrix bridges.
Small and fast. Tauri produces a 5-10 MB installer instead of 200+ MB (Electron). Custom splash screen with animated background. Uses the system WebView instead of bundling Chromium.
Hardware roadmap. Beyond desktop, SimpleGoX targets dedicated hardware devices with NXP i.MX 93 EdgeLock Enclave, triple-vendor secure elements (NXP SE050 + Infineon OPTIGA + Microchip ATECC608B), tamper detection, physical kill switches, and a minimal verified-boot Linux. See ARCHITECTURE_AND_SECURITY.md for full details.
Svelte 5 Frontend (WebView)
|
| Tauri IPC (commands + events)
|
Tauri v2 Rust Backend
|
+-- sgx-core (Matrix via matrix-rust-sdk)
| |
| +-- Direct (HTTPS to homeserver)
| +-- Tor (Arti 0.41, SOCKS5 on port 19150)
| +-- I2P (i2pd sidecar, SOCKS5 on port 4447)
|
+-- gRPC Client --> sgx-telegram Sidecar (TDLib)
|
+-- gRPC Client --> sgx-simplex Sidecar (planned)
|
+-- gRPC Client --> sgx-whatsapp Sidecar (planned)
Frontend (Svelte 5) - UI only, no access to keys or tokens.
Tauri Backend (Rust) - Matrix client runs in-process with configurable routing (Direct, Tor, I2P). External protocols connect via gRPC to isolated sidecar binaries.
Routing Layer - Tor runs natively via Arti (Rust). I2P runs as an i2pd sidecar process with built-in SOCKS5 proxy. Mode switching is seamless - sync cancels cleanly, proxy changes, new sync starts. StatusBanner shows live progress with expandable log.
Sidecar Processes - Each non-Matrix protocol runs as a separate binary. Communicates over localhost gRPC using a shared protobuf schema (messenger.proto). Complete process isolation. The Telegram sidecar auto-starts on app launch when a saved session exists.
Protobuf Contract - All sidecars implement the same MessengerService gRPC interface. Adding a new protocol means implementing one more sidecar binary against this contract. The frontend and Tauri backend remain untouched.
- End-to-end encrypted messaging (Olm/Megolm via vodozemac)
- Cross-signing with recovery key
- Federation (tested: simplego.dev <-> matrix.org)
- Telegram message sending and receiving
- Unified chat list across protocols
- Message grouping with stacked bubbles
- Reply, reactions, edit, redact (Matrix)
- Emoji and animated emoji support (Telegram)
- Date separators (Today, Yesterday, full date)
- Protocol badges (MX, TG) on every chat
- Chat type badges (Grp, Ch) for Telegram groups and channels
- Single sorted inbox across all protocols
- Isolated sidecar architecture per protocol
- Automatic sidecar startup and session restore
- Account management (connect, disconnect per protocol)
- Telegram sender avatars in chat messages and contact list
- Three routing modes: Direct, Tor, I2P (one-click switching in Settings)
- Tor: Native Arti integration with exit IP verification displayed in banner
- I2P: i2pd sidecar with hidden service routing (zero exit nodes)
- I2P Dashboard: live stats (routers, floodfills, tunnels, bandwidth, uptime)
- StatusBanner with expandable log showing bootstrap progress
- Routing mode persists across app restarts
- Clean mode transitions with sync cancellation and process management
- Matrix homeserver reachable via I2P hidden service (.b32.i2p)
- First-time setup wizard with 5 animated phases
- Protocol selection (Matrix, Telegram, SimpleX and WhatsApp coming soon)
- Matrix homeserver selection (simplego.dev, matrix.org, or custom)
- Telegram phone/code/2FA authentication within wizard
- Animated aurora and particle background effects
- Splash screen with branding on app startup
- Wizard re-triggers automatically when all accounts are disconnected
- Custom SimpleGoX app icon (three-dot triangle design)
- Custom two-part bubble design with info bar and split line
- Circular avatars with quarter-cut effect
- Visual color picker with 2D saturation/lightness field and hue slider
- Default accent color #58a6ff with 10 presets and custom hex input
- Fullscreen settings overlay with tabbed navigation (Accounts, Appearance, Privacy, Routing, Tor, I2P, Notifications, About)
- Info tooltips on all settings options
- "Run Setup Wizard" button in About tab
- Full settings reset when all accounts disconnected
- Dark theme with sender colors (deterministic per user)
- All cryptography runs natively in Rust (not WASM)
- Encryption keys never enter the WebView process
- Each protocol isolated in separate OS process
- No server-side bridges - all connections are local
- Telegram credentials never leave the device
- Tor routing hides IP from homeserver with verified exit IP
- I2P routing keeps all traffic inside the encrypted overlay network
- Crypto store cleanup on Matrix logout (prevents device ID mismatch)
- Hardware security architecture planned (see ARCHITECTURE_AND_SECURITY.md)
- Template system - fully customizable UI themes with JSON-based templates, a visual drag-and-drop editor, and a community marketplace for sharing and downloading themes
- SimpleX protocol integration (native Rust SMP implementation)
- WhatsApp via official EU DMA interoperability
- Dedicated hardware messenger devices with secure elements
Pre-alpha software. Expect rough edges. Build instructions may change between commits. If you run into issues, please open a GitHub issue.
- Rust 1.85+ (via rustup)
- Node.js 20+ (via nodejs.org)
- Protocol Buffers compiler (
protoc): github.com/protocolbuffers/protobuf/releases - Tauri CLI:
cargo install tauri-cli --version "^2"
Windows: Visual Studio Build Tools (installed automatically by rustup). WebView2 Runtime (usually pre-installed on Windows 10/11).
Linux: sudo apt install libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev protobuf-compiler
macOS: Xcode Command Line Tools (xcode-select --install). Install protoc via Homebrew: brew install protobuf
The I2P integration requires the i2pd binary. Download from PurpleI2P/i2pd releases and place it at:
- Windows:
%LOCALAPPDATA%\simplego-x\i2pd.exe - Linux: Install via
sudo apt install i2pdor place binary in PATH
Note: Windows Defender may flag i2pd as a PUA (Potentially Unwanted Application). This is a false positive common with anonymization tools. Add %LOCALAPPDATA%\simplego-x\ to your Defender exclusions.
cd SimpleGoX
npm install
cargo tauri devThe Telegram sidecar starts automatically when a saved session exists. For first-time Telegram setup, the setup wizard guides you through the authentication flow.
Note: After cargo clean, you may need to copy tdjson.dll manually:
Copy-Item "target\debug\build\tdlib-rs-*\out\tdlib\bin\tdjson.dll" "target\debug\"cargo tauri buildOutput: .msi (Windows), .deb/.AppImage (Linux), or .dmg (macOS) in target/release/bundle/
SimpleGoX/
├── crates/
│ ├── sgx-core/ # Matrix client (matrix-rust-sdk wrapper)
│ ├── sgx-proto/ # Shared protobuf/gRPC definitions
│ └── sgx-telegram/ # Telegram sidecar (TDLib + gRPC server)
├── proto/
│ └── messenger.proto # Unified messenger service contract
├── src-tauri/ # Tauri v2 Rust backend
│ └── src/
│ ├── lib.rs # App entry, sidecar auto-start, tracing
│ ├── commands.rs # Matrix IPC commands
│ ├── routing_commands.rs # Routing mode switching (Direct/Tor/I2P)
│ ├── telegram_commands.rs # Telegram IPC commands
│ ├── tor.rs # Arti Tor integration
│ ├── i2p.rs # i2pd sidecar management
│ ├── tor_logging.rs # Tor log forwarding
│ └── sidecar.rs # Sidecar process manager
├── src/ # Svelte 5 frontend
│ ├── components/
│ │ ├── ChatLayout.svelte # Main layout with sidebar and chat
│ │ ├── ChatView.svelte # Message display with custom bubbles
│ │ ├── RoomList.svelte # Unified chat sidebar
│ │ ├── RoomItem.svelte # Individual chat entry with badges
│ │ ├── Avatar.svelte # Avatar with MXC and TG file support
│ │ ├── StatusBanner.svelte # Global status with expandable log
│ │ ├── Settings.svelte # Fullscreen settings overlay
│ │ ├── SplashScreen.svelte # Branded splash on app startup
│ │ ├── AnimatedBackground.svelte # Aurora + particle effects
│ │ ├── TelegramAuth.svelte # Telegram login flow
│ │ ├── wizard/ # Setup wizard (6 step components)
│ │ ├── settings/ # Settings tab components
│ │ │ ├── AccountsTab.svelte
│ │ │ ├── AppearanceTab.svelte
│ │ │ ├── PrivacyTab.svelte
│ │ │ ├── RoutingTab.svelte # Protocol routing configuration
│ │ │ ├── TorTab.svelte # Tor dashboard
│ │ │ ├── I2PTab.svelte # I2P live dashboard
│ │ │ ├── NotificationsTab.svelte
│ │ │ └── AboutTab.svelte
│ │ └── ui/ # Shared UI components (Tooltip, ColorPicker)
│ ├── lib/
│ │ ├── stores.js # Svelte reactive stores
│ │ └── tauri.js # Tauri command wrappers
│ └── App.svelte
├── scripts/ # Development helper scripts
├── ARCHITECTURE_AND_SECURITY.md # Security whitepaper
├── CHANGELOG.md
└── docs/
└── internal/ # Season protocols, briefings (gitignored)
SimpleGoX works with any Matrix homeserver (Synapse, Dendrite, Tuwunel, Conduit). The project maintains a public instance at matrix.simplego.dev running Tuwunel 1.5.1 for development and testing.
The homeserver is also reachable via I2P hidden service for fully anonymous connections.
SimpleGoX is designed as a complete security system from silicon to user interface. The desktop client provides native Rust cryptography outside the WebView with per-protocol process isolation. Traffic can be routed through Tor (onion routing with exit IP verification) or I2P (garlic routing with zero exit nodes) with one click.
For the complete security architecture including hardware classes, post-quantum cryptography plans, secure deletion mechanisms, competitor comparison, and certification roadmap, see ARCHITECTURE_AND_SECURITY.md.
| Phase | Focus | Status |
|---|---|---|
| Desktop Client | Matrix + Telegram multi-messenger, setup wizard, UI polish | In progress |
| Privacy Routing | Tor and I2P integration with live dashboards | Done |
| SimpleX Integration | Native Rust SMP implementation | Next |
| WhatsApp Integration | EU DMA interoperability, template system | Planned |
| Hardware Class 1 | Raspberry Pi image, dedicated terminal | Planned |
| Hardware Class 2 | Custom PCB with NXP i.MX 93, dual secure elements | Future |
| Hardware Class 3 | Vault edition with triple secure elements, tamper detection | Future |
SimpleGoX is in early development and contributions are welcome. Whether it is bug reports, feature ideas, code contributions or documentation improvements - every bit helps.
Please use Conventional Commits for all commits: type(scope): description
Examples: feat(telegram): add message pagination, fix(ui): settings border color, docs(readme): add build prerequisites
AGPL-3.0-or-later
matrix-rust-sdk (Matrix client SDK) - vodozemac (Olm/Megolm cryptography) - Tauri (desktop framework) - tdlib-rs (Telegram Database Library wrapper) - Tuwunel (homeserver) - Arti (Rust Tor implementation) - i2pd (C++ I2P implementation)
SimpleGoX is an independent open-source project by IT and More Systems, Recklinghausen, Germany.