Alice: a voice-first desktop assistant built on Electron, Vue and a Go backend

What Alice solves, and who the desktop assistant is for

Most chat interfaces are a text box in a browser tab. Alice targets the opposite shape: a persistent desktop presence that hears you, remembers earlier conversations, and can act on your machine. The README describes it as an "open-source AI companion designed to live on your desktop," and the feature list backs that framing with voice activity detection, wake-word handling, animated avatar states, and a set of computer-use tools that run against the local file system and shell.

The audience is narrow but real. If you already pay for an OpenAI, OpenRouter, DeepSeek, Z.ai, or Minimax plan and you want that model reachable by voice without switching windows, Alice is aimed at you. It also suits people who want local retrieval over their own documents: the README lists local RAG, meaning you add documents and chat with them. The torrent tooling (Jackett plus qBittorrent), Google Calendar and Gmail integration, and the Chrome extension point to a power-user profile rather than a casual one.

It is not a library. There is no published npm package to import, no server mode, and no documented HTTP API for third parties. The package is marked private in package.json, so the intended consumption path is the installer, not a dependency.

How the memory, VAD and tool-calling layers fit together

Alice splits into an Electron shell, a Vue 3 and Tailwind front end with Pinia for state, and a separate Go backend process. The build scripts confirm the split: npm run build runs build:go first, which compiles backend/ into resources/backend/alice-backend (or alice-backend.exe on Windows), then Vite builds the renderer, then electron-builder packages everything. The main entry in package.json points at dist-electron/main/index.js.

Memory is the part worth understanding before you commit. The README separates short-term context called Thoughts, stored in an Hnswlib vector database, from long-term structured facts called Memories, stored in a local database. Summarization compacts message history into context prompts, and those summaries include a mood estimate that feeds back into responses. Embeddings come from multilingual-e5-small running as ONNX at 384 dimensions, or from a cloud embedding service if you configure one. better-sqlite3 handles the structured storage.

Voice input runs through web-based VAD, then a speech-to-text model: the README names gpt-4o-transcribe, whisper-large-v3, or a local whisper.cpp model. Output goes through OpenAI or Google TTS, or Piper for local multilingual speech. Because VAD is always listening in wake-word mode, the wake word is what gates whether a request is processed at all.

Tool execution is where the design gets interesting. Shell commands, file browsing, web search, calendar access, torrent search, clipboard control, and scheduled tasks are all offered to the model as functions. Every shell command goes through an approval layer with three lifetimes: one-time, session-based, and permanent. Permanent approvals are revocable, and the README says the Settings tab "Permissions" lists everything you have approved. That is a sensible compromise between a sandbox that blocks useful work and an agent that can run anything.

Installing Alice from a release build or from source

The README points at the GitHub releases page as the primary download route, with installers for Windows (Setup.exe), macOS (Installer.dmg), and Linux (AppImage), plus a community AUR package named alice-ai-app-bin. After installing, the README directs you to docs/setupInstructions.md to configure API keys and environment. The repository root contains a .env-example file, so expect to copy it and fill in provider credentials; the README does not print the individual key names.

If you want to run from source, the development section gives three steps. The first two are the clone and the dependency install:

git clone https://github.com/pmbstyle/Alice.git
cd Alice
npm install

package.json sets engines.node to ">=22.0.0", so check your runtime before installing. The native modules better-sqlite3 and hnswlib-node need to be rebuilt against Electron's ABI, and the repository provides a script for exactly that:

npm run rebuild

That script runs npx electron-rebuild -f -w better-sqlite3,hnswlib-node. If it fails, the app will not start, because both modules are load-bearing for memory. There are also two setup helpers, setup:dependencies and setup:embeddings, which the README does not describe in detail; the names suggest they fetch native dependencies and the ONNX embedding model.

For a development loop, npm run dev starts Vite. The package.json debug block pins VITE_DEV_SERVER_URL to http://127.0.0.1:3344/, which is the address the Electron shell expects during development. A production build is npm run build, which chains the Go compile, the Vite build, and electron-builder. Tests run through vitest with npm test, using cross-env to set ROLLUP_SKIP_NODEJS_REQUIRE=1.

Once running, the first real task is to open Settings and pick a provider, then speak. In wake-word mode with a local STT model, Alice listens continuously and only acts when the wake word appears. The README does not document rollback or a reset path if a provider is misconfigured, so keep the .env values and the in-app settings consistent.

