A native Android port of Star Trek: Voyager — Elite Force — the single-player campaign (2000). It is the single-player companion to the Holomatch (multiplayer) port, and shares its engine base. Inspired by and building on VoyagerNX, faithvoid's Nintendo Switch port. The engine base is lilium-voyager with the Vulkan renderer from Quake3e; the single-player game logic (Raven's officially-released Elite Force SP source) runs as a native module. Touch controls, full gamepad support.

Its sequel has an Android port too: Star Trek: Voyager — Elite Force II is playable on Android via Provenance EF2.

No game data is included. You need your own copy of the retail game (GOG release, original CD + patches, or an existing PC install).

Features

Vulkan renderer (Quake3e renderervk, adapted to the Elite Force engine) — this is the only renderer; the old OpenGL ES path has been removed.
Native single-player game module (libefgame / libefui) built from Raven's Elite Force SP source for both armeabi-v7a and arm64-v8a. A width-explicit savegame transcoder keeps saves compatible across the 32-bit and 64-bit builds.
Touch controls: virtual stick, look area, and an LCARS-styled button overlay that auto-hides while a gamepad is in use and during scripted cinematics.
Gamepad: SDL GameController mapping, dual-analog defaults, with look-sensitivity and deadzone options.
Aspect handling: 4:3 pillarbox or 16:9, applied to the 3D view, HUD, and 2D menus, with black side bars.
Retail LCARS level-loading screens (animated load bar, levelshot, and your saved screenshot when loading a save) on every load path.
Save menu thumbnails (real framebuffer capture) and autosave labelling.
In-app game-data import: if the game data is missing at launch, the app lets you pick your pak*.pk3 files and a retail efgamex86.dll with the system file picker and copies them into place. No storage permission needed at any target SDK.
16 KB memory page-size compatible (Android 15+); all native libraries are 16 KB-aligned.

Screenshot from the first mission

Requirements

Android 7.0+ (API 24) with Vulkan support — the APK declares Vulkan as a required feature.
An ARM device. The APK is universal (armeabi-v7a + arm64-v8a).
Retail Elite Force data: pak0.pk3 (~541 MB) plus the patch paks pak1.pk3–pak3.pk3 from BaseEF/ of a PC installation, and a genuine efgamex86.dll from the game's install folder. The DLL is not loaded or executed by this port — it is required only as confirmation that you own a real copy of the game.

Install

Copy your four pak*.pk3 files and efgamex86.dll onto the phone (anywhere — Downloads is fine).
Install the APK and launch it.
When asked, pick the files. They are copied into the game's data directory and the game starts. That's the whole setup; next launches go straight into the game.

The manual push target (e.g. over adb) is /sdcard/Android/obb/com.voyager.efsp/baseEF/.

Linux

The same tree builds a native desktop client — one source base, EF_PLATFORM selects the target at configure time, Vulkan remains the only renderer on both.

Requirements

x86-64 Linux with a Vulkan driver.
glibc 2.35 or newer (GLIBCXX_3.4.29): Ubuntu 22.04+, Mint 21+, Debian 12+, Fedora 36+, Arch/Manjaro/SteamOS 3. RHEL/Rocky 9, Debian 11 and musl distributions are not supported.
X11 or XWayland. SDL is built with the X11 backend, so a pure Wayland session without XWayland will not start a window.
Your own retail data, exactly as on Android.

Running the AppImage

chmod +x VoyagerSP-1.2.0-x86_64.AppImage
./VoyagerSP-1.2.0-x86_64.AppImage

On first run the game asks for your retail files (pak0.pk3–pak3.pk3 and efgamex86.dll): pick the BaseEF folder of your installation, or pick the files individually. A folder is linked, not copied, so the 640 MB installation stays where it is; retail is only ever read, and saves/config live in your own data directory:

${XDG_DATA_HOME:-~/.local/share}/voyagersp/baseEF/     # saves, efspconfig.cfg, logs

Override the location with VOYAGERSP_DATA_ROOT or --data-dir <path>, and skip the prompt once the data is in place with --no-import. --import-from <dir> imports non-interactively, --import-only imports and exits.

