A small voice assistant for your desk that you put together yourself.
Say "Orion", ask in Arabic or English, and it answers out loud.
You do not need to write code or install developer tools. Three steps:
1. Get the board. Orion runs on the LilyGO T-CameraPlus-S3. You also need a USB-C cable that carries data (not a charge-only one). The printed case is optional.
2. Put Orion on it. Connect the board to your computer with the cable, then:
-
Windows 10 or 11: download
flash-orion.bat(on that page, use the download button at the top right of the file) and double-click it. That one double click is the whole install. If Windows says it protected your PC, choose More info, then Run anyway. -
Linux or macOS: open a terminal and paste the line below. macOS is supported by the same script but has been tested less than Linux.
bash <(curl -fsSL https://raw.githubusercontent.com/MultiX0/orion/main/tools/install/flash-orion.sh)
The installer finds the board, gets Espressif's flashing tool, downloads the latest Orion firmware, checks it against the release's checksum, and writes it. You do not need Python: when it is missing, the installer uses the standalone esptool that Espressif publishes. It takes a few minutes and needs no admin rights. If it cannot find the board, try another cable, or hold the BOOT button on the side of the board, tap RST, let go of BOOT, and run it again. More in tools/install.
3. Open the app. Get the Orion app for Android or Windows (on Windows, run Orion-1.0.0-windows-x64-setup.exe; no admin rights needed) and tap Find my Orion. The app finds the board over Bluetooth, gives it your Wi-Fi, and asks for two keys:
- a Fish Audio key, for Orion's voice and hearing,
- a key for the model that does the thinking. DeepInfra is the default; any OpenAI-compatible provider works.
When the board shows its idle screen, say "Orion".
Orion is a voice assistant that lives on a small board with a screen, a camera, a microphone and a speaker. It listens for its name on the board itself, so nothing leaves your home until you call it. Then it hears your question, thinks, and speaks the answer, in Arabic or English, in its own voice.
It works on its own once it is set up: plug it into any USB charger and it is ready. Leave the Orion app open on your PC or phone and it can do more: open apps, play music, look things up on the web, check how your computer is doing, and remember what you talked about.
Things you can say:
- "Orion, what's the weather in Amman tonight?"
- "Orion, what do you see?" (it takes a picture with its camera and describes it)
- "Orion, open Spotify and play something calm."
- "Orion, how is my PC doing?"
- "أوريون، احسب ١٢٨ ضرب ٤٦"
- "أوريون، شو هاد؟"
On the board
- A custom wake word, "Orion", trained for Arabic and English speakers and run on the board with TensorFlow Lite Micro.
- Speech in and out through Fish Audio, in Orion's own voice. Any OpenAI-compatible speech endpoint can be used instead.
- Answers stream: Orion starts speaking the first sentence while the rest is still being written.
- A camera it can look through when you ask what it sees.
- A 240x240 touch screen with an animated orb for listening, thinking and speaking, a push-to-talk button, and a menu for Wi-Fi setup and factory reset.
- Works with any OpenAI-compatible model: DeepInfra, OpenAI, Anthropic, Groq, OpenRouter, Ollama on your own network, or a custom endpoint.
With the app
- Setup over Bluetooth, with each key checked against the real service before it is saved. A board that is already on your Wi-Fi pairs over the network with a six digit code from its screen.
- Talk or type to Orion, watch its camera live, and read past conversations.
- PC control on Windows: open and close apps, control media, read system stats, take a screenshot and describe it, find files, search the web. Bigger multi-step jobs go to DeepSeek Harness, an agent that works in a sandbox folder.
- Three levels of trust for the PC: off, ask me first, or act on your own. Every action is logged.
- Phone as a helper: with the app open, Orion can open links and apps on your phone.
- Memory: with the PC app connected, Orion remembers recent turns and what it did, so "pause it" knows what "it" is.
Privacy
- The wake word runs on the board. Audio goes out only after you say "Orion".
- No Orion account, no Orion cloud, no subscription. Nothing passes through a server of ours.
- Keys live in the board's own storage and in your system keychain, and are sent only to the board you paired with and the services they belong to.
A single voice turn:
sequenceDiagram
autonumber
actor You
participant Board as Orion board
participant Fish as Fish Audio
participant Brain as Brain (PC app, phone app, or the board)
participant Model as Language model
You->>Board: "Orion"
Note over Board: Wake word heard on the board.<br/>The orb starts listening.
You->>Board: your question
Board->>Fish: recorded speech
Fish-->>Board: text
Board->>Brain: the question
Brain->>Model: chat request, with tools when a PC or phone is linked
Model-->>Brain: answer, streamed
Brain-->>Board: answer, streamed
loop each sentence
Board->>Fish: text
Fish-->>Board: speech, streamed
Board-->>You: Orion speaks
end
The brain is whichever is available first: the PC app when PC control is on, then a linked phone, then the board itself calling the model directly. The PC and phone add tools, the web, the time and a memory of the conversation; the board alone can still answer anything the model knows and look through its camera.
More detail in docs/ARCHITECTURE.md, docs/DEVICE_PROTOCOL.md and docs/HARNESS.md.
Photos by LilyGO, from the T-CameraPlus-S3 repository.
Orion is written for the LilyGO T-CameraPlus-S3. Everything it needs is on the one board:
| Part | On the board |
|---|---|
| Processor | ESP32-S3, dual core, Wi-Fi and Bluetooth LE |
| Memory | 16 MB flash, 8 MB PSRAM |
| Screen | 1.3 inch 240x240 (ST7789) with capacitive touch (CST816) |
| Camera | OV2640 |
| Microphone | MP34DT05 digital microphone |
| Sound | MAX98357 amplifier and a small speaker on the Audio socket |
| Power | USB-C, with a battery charger (SY6970) |
| Buttons | Push-to-talk on the front, BOOT and RST on the side |
Buy it from LilyGO. Board documentation and schematics are in LilyGO's repository. Flashing, updating and resetting are covered in docs/FIRMWARE.md.
A two-part case with a desk stand, made for version 1.2 of the board. The screen sits behind a thin lip, the push-to-talk button gets its own plunger, the microphone and speaker have sealed channels, and the Wi-Fi antenna has a pad of its own. White star and wordmark inlays finish the front and back.
Heads up: the measurements of the 3D case model are not fully accurate yet, and we are working on a fix. Print the two small fit-test parts in
case/fit_testfirst and check the fit on your board before you print the whole case.
- Print in PLA or PETG, 0.2 mm layers, no supports. Never use carbon fibre, metal-filled or conductive filament: it blocks Wi-Fi.
- STL files are in
case/stl. A multi-colour printer can usecase/orion_case.3mf, which has the white logos in place, and the whole assembly opens in Blender fromorion_case.blend(also incase/). - You also need four M2 x 16 self-tapping screws and four small rubber feet.
Dimensions, print settings and assembly order: case/SPEC.md. The whole case is generated from case/cad/params.py, so a measurement change is one edited number.
One Flutter app for Android and Windows. It sets the board up, shows what Orion is doing, and on Windows lets Orion use your PC.
From the app itself:
Most people never need this; the installer and the app releases cover everything. If you want to change Orion:
| Part | What you need | Start here |
|---|---|---|
| App | Flutter stable | flutter pub get, dart run build_runner build --delete-conflicting-outputs, flutter run. No board yet? dart run tool/mock_device/main.dart runs a pretend one. iOS is set up in the same code but has not been built or tried on a device yet, so there is no iOS release. |
| Firmware | ESP-IDF v5.5.5 | idf.py build in firmware/. See docs/FIRMWARE.md. |
| Wake word | Python, WSL2 on Windows | wakeword/README.md |
| Case | Python with build123d, Blender for renders | case/SPEC.md |
Further reading: docs/ARCHITECTURE.md for how the app is organised, docs/PROVIDERS.md for model and voice settings, docs/UI.md and brand/ for the look, and docs/CODE_STYLE.md for how code is written here.
Orion is written down well enough for an AI assistant (ChatGPT, Claude, Gemini, Copilot, Cursor and the like) to find its way around it. To get help, give your assistant this repository and a message like:
I'm working with Orion (https://github.com/MultiX0/orion), a voice assistant that runs on a LilyGO T-Camera Plus S3, with a Flutter app for Windows and Android. Read its README.md, docs/ARCHITECTURE.md and docs/DEVICE_PROTOCOL.md first. Then help me: what you want to do.
Where things are
| Folder | What it is | Read first |
|---|---|---|
firmware/ |
The board's firmware, ESP-IDF 5.5.5 in C, one component per concern | docs/FIRMWARE.md |
lib/, test/ |
The Flutter app, one folder per feature | docs/ARCHITECTURE.md, docs/UI.md |
lib/features/harness/ |
The PC and phone brain and the tools it can use on a computer | docs/HARNESS.md |
tool/ |
Dart tools for the app, including a pretend board | |
tools/ |
Board scripts and the one-click installer | tools/install/README.md |
wakeword/ |
Training the "Orion" wake word, and the model that ships | docs/WAKEWORD.md |
case/ |
The 3D printed case | case/SPEC.md |
docs/ |
Everything else, with an index | docs/README.md |
Anything the app and the board both touch (the HTTP API, the WebSocket, the settings) is defined in docs/DEVICE_PROTOCOL.md. Models, keys and Fish Audio are in docs/PROVIDERS.md.
Commands
# the app
flutter pub get
dart run build_runner build --delete-conflicting-outputs # generated Dart is not in git
dart run tool/mock_device/main.dart # a pretend board on localhost:8080, pairing code 123456
flutter run -d windows # or an Android device
flutter analyze && flutter test
# the firmware, from firmware/ with ESP-IDF 5.5.5
idf.py build
Rules to give your assistant
- Never ask for, print or commit an API key or a pairing token. Keys live only on the board and in the app's secure storage;
.envis for local scripts and is not in git. - When a change touches both the app and the board, change both sides and docs/DEVICE_PROTOCOL.md together.
- Do not hand-edit generated files (
*.g.dart,*.freezed.dart,lib/core/theme/tokens.dart, the firmware's fonts and images). Change the source and rerun its generator, as docs/CODE_STYLE.md explains. - The board is short on internal memory: large buffers go in PSRAM. docs/FIRMWARE.md has the details.
- Ask before flashing a board or playing sound on it.
- Plain English in code, comments, docs and commits, with no em dashes and no emojis.
Bug reports, ideas and pull requests are welcome. Open an issue first for anything large, so we can agree on the shape before you spend time on it. For code, follow docs/CODE_STYLE.md, and for the app run flutter analyze and dart format . before you send it. By contributing you agree that your work is shared under the same license as the rest of Orion.
Orion is free for personal and non-commercial use. You can build it, change it, share it, and use it at home, in school, in research, or in a charity. You cannot sell it, or use it in a commercial product or service, without the author's permission.
The terms are the PolyForm Noncommercial License 1.0.0. If you pass Orion on, pass on that file with its Required Notice line. Because commercial use is excluded, Orion is source-available rather than open source in the OSI sense: all of the source is public to read, build and learn from.
Parts made by others keep their own licenses: ESP-IDF, LVGL, TensorFlow Lite Micro, microWakeWord and the okay_nabu wake word model, the Flutter packages, and the fonts (Playfair Display, Source Serif 4, Inter and DM Mono, under the SIL Open Font License). The board photos above belong to LilyGO.
Orion is made by MultiX0: github.com/MultiX0. The project's website is joinorion.io.
Thanks to LilyGO for the board, Espressif for the ESP32-S3 and its tools, Fish Audio for the voice, DeepInfra for the default models, and the people behind microWakeWord, LVGL and Flutter.