When we started building Voidcom, the first decision wasn’t what features to build — it was what technology to build them with. That choice would define everything: performance, reliability, developer velocity, and ultimately, the experience you get as a user.

Why Rust for the server

Most communication platforms run their servers on Go, Java, or Node.js. We chose Rust, and here’s why:

Memory safety without garbage collection. Rust’s ownership model eliminates entire categories of bugs — use-after-free, data races, null pointer dereferences — at compile time. For a server handling thousands of concurrent voice and text connections, this matters enormously. No GC pauses. No unexpected latency spikes.

Massively concurrent. Rust’s async runtime handles millions of concurrent tasks without the overhead of OS threads. All our server communication — signaling, voice transport, everything — runs on the same efficient async foundation.

The right tool for real-time. Voice is unforgiving. A few milliseconds of jitter and the audio quality degrades noticeably. Rust gives us the deterministic performance we need for low-latency audio.

The server architecture

Our server isn’t a monolith — it’s a focused set of services:

  • API signaling handles authentication, channels, chat, friends, presence, roles, and moderation
  • Voice server forwards audio and video packets with minimal latency — no mixing, just selective forwarding so the server never decodes your audio
  • PostgreSQL stores relational data (users, servers, roles)
  • ScyllaDB handles time-series data (messages, reactions, call history)
  • Valkey manages ephemeral state (cache, sessions, presence, rate limiting)
  • NATS real-time pub/sub for multi-instance deployment (implementation ready, wiring in progress)
  • Typesense powers full-text search

Every backend is feature-flagged. You can run the server with just an in-memory store for development, or spin up the full infrastructure stack for production.

Why Flutter for the desktop client

Flutter might seem like an unusual choice for a desktop app. Here’s why it works:

Native compilation. Flutter compiles to native machine code — not JavaScript, not a web view. The result is a desktop app that starts fast, uses less memory than Electron alternatives, and renders at 60fps on the GPU.

Single codebase, multiple platforms. We’re targeting Windows first, with Linux, Android, and web coming next. Flutter lets us ship to all of them from one Dart codebase without sacrificing native feel.

Native audio engine. The voice engine is written in Rust and compiled to a native library. The desktop app calls into it directly — giving us the full power of native audio capture, studio-quality encoding, and end-to-end encrypted voice without any browser overhead.

The voice pipeline

Here’s how audio flows from your microphone to your teammate’s speakers:

  1. Capture — your microphone audio is grabbed at 48kHz
  2. Encode — the audio is compressed into frames (~48–256 kbps depending on quality preset, frame sizes from 5ms to 20ms)
  3. Encrypt — the packet is encrypted with the channel’s per-channel key (XChaCha20-Poly1305)
  4. Transport — the encrypted packet is sent to the server over QUIC
  5. Forward — the server routes the opaque packet to everyone in the voice channel (no mixing, no decryption — the server can’t read the audio)
  6. Decrypt — the packet is decrypted with the shared channel key on each listener’s device
  7. Decode — the audio is decompressed
  8. Playback — the audio plays through your teammates’ speakers

The entire pipeline is designed for one thing: getting your voice to your teammates as fast and clearly as possible.

Why not Electron?

Electron apps are web pages running inside a bundled Chromium browser. That means:

  • Hundreds of megabytes of RAM just to run the app (Discord uses ~450 MB across its processes)
  • Higher CPU usage from the JavaScript runtime and browser rendering engine
  • More latency from the additional abstraction layers

Voidcom’s Flutter client uses a fraction of that. It’s not a browser — it’s a compiled native application.

The trade-off

Rust and Flutter are harder to develop with than JavaScript and Electron. The compile times are longer. The ecosystem is younger. But the result is a communication app that’s genuinely faster, more secure, and more efficient than the alternatives.

We think that trade-off is worth it. And we think you’ll feel the difference.