An Artemis / EmptyEpsilon-style bridge simulator built in Unreal Engine 5.7 (C++) on Linux. One player pilots from a 3rd-person view of the ship; the rest of the "crew" open web consoles on their phones/laptops over the LAN (Helm, Weapons, Engineering, Science) and run the stations together. It ships with a small story campaign across an open sector — fly between planets and a sun, trigger encounters by proximity, warp to travel, dock to repair and buy upgrades/ships.
On approach to Haven, the home system — one player flies the ship in 3rd person.
This is a source project (no packaged build committed). You compile the editor target and play in-editor (PIE). The steps below take you from a clean checkout to a running game.
| Requirement | Notes |
|---|---|
| Unreal Engine 5.7 (source or Linux binary build) | Tested against 5.7.4 installed at ~/UnrealEngine/UE_5.7. |
| Linux | Developed on CachyOS / Arch (kernel 7.x), Wayland + Vulkan. Any modern Linux with a Vulkan-capable GPU should work. |
| Clang toolchain | The one bundled with UE 5.7 (Engine/Extras/ThirdPartyNotUE/SDKs/...) — no separate install needed. |
| ~150 GB disk + a discrete GPU | Standard UE editor requirements. |
| Python 3 | Only for the optional agent/automation tooling in tools/. Not needed to play. |
Find your engine path. This repo assumes ~/UnrealEngine/UE_5.7. Your install is recorded in
~/.config/Epic/UnrealEngine/Install.ini:
[Installations]
UE_5.7=/home/<you>/UnrealEngine/UE_5.7If yours differs, substitute your path for $UE below.
# set once per shell (fish syntax; use `export` for bash)
set -x UE $HOME/UnrealEngine/UE_5.7
set -x PROJ (pwd)/SpaceGame.uproject # run from the repo root- Game module:
Source/SpaceGame/— the C++ runtime (Ships, Components, Core, FX, Net, World). - Targets:
Source/SpaceGame.Target.cs(game) andSource/SpaceGameEditor.Target.cs(editor). - Content:
Content/— maps (Maps/MainMenu,Maps/VSlice_Arena), art, materials, audio. - Plugins:
Plugins/UnrealClaudeandPlugins/VibeUE— AI-agent dev tooling only (MCP servers used to drive the editor during development). They are not required to play; you may disable them inSpaceGame.uprojectif you don't want them. - The web consoles are hosted in-process by the game itself (
Net/StationServerSubsystem, HTTP on port 8080) — there is no separate web server to run.
Build artifacts (Binaries/, Intermediate/, Saved/, DerivedDataCache/) are gitignored and
regenerate on first build.
Editor closed, from anywhere:
$UE/Engine/Build/BatchFiles/Linux/Build.sh \
SpaceGameEditor Linux Development \
-Project=$PROJ -WaitMutex- First build is slow (compiles the game module + the two plugins). Subsequent builds are incremental.
-WaitMutexavoids clobbering a build the editor might be running. If a build exits1immediately after killing an editor, it's usually mutex contention — just run it again.- No separate "generate project files" step is required to build from the command line. (For an
IDE, run
$UE/Engine/Build/BatchFiles/Linux/GenerateProjectFiles.sh -project=$PROJ -game.)
Launch the editor with the project:
$UE/Engine/Binaries/Linux/UnrealEditor $PROJIt opens on Maps/MainMenu. Press Play (the ▶ toolbar button, or Alt+P) to start a
Play-In-Editor session. Use New Game from the menu to begin the campaign; you spawn in the open
sector at the home system.
Pilot controls (Helm / keyboard, in the focused PIE window):
- Throttle / steer the ship, orient toward contacts.
1/2/3switch the local on-screen station (Helm / Weapons / Engineering).
You can play solo from the editor window, but the intended experience is the crew web consoles below.
While a PIE (or packaged) session is running, the game hosts the bridge stations as web pages on port 8080. On any device on the same network, open:
http://<the-game-machine-LAN-IP>:8080/
From the same machine, http://localhost:8080/ works too. Each crew member picks a station:
- Helm — radar, throttle/steering, firing-arc wedges, DOCK/UNDOCK, WARP, sector map.
- Weapons — target list (enemy callsigns), phaser/torpedo firing (only within the correct arc).
- Engineering — power routing / reactor budget, and (while docked at a station) the drydock: buy tiered upgrades and new ships with earned credits/XP.
- Science — comms log, sector starmap.
 Helm — radar with contacts and phaser/torpedo firing arcs, heading & throttle, DOCK / WARP. |
 Weapons — lock a target, watch range / in-arc, fire the beam and torpedoes when it's a solution. |
 Engineering — route reactor power between engines/weapons/shields, or snap to a preset. |
 Science — mission orders, the comms log, target scans, and the sector map. |
