Voxal

Instant push-to-talk voice rooms. No accounts. No installation. No server required.

	Home	Audio call
Dark
Light

Video call with an animated virtual background (the Lagoon deck, lit by night or by day):

Dark	Light

Get Started

🌐 Try in a browser

💻 Download Desktop App

📡 Join the Presence Portal

🎬 Watch Voxal in 30 seconds

Why Voxal?

• Pure P2P voice (WebRTC full-mesh audio) — never routed through a media server, under any setting
• Push-to-talk first UX on every platform
• Host migration keeps rooms alive when the host leaves
• No account required to create or join rooms
• No mandatory backend (optional presence only)
• Desktop + iOS + Android + Web from one shared frontend
• Open source and self-hostable signaling for production control

Features

Voice

• Peer-to-peer voice conversation - WebRTC audio mesh (Opus, 16 kHz mono)
• Push-to-talk with background mode - Global shortcut on desktop; touch PTT on mobile/web; hands-free mode when you'd rather not hold anything
• Noise suppression - RNNoise in a WebAssembly AudioWorklet, the browser/OS suppressor, or off — switchable mid-call
• Audio tuning - Adjustable jitter buffer (adaptive or a fixed 0–500 ms), mic and speaker device pickers, and speaker/earpiece switching on mobile
• Echo test - Hear your own outgoing audio, locally or round-tripped over the network, before you rely on it
• TURN / STUN support - for NAT/firewalls traversal, with short-lived credentials minted for anonymous users (details)

Video & screen sharing

• Video stage - A real video layout that adapts to the room: tiles that reflow with the split, an overflow ribbon, a self-view you can park in any corner, on-tile camera flip, and an immersive full-screen stage on phones and the native apps
• Screen sharing - Optional per participant (desktop/web; not on native mobile)
• Camera backgrounds - Blur, six animated scenes (office, island, cyber café, mountain, countryside, neon rain), your own image, a 360° panorama or a 3D model. The scenes are real-time 3D worlds — ray-marched landscapes and rooms with a sun, volumetric clouds, mirror water and wet glass — generated on your GPU with no assets, and relit to match your own light — your shadow falls on the wall behind you. Segmentation runs locally in WebAssembly on your own GPU — no frame is ever sent anywhere to compute it. With Let others draw my scene (on by default, switch it off in Settings → Video), on a direct connection, a peer whose device can draw the scene is sent just you over flat green and renders the scene itself, and your camera is sent to it under a lower bitrate cap (details)
• Optional SFU for video - Camera and screen-share can route through Cloudflare's Realtime SFU once a room outgrows a comfortable mesh — the default past two participants, switchable to direct-only in Settings → Advanced. It applies to video only and never touches voice (details)

Rooms & platforms

• Room keep-alive via host migration - Deputy/successor handoff with authoritative peer lists (deep dive)
• Multi-platform support - Web, macOS/Linux/Windows (Tauri), iOS/Android (Capacitor)
• Responsive everywhere - Landscape web layout with a left/right-handed talk button; native apps stay portrait-locked
• Embeddable - Drop a room into any page as an iframe, including a compact "tiny" mode with a postMessage bridge (details)
• Optional presence - Named channels and org rooms through the presence portal, with sign-in that works the same on web and native

Diagnostics (dev mode)

• Device panel - Per-participant OS, CPU, memory, battery, mic and link stats, filled natively on desktop where the WebView can't see them
• Remote log streaming - Stream a peer's console to help debug, behind an explicit per-session consent prompt that auto-expires
• Network usage - Live bandwidth broken down by voice, camera and screen, with a ten-minute history, in Settings → Advanced

Experimental features

• Dynamic Island PTT (iOS) - PushToTalkUI integration; requires a paid Apple Developer membership and is unverified on-device (details)

What Makes Voxal Different?

Voxal combines push-to-talk simplicity with peer-to-peer resilience across desktop, mobile and web.

Most peer-to-peer voice applications stop working when the host disconnects. Voxal automatically elects a successor and keeps the room alive without reconnecting participants (deep dive).