Where Alice gets in the way: cloud dependence, native builds and permissions

The README is unusually direct about the biggest limitation: "While the OpenAI cloud API is preferred and provides the best user experience, Alice can also operate fully locally (experimental)." Treat that word as load-bearing. A fully local setup means local STT through whisper.cpp, local TTS through Piper, local embeddings through multilingual-e5-small, and a local LLM through Ollama or LM Studio. Four moving parts, each with its own model download and its own quality ceiling. If your reason for choosing Alice is privacy, verify the local path end to end before you rely on it.

Native module compilation is the second friction point. better-sqlite3 and hnswlib-node are both compiled against Electron, and the rebuild step must match your Electron version, which package.json pins at 43.2.0. On platforms without prebuilt binaries this turns into a toolchain problem rather than an app problem.

The permission model is a genuine limitation as well as a feature. Approving shell execution permanently means the model can run commands of that shape later without asking. The README says approvals are revocable through the Permissions tab, but revocation is manual. There is no described policy file, no allowlist syntax, and no documented audit log beyond the list of approved commands. If you need reproducible, machine-checkable policy for agent actions, this is not that.

Finally, the integration surface assumes other software. Torrent search needs Jackett and qBittorrent running. Self-hosted web search needs Searxng. Google features need OAuth setup the README does not walk through. Each one is an external service to install and keep alive.

Alice compared with Open WebUI and other local-first chat front ends

The closest category is a self-hosted chat front end such as Open WebUI, which runs as a web application you reach through a browser and typically deploy alongside Ollama. The difference is architectural, not cosmetic. Open WebUI is a server: one process, many clients, reachable from any device on your network. Alice is a single-user Electron application whose Go backend exists to serve that one desktop instance. You cannot point a phone at Alice.

That shapes what each is good at. A server-based front end handles document collections, multi-user accounts, and model switching without touching your machine's shell. Alice handles the opposite: microphone input with voice activity detection, an animated avatar, clipboard and file system access, and scheduled commands that run on your desktop. Retrieval exists in both, but Alice's is wired into a memory model with short-term Thoughts and long-term Memories rather than a flat document index.

The permissioned shell is the sharpest divergence. A browser-based front end generally cannot run ls or mv on your behalf. Alice can, with explicit approval, which is useful and also the reason to think carefully about the session and permanent approval options. If your work is mostly document question answering over a shared corpus, a server front end is the better fit. If your work is voice-driven desktop actions, Alice is doing something the server model does not attempt.

Maintenance, release cadence and what the MIT licence covers

The repository is not archived, and the last push was on 2026-09-01. Releases are recent and versioned: v1.5.0 on 2026-08-05, v1.4.4 on 2026-06-05, and v1.4.3 on 2026-05-18. The gap between 1.4.4 and 1.5.0 is two months, and the gap before that is about two and a half weeks. That is a steady cadence rather than a burst, though the README does not publish a support policy, a deprecation window, or a compatibility matrix for the providers it lists.

Upgrade cost is concentrated in two places. First, the native modules: every Electron bump can require a fresh electron-rebuild, and the rebuild script is the documented remedy. Second, configuration drift: providers, model names, and tool settings live in the app's settings interface and in the .env file, and the README does not describe a migration path between versions. Back up user-customization/ and custom-tool-scripts/ before upgrading, since those directories hold avatars and custom tool scripts that are not part of the release artifact.

The licence is MIT, which permits commercial and private use, modification, and redistribution provided the copyright notice and permission notice are retained. That is permissive, but it says nothing about the third-party services Alice connects to. Your OpenAI, OpenRouter, DeepSeek, Z.ai, or Minimax usage is governed by those providers' terms, not by the MIT grant, and local models such as whisper.cpp, Piper, and multilingual-e5-small carry their own licences. Check each one for your distribution scenario; this is not legal advice.

Editorial conclusion

Adopt Alice if you want a desktop assistant that listens continuously, keeps short-term and long-term memory in local databases, and lets you approve shell commands one time, per session, or permanently from the Permissions tab. Skip it if you need a headless server component, a stable plugin API, or a fully local setup without experimental caveats: the README labels fully local operation experimental and says the OpenAI cloud API is preferred. Before committing, verify that your Node runtime is at least 22.0.0, that electron-rebuild succeeds for better-sqlite3 and hnswlib-node on your platform, and that a packaged build actually starts the Go backend binary for your OS.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. pmbstyle/Alice on GitHub
4. README
5. Releases