The four crew consoles, opened on phones/laptops over the LAN. They're mobile-first and update live.
Find your LAN IP with ip addr (look for the 192.168.x.x / 10.x.x.x address). The consoles are
mobile-first and scrollable.
- New Game → you're in the home system (a blue planet, Haven) with a friendly starbase.
- Fly toward the next objective (the highlighted system on the sector map). Warp to shorten long hops.
- Entering an objective's zone spawns the enemy fleet and opens comms. Orient and destroy them (respect the phaser/torpedo firing arcs shown on the radar).
- Clearing a fleet advances the campaign seamlessly and points you at the next system.
- Dock at the starbase to repair, resupply torpedoes, and spend credits/XP on upgrades or a new ship in Engineering's drydock.
- Clear the final system (the Pact staging point at the Ember sun) for the epilogue. Being destroyed shows the defeat screen; retry reloads the sector.
Hostiles closing in over the homeworld — accept orders and the fleet engages.
Build.sh: No such file— your engine isn't at~/UnrealEngine/UE_5.7. Check~/.config/Epic/UnrealEngine/Install.iniand update$UE.- Build exits
1right after closing the editor — mutex contention; re-run the build once. - Web consoles don't load — confirm a PIE/game session is actually running (the server only
exists while the game is playing), that you're using the machine's LAN IP, and that port
8080isn't firewalled. Check the log for[StationServer]. - Plugins fail to compile / you don't want the agent tooling — set
"Enabled": falseforUnrealClaudeandVibeUEinSpaceGame.uproject, then rebuild. The game itself doesn't depend on them.
SpaceGame.uproject project descriptor (module + plugins)
Source/SpaceGame/ C++ game module
Ships/ Components/ Core/ FX/ Net/ World/
Content/ maps, art, materials, audio
Plugins/ UnrealClaude, VibeUE (dev/agent tooling only)
tools/ Python helpers for editor automation (optional)
docs/
PROGRESS.md append-only build log (per feature/commit)
PROJECT_PLAN.md phased roadmap + "done-when" checks
DECISIONS.md design decisions
Development follows a one-commit-per-feature cadence; docs/PROGRESS.md is the running history
of what was built and how it was verified.
Licensed under the PolyForm Noncommercial License 1.0.0 — free to use, modify, and share for any noncommercial purpose (personal, hobby, research, education); commercial use is not permitted. This covers the SpaceGame source, content, and docs. Unreal Engine (UE EULA), the bundled dev-tooling plugins, and any downloaded art assets keep their own separate licenses.
The VibeUE agent tooling uses an API key stored in
Saved/Config/LinuxEditor/EditorPerProjectUserSettings.ini, which is gitignored and must never be
committed. Nothing there is needed to compile or play the game.
Session recording (analysis mode). An opt-in telemetry recorder captures a played session for
offline analysis (movement, combat, hull loss, mission pacing). Enable it from the console with
sg.RecordSession 1 (or launch with -recordsession); it writes newline-delimited JSON to
Saved/SessionLogs/session_*.jsonl, one file per recording. Analyse it with
python3 tools/analyse_session.py (newest log by default). Off by default; nothing is recorded unless
you turn it on.