Desktop controls: keyboard and mouse use the retail bindings (WASD, mouse look, MOUSE1 fire, MOUSE2 forward, MOUSE3 zoom, wheel cycles weapons); SDL game controllers are picked up hot-plugged with the same EF1 layout as the Android build. The video menu has a FULL SCREEN row that toggles between windowed (the default, 1280×720, resizable) and fullscreen; r_fullscreen, --windowed and --fullscreen do the same from the console or the command line.

Known issues

This port is over 90% complete, but has yet to be fully play tested. Known issues:

Save corruption is technically possible and retail PC elite force saves or not compatible - but might be in the future — back up your saves; loads may occasionally fail or restore an inconsistent state. Most save specific isssues have been resolved, however latent bugs might still present themselves.
Minor graphical and audio glitches are still present.
Character animations are not 100% accurate yet.
Anti-aliasing (MSAA) is disabled on Mali and PowerVR GPUs as a precaution against a graphics-device-lost crash seen on some of those devices. This is a best-effort workaround and may not cover every affected device — please report any issues.
REPORT YOUR ISSUES PLEASE!

Build

Everything needed to build is in this repository (engine, SDL2, the single-player game source, and the prebuilt SPIR-V). No game data is required to build — only to run.

Prerequisites:

Android SDK
NDK 25.1.8937393
CMake 3.31.5
JDK 21

Point Gradle at your SDK with a local.properties file:

echo "sdk.dir=/path/to/Android/sdk" > EFAndroid-SP/local.properties

Build the native game/UI module, copy it into the app, then build the APK:

cmake --build efgame/build64 --target efgame efui      # arm64  (efgame/build for armv7)
cp efgame/build64/lib*.so EFAndroid-SP/app/libs/arm64-v8a/

cd EFAndroid-SP
./gradlew :app:assembleDebug    # output: app/build/outputs/apk/debug/app-debug.apk

The APK is universal (armeabi-v7a + arm64-v8a). Engine sources compiled into the APK live in EFAndroid-SP/app/jni/efcode/ (lilium-voyager plus the Android/Vulkan port layer); the single-player game/UI module lives in efgame/.

Linux

One tree, two targets: EF_PLATFORM (default android under the NDK toolchain, linux otherwise). On Linux the build links the system SDL2, Vulkan and FFmpeg instead of the vendored copies, and produces a normal executable instead of libmain.so:

# engine + client -> EFAndroid-SP/app/jni/build-linux/Release/voyagersp
cmake -S EFAndroid-SP/app/jni -B EFAndroid-SP/app/jni/build-linux -G Ninja \
      -DEF_PLATFORM=linux -DCMAKE_BUILD_TYPE=Release
cmake --build EFAndroid-SP/app/jni/build-linux -j"$(nproc)"

# game/UI modules -> Release/libefgame.so, Release/libefui.so (dlopened at runtime)
cmake -S efgame -B efgame/build-linux -G Ninja -DEF_PLATFORM=linux -DCMAKE_BUILD_TYPE=Release
cmake --build efgame/build-linux -j"$(nproc)"
cp efgame/build-linux/Release/lib*.so EFAndroid-SP/app/jni/build-linux/Release/

./scripts/play_voyagersp.sh          # or run Release/voyagersp directly

Host packages: cmake, ninja, libsdl2-dev, libvulkan-dev, libavformat-dev, libavcodec-dev, libswscale-dev, libavutil-dev. The AppImage is built from an unprivileged Ubuntu 22.04 rootfs so the glibc floor stays at 2.35:

cd packaging/appimage
./setup-buildbox.sh        # once: rootfs + pinned tools, no sudo
./build-appimage.sh        # dist/VoyagerSP-<version>-x86_64.AppImage

License & credits

This project is multi-licensed. The engine and port code are GPLv2 (LICENSE) — from id Software's Quake III via ioquake3, lilium-voyager, and Quake3e. The single-player game module (efgame/) is based on Raven Software's officially released Elite Force SP source and is under Raven's STEF Game Source License (efgame/STEF Game Source License.doc). Star Trek and related marks belong to Paramount/CBS; this is a non-commercial fan port and includes no game assets. Full attribution in CREDITS.md.

Leer guía oficial