And voice stays peer-to-peer permanently. A TURN relay only ever forwards opaque encrypted DTLS-SRTP; an SFU has to decrypt media to forward it selectively, which is why camera and screen-share may use one in larger rooms but audio never does, under any setting (the distinction, in full).

Use Cases

• Gaming communities
• Remote teams and standups
• Event staff coordination
• Family voice rooms
• Temporary project channels
• Lightweight emergency communication

Architecture Overview

Signaling topology : star  (host ↔ peers via PeerJS DataConnection)
Audio topology     : mesh  (peer ↔ peer via WebRTC MediaConnection) — always, never server-routed
Video/screen       : mesh by default; optionally through Cloudflare's Realtime SFU
Codec              : Opus (16 kHz mono)

Room flow (high level):

1. Host creates a room (host PeerJS ID becomes the room join target).
2. Joiners connect to the host signaling channel and receive peer state.
3. Peers open direct audio links to each other.
4. Camera and screen-share form their own independent link sets, which selectVideoTopology() may route through the SFU instead.
5. If host disconnects, successor/deputy migration elects a new host without dropping active media links.

See it drawn: topology diagrams — the join sequence, star vs. mesh at four people, what each server sees, host migration, and how video changes above two participants. Room Lab lets you build a room yourself and watch the links form, and the flow explorer walks the same system component by component.

Documentation

• Architecture & protocol
• The 30-second film — watch it, or export it as MP4/WebM in 16:9, 1:1 or 9:16 (source: docs/promo.html)
• Topology diagrams — voice room, two-peer video, larger rooms (source: docs/topology.html)
• Architecture flow explorer (source: docs/architecture.html)
• Room Lab — build a room and watch the links form (source: docs/topology-lab.html)
• Host migration deep dive
• Video routing — mesh vs. SFU, and why audio never relays
• Camera background effects
• TURN & ICE configuration
• Benchmark results — what a room costs (, method: )

Contributing

Contributions are welcome. For local development:

git clone https://github.com/ErwannRobin/Voxal.git
make install
make dev
make test

If you modify files under src/, sync assets for mobile builds with make cap-sync.

Command	What it does
make install	Installs Node deps and fetches Rust crates (with setup preflight checks)
make dev	Starts the Tauri desktop app with hot reload
make run-web	Serves the web app at http://localhost:8080
make test	Full suite: Rust type-check + Rust tests + API tests + Playwright E2E
make test-e2e	Fast Playwright E2E only (pure-logic and UI flows)
make test-mesh	Multi-peer WebRTC E2E against a real local PeerServer
make lint	ESLint over all JavaScript + cargo fmt --check
make coverage	Rust + E2E + API coverage reports, summarised in one table
make coverage-badge	Re-measure main.js and rewrite the coverage badge above
make bench	Performance benchmark: voice and camera, real WebRTC, no thresholds
make bench-publish	Put the newest benchmark run into the published results

make test is what CI gates on: main takes no merge whose tests are not green (how that is enforced). The multi-peer make test-mesh suite is kept out of it so the fast path stays deterministic — run it when you touch signaling, the audio mesh, or host migration.

Git hooks

npm install (and so make install) points git at the repository's own hooks in .githooks/ by setting core.hooksPath. Nothing to do by hand; make hooks re-enables them if you ever need to. They catch what CI would reject before it costs a CI run. CI still runs everything and stays the real safety net.

Hook	Runs	Time
pre-commit	On staged files only: ESLint for JS, JSON validity, rustfmt --check for Rust, conflict markers/whitespace	~2 s
pre-push	Only what your pushed commits touch: API tests (api/), Rust tests (src-tauri/), a Swift syntax check (ios/**/*.swift, macOS only). Pushes that only change src/ or docs run nothing. No E2E: a push that edits tests/e2e/*.spec.js just prints a reminder to run make test-e2e-changed (CI runs the suite; PREPUSH_E2E=all runs it in the hook anyway)	seconds

The mesh suite is never run by a hook (slow, timing-sensitive; CI runs it). pre-push tests the working tree, so stash unrelated edits if you want the result to describe exactly what you push.

Emergency bypass: git commit --no-verify / git push --no-verify skips the hook for that one command. CI will still check the change.

License

MIT - see LICENSE.