- Rust 57.5%
- TypeScript 23.2%
- CSS 15.4%
- Kotlin 1.6%
- HTML 1%
- Other 1.3%
| Filename | Latest commit message | Latest commit date |
|---|---|---|
| apk-dist | ||
| scripts | ||
| src | ||
| src-tauri | ||
| .dockerignore | ||
| .gitignore | ||
| docker-compose.yml | ||
| Dockerfile.dev | ||
| index.html | ||
| LICENSE | ||
| package-lock.json | ||
| package.json | ||
| PLAN.md | ||
| README.md | ||
| tsconfig.json | ||
| vite.config.ts | ||
Extrovert Mobile
A native Extrovert client for Android (now) and iOS / Linux (arm64 phones) / macOS (next), built with Tauri v2 + Rust and vodozemac for end-to-end encryption.
The UI reuses the website's own theme.css, fonts, icons and rings motif, so it
looks like Extrovert — just re-flowed for a phone.
Licensed GPL-3.0-or-later, like Extrovert itself (this project reuses its design assets and links against its API).
Status
P0 (scaffold), P2 (E2EE + DMs), P3 (realtime + social), P4 (rooms + Megolm) and P5 (calls + Android) are complete and verified.
-
Calls: 1:1 audio over WebRTC, with signing relayed through the Rust gateway (the WebView never sees a token). Full state machine —
call_request→callee_available,call_offer→incoming_call,call_answer, ICE relay,call_end/decline, busy/offline handling — plus presence, ICE config, and the native push channel for offline-call wake-ups including decline-by-token. -
Android: the project is initialised, and
tauri android build --debug --apk --target aarch64produces an installable APK. A Kotlin foreground service keeps the push socket alive while backgrounded; Tauri already grants WebView mic permission (RECORD_AUDIO). -
Rooms: create/join/leave, channels, roles, join requests, invites, kicks — plus Megolm group encryption: a per-device outbound session, keys wrapped for every member device over 1:1 Olm, the
session/syncround trip (publish → pending → ack → share), and decryption of history and live messages. Room keys are shared only with members who lack a real key, using themissing_for_sessionbundle filter. -
Realtime gateway (
realtime.rs): connects withauto_subscribe=1, 30 s ping, reconnects withresumeso no events are lost, and forwards every frame to the WebView as typedextrovert://gatewayevents. Auth rides in the handshakeAuthorizationheader, never the URL. -
Social surface: feed with cursor pagination, create/edit/delete posts (text + photo/video), likes, reposts, comment threads, edit history, profiles with inline editing, follow/unfollow, search, friend-of-a-friend discovery, notifications, and the announcement banner.
-
Optimistic UI: posts and comments are sent with a
client_idand reconciled against the gateway echo.
Earlier phases:
- Tauri v2 + Vite/vanilla-TS app shell, bottom tab bar, safe-area handling;
- the site's
theme.css, variable fonts (trimmed to latin + latin-ext), icon set and rings SVG copied in; extrovert-core: typed/api/v1models, encrypted on-device store, REST client, and a full Olm (vodozemac) implementation — device registration, prekey publish/top-up, bundle claim, the web client'sv:2envelope, the self-session copy, and safety numbers;- auth: token sign-in and device pairing (
pair/init→pair/claim, single-use),/client/bootstrap, sign-out, cold-start session restore; - encrypted DMs: conversation list, decrypting thread view (with local plaintext cache), compose, delete, safety number, and Additional-Security toggle/ack;
- tests: unit + libolm golden vectors, cross-implementation interop (vodozemac ⇄ libolm, both directions), and live server tests.
Most importantly, the DM encryption is verified interoperable with the website: a native Rust client and the website's libolm engine decrypt each other's messages in both directions.
Still to do: rooms/Megolm (P4), calls/voice (P5), and the Android/iOS/desktop
builds (P6). See PLAN.md.
Architecture
src/ frontend (vanilla TS) — views only, no tokens, no keys
main.ts router.ts state.ts api.ts dom.ts
views/ components/ styles/ fonts/ vendor/
src-tauri/ Tauri shell (thin)
src/lib.rs #[tauri::command]s + state
core/ extrovert-core — reusable, Tauri-free
models.rs serde types for every /api/v1 payload
net.rs REST client
store.rs AES-256-GCM on-device store
olm.rs vodozemac Olm + Megolm sessions and the v:2 envelope
client.rs device + HTTP orchestration (DMs and rooms)
realtime.rs WebSocket gateway client (auto-subscribe, resume, ping)
e2ee.rs safety numbers
Secrets (bearer tokens, and later Olm/Megolm pickles) live in extrovert-core;
the WebView only calls typed commands. REST and the realtime gateway are handled
in Rust so no bearer token ever reaches JavaScript.
Prerequisites
- Rust (stable) and Node 20+
- Tauri Linux build deps (only for a local desktop build; use Docker otherwise):
libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev libsoup-3.0-dev - For Android: the Android SDK/NDK + JDK 21, then
npm run android:init
Develop
npm install
npm run dev # Vite dev server (frontend only, in a browser)
npm run tauri dev # full desktop app (needs the Linux deps above)
Point the app at a server on first launch (defaults to
https://extrovert.redforged.eu) and sign in with a Personal Access Token or a
pairing code.
Build
npm run build # typecheck + bundle the frontend
npm run tauri build # desktop bundle
npm run android:build # Android APK/AAB (needs the Android SDK)
Android setup (one-off)
The toolchain lives entirely in your home directory — no root needed:
# 1. Command-line tools (pick the latest build from developer.android.com/studio)
curl -Lo cmdline-tools.zip https://dl.google.com/android/repository/commandlinetools-linux-<BUILD>_latest.zip
mkdir -p ~/android-sdk/cmdline-tools && unzip -q cmdline-tools.zip -d ~/android-sdk/cmdline-tools
mv ~/android-sdk/cmdline-tools/cmdline-tools ~/android-sdk/cmdline-tools/latest
# 2. Packages + NDK
export ANDROID_HOME="$HOME/android-sdk"
export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$PATH"
yes | sdkmanager --licenses
sdkmanager "platform-tools" "platforms;android-35" "build-tools;35.0.0" "ndk;29.0.14206865"
# 3. Rust targets
rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android
# 4. Generate the project and build (JDK 21 + NDK_HOME required)
export NDK_HOME="$HOME/android-sdk/ndk/29.0.14206865"
export JAVA_HOME=/usr/lib/jvm/temurin-21-jdk-amd64
npx tauri android init --ci
npx tauri android build --debug --apk --target aarch64
# → src-tauri/gen/android/app/build/outputs/apk/universal/debug/app-universal-debug.apk
The generated src-tauri/gen/android project is checked in deliberately — it
carries the mic/notification permissions, the PushService foreground service
and MainActivity changes that call wake-ups depend on.
Signed release build
Create a keystore once, then put its path and credentials in a gitignored
src-tauri/gen/android/keystore.properties:
storeFile=release.keystore
storePassword=…
keyAlias=extrovert
keyPassword=…
app/build.gradle.kts reads that file into a release signing config (release
builds are left unsigned when it is absent). Then:
npx tauri android build --apk --split-per-abi --target aarch64
# → app/build/outputs/apk/arm64/release/app-arm64-release.apk (~20 MB)
Keep the keystore and its password. Losing them means you can never update
the app under the same identity. Note the release build sets
usesCleartextTraffic=false, so it only talks to https:// servers — use the
debug build to test against a plain-http dev instance.
Test
Fast, hermetic:
npm run build # tsc + vite
cargo test --manifest-path src-tauri/Cargo.toml -p extrovert-core --lib
# Cross-implementation E2EE interop (vodozemac <-> libolm, both directions):
sh scripts/interop-libolm.sh
Against a real, seeded server:
./scripts/dev-server.sh # clones Extrovert into .dev/ and starts it
# or let the runner start the server and run everything (recommended):
sh scripts/run-live-tests.sh
scripts/run-live-tests.sh runs both the upstream client suites and the native
ones (bootstrap/pairing, DMs, realtime gateway, social surface) against a seeded
server, and fails loudly if the environment is half-configured.
The seeded fixtures are alice / bob / charlie (password123), room
Town Square, and deterministic PATs.
Building without host toolchain
Dockerfile.dev has everything (Tauri deps + Rust + Node):
docker build -f Dockerfile.dev -t extrovert-mobile-dev .
docker run --rm -v "$PWD":/app -w /app/src-tauri extrovert-mobile-dev cargo check
Known upstream issue
src/webrtc-signaling.js:946 in the Extrovert server dereferences user.id on
WebSocket close without checking that the socket authenticated first, so a
connection to /ws that closes before authenticating can crash the process.
It's a server-side robustness bug (fix: if (!user) return; in the close
handler) and does not affect the client. Reported here for upstream.
License
GPL-3.0-or-later. See LICENSE.