Universal multi-provider LLM chat client for Android, Windows and Linux — dark, fluid, secure. Windows and Linux builds are beta for now — Android is the primary platform.
Arcade AI is a single mobile app that talks to any large language model. Drop in an API key, pick a provider, choose a model — and chat. From global giants (OpenAI, Anthropic, Google) to Russian platforms (GigaChat) to your own endpoint
Black canvas · violet aurora · buttery animations
Built on pure stubbornness and one heroically dying USB stick. 12 providers — and this time they actually work (we checked).
- 12 built-in providers + a fully custom one (any OpenAI- or Anthropic-compatible endpoint).
- Streaming responses — text appears token by token, like the web chats.
- Reasoning view — for thinking models (o-series, DeepSeek R1, Claude with extended thinking) a collapsible panel shows how the model reasoned before answering.
- Vision — attach photos to your message where the model supports it.
- Browser (beta) — paste a link into your message and the app downloads the page itself, strips the HTML and hands the clean text to the model. Even a tiny local model (1B on Ollama) can "read the web". Toggle it in settings; the per-page text limit is adjustable (8000 chars by default), and the chat shows only a compact "🌐 site · size" chip.
- Compare two models — long-press Send to ask two models the same prompt side by side, then keep the better answer and continue with it.
- Bilingual UI — English / Russian, picked on the welcome screen, switchable later.
- Security first — API keys live in the hardware-backed Android Keystore (AES-GCM); optional biometric auto-lock on reopen.
- Crafted design — pure-black surfaces, restrained violet accents, an animated aurora background, and motion on every meaningful transition.
| Global | Russian / Regional | Local & custom |
|---|---|---|
| OpenAI, Anthropic, Google Gemini, Groq, DeepSeek, xAI Grok, Mistral, Together AI, OpenRouter, Cohere | GigaChat (Sber) | Ollama, any custom endpoint |
GigaChat uses Sber's OAuth: paste your Authorization key (Base64) and the app fetches and refreshes the short-lived access token for you. Sber's Russian root CA is trusted for
*.sberbank.ruso requests don't fail on TLS.
Local models (Ollama) connect to a running Ollama server over HTTP (
localhost:11434) — the app does not load.gguffiles directly. True on-device GGUF inference (pick a file, run it on the phone via llama.cpp) is on the roadmap, not in this build.
This started as a "mix the languages to look cool" idea. The honest engineering answer shaped the final stack:
-
Dart + Flutter — the whole app. Flutter is Dart's killer capability: one codebase compiled to native ARM, a self-rendered UI (Skia/Impeller) that looks pixel-identical on every device, and sub-second hot reload. For a polished, heavily-animated single-screen-flow app, nothing else gets you there faster.
-
No Rust (yet) — and that's the secure choice. The instinct was to add Rust for "security via custom encryption." But hand-rolled crypto is a liability; the Android Keystore stores keys in a hardware security module where the secret never leaves the chip — strictly stronger than app-level AES. The app is network-bound (it waits on API calls), so there is no CPU hotspot for Rust to accelerate. Rust earns its place the day we add on-device local inference — that's a real compute task, and it's the planned hook for it.
The principle: every language must pull its weight, not pad a buzzword list.
Working. The setup writes OpenCode's config file (
~/.config/opencode/opencode.jsonc) with your provider, base URL, key and model, so OpenCode runs on your model instead of falling back to the free built-ins. Still young — treat the terminal as an early feature — but the core "your provider in OpenCode" flow works.
A separate Terminal (BETA) screen (open it from the chat drawer) turns the app into a thin client for an agentic coding session running on your own machine — no servers on our side. The idea: bring your own compute (a VPS, a home PC, a Raspberry Pi) over SSH and run OpenCode from your phone.
Flow:
- Pick your data (the app's active provider + key + base URL + model) or Free (OpenCode's built-in free models, no key).
- Enter the machine: host / user / port / password (saved encrypted in the Keystore, optional).
- Choose a run mode — with confirmation or auto (no confirmation).
- A clean step-by-step setup runs in the background (connect → detect package manager → install Node/git → install OpenCode → launch). The raw install output is hidden; on failure there's a collapsible log + retry.
- OpenCode's TUI is rendered in a real terminal emulator (
xterm) over the SSH shell, with quick keys (Esc/Tab/Ctrl-C, Ctrl+letter, arrows), paste, and a "manual terminal" mode for power users.
Built on dartssh2 (SSH client) + xterm (terminal emulator) — the SSH protocol
and the emulator are libraries; the app is the glue + provisioning + UI.
Known rough edges:
- Your provider/key/URL/model are written into OpenCode's config file, so it uses your model. Pick My data for that, or Free for OpenCode's built-in models.
- The auto/bypass mode uses a best-effort env var; the exact flag may vary by OpenCode version.
- Reachability: same LAN works; a machine behind NAT needs Tailscale / a public IP / port forwarding.
- Installing packages needs root or passwordless sudo; otherwise the install prompts for a sudo password in the terminal.
lib/
├── core/ theme, global app state (ChangeNotifier)
├── models/ provider, chat message, generation config
├── data/ provider catalog · Keystore key store · settings
├── services/ streaming LLM client (OpenAI + Anthropic shaping)
├── ui/
│ ├── onboarding/ language → provider grid → connect form
│ ├── chat/ chat screen · model switcher
│ ├── settings/ settings · biometric lock screen
│ └── widgets/ ambient background · bubbles · reasoning block
└── l10n/ EN / RU strings
flutter pub get
# Android (requires the Android SDK; minimum Android 6.0 / API 23)
flutter build apk --release
# output: build/app/outputs/flutter-apk/app-release.apk
# Windows (run on a Windows machine with Visual Studio)
flutter build windows --release
# Linux
flutter build linux --releaseRequires Flutter (stable). Windows and Linux users don't need to build
anything — every release ships ArcadeAI-Setup-x.y.z.exe (a regular
installer: Program Files, Start menu shortcut, uninstaller; built
automatically by GitHub Actions from .github/workflows/windows.yml +
windows/installer.iss) and ArcadeAI-x.y.z-amd64.deb (packaged by
tool/build_deb.sh). Both desktop builds are beta: the core chat works,
but they get less testing than Android.
| Concern | Approach |
|---|---|
| API keys at rest | Android Keystore via flutter_secure_storage (AES-GCM, hardware-backed) |
| App reopen | Optional biometric / device-credential lock (local_auth) |
| Network | HTTPS to providers; cleartext allowed only for localhost (Ollama) |
| Telemetry | None — the app talks only to the provider you configure |
MIT — see LICENSE.
Built by github.com/NickIBrody