Skip to content
ArthurSiminPublic

About

Linux game launcher with Wine, Proton and OnlineFix support, built with Qt 6

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Repository files navigation

Vanta

Made with OpenCode Made with Google Antigravity Website

CI Release License: AGPL-3.0

Vanta is a Linux game launcher written in C++17 with Qt 6 Widgets. It keeps a local library of the games you already own, launches native Linux builds and Windows builds through Wine or Proton, discovers the runners other launchers have already installed, and reports what it finds inside a game folder — without ever downloading a game or claiming that a detected fix works.

Vanta main window showing a clean, empty library

The screenshot shows a clean Vanta installation: the library starts empty and Vanta never adds entries on its own.

Features

  • One library for everything. Add a game by pointing Vanta at its executable; the game folder is taken from the executable's parent directory. Native, Wine, Proton, Flatpak and custom-wrapper launches are all supported from the same window. A Windows binary is detected by its PE header, not just its extension, and Proton is selected for it automatically.
  • Background scanning. Every game is inspected on a worker thread through QtConcurrent. Results are cached in scan-cache.json, keyed by game id and validated against the game path, the folder modification time and the selected executable, so a second start is instant and only changed games are rescanned.
  • Runner discovery. Vanta finds Wine and Proton builds installed by Steam (including extra Steam libraries), Lutris, Heroic and Bottles, including their Flatpak variants, plus anything you installed from Vanta itself or configured manually.
  • Runner installation. A built-in dialog can install Wine with your distribution's package manager, or download a portable Wine build or the latest GE-Proton release from its official GitHub release page.
  • BepInEx and mods. Vanta detects a BepInEx installation next to the executable, lists its plugins and patchers, and enables or disables a mod by renaming it between .dll and .dll.disabled. You never rename or move files yourself, and DLL contents are never changed. Mods can be added from a local .dll or .zip, and the built-in Thunderstore browser lists the game's community, searches packages, resolves dependencies and installs them into the game folder. Anything that would be replaced is first copied to BepInEx/.vanta-backups/<timestamp>/.
  • OnlineFix support. Vanta ports the launcher-side behaviour of OnlineFix Linux: signature detection, INI updates with backups, the FreeTP app-id swap, ExtraProtection=false, the Photon Newtonsoft link and launch-only Wine DLL overrides. If Steam is closed when an OnlineFix launch starts, Vanta asks what to do instead of starting the client behind your back. See ONLINEFIX.md.
  • Cover art from Steam, then SteamGridDB. Missing covers are fetched from the game's own Steam library art when Vanta can match the release, and from SteamGridDB otherwise. The picker offers the Steam cover first and the SteamGridDB grids beside it, with a full-size preview so you choose the one Vanta uses. Names are matched fuzzily, so a typo like "Testris" still resolves to "Tetris Ultimate". The Steam match is release-checked, so a sequel, a spin-off or a prequel never supplies another game's Steam art; the SteamGridDB fallback matches by name similarity.
  • Real source icons. Steam, GOG, Epic, EA and Ubisoft entries use the official brand marks from bundled SVGs, recoloured to match the active theme.
  • Themes. System, Light, Dark and Follow system colors. The System theme follows QStyleHints::colorScheme() and switches live when the desktop changes; Follow system colors derives the whole palette from the active desktop theme, so a Breeze Dark session is reproduced with its own window, text and accent colors.
  • Grid and list views. Cover grid with small/medium/large covers and badges, or a compact sortable table.
  • Guided tour. An eight-step spotlight tutorial runs on first start and can be replayed from the sidebar or Settings.
  • Honest diagnostics. Launch failures keep the composed command line, the prefix path and the OnlineFix patch log so you can see exactly what happened.
  • Launch logs. Every launch stores the runner output, and a terminal-styled viewer opens the newest one so a game that closed on its own can still be diagnosed. See Launch logs.
  • Release notifications. Vanta asks GitHub for the newest release once at start, and again whenever you choose Main menu → Check for updates…. When a newer version exists, a banner above the library names it and offers Open release page. Vanta never downloads or installs an update itself: packages belong to your distribution, so the check only tells you that a new version is there. See Update notifications.

Requirements

  • A C++17 compiler (GCC 11+ or Clang 14+)
  • CMake 3.21 or newer
  • Qt 6.2 or newer with the Widgets, Svg, Concurrent and Network modules
  • zlib, used to read mod ZIP archives
  • Ninja (recommended) or Make

Qt 6.2 is the floor on purpose: Vanta avoids anything newer so a single build runs on every distribution from Ubuntu 22.04 onward. On Qt 6.2 and 6.3 the "Follow system colors" theme falls back to the palette's lightness, because QStyleHints::colorScheme() arrived in 6.5.

Wine and/or Proton are only needed to launch Windows games. Vanta starts and runs fine without them.

Install with one command

Copy this into a terminal. The script reads the newest release, works out whether Vanta is already installed and which package your distribution needs, and either installs Vanta or updates the copy you have. It shows what it found before changing anything.

curl -fsSL https://raw.githubusercontent.com/ArthurSimin/Vanta/main/scripts/install.sh | sh

It verifies the release SHA-256 checksum, uses sudo on a text console and pkexec in a graphical terminal when it is available, and falls back to the portable tarball in /usr/local when no supported package manager is found. The script is plain POSIX sh; read it first if you prefer.

To skip the confirmation prompt, pass --yes after sh -s --; --help lists every option:

curl -fsSL https://raw.githubusercontent.com/ArthurSimin/Vanta/main/scripts/install.sh | sh -s -- --yes
curl -fsSL https://raw.githubusercontent.com/ArthurSimin/Vanta/main/scripts/install.sh | sh -s -- --help

Arch, Manjaro and CachyOS users can skip the script and install from the AUR with any AUR helper:

yay -S vanta
# or
paru -S vanta

That package builds the current release from source, so there is no download step and your helper keeps it updated with the rest of your system.

If you would rather download a package yourself, the table below lists the format for each distribution.

Installing a package

Just head over to Releases and grab the correct package for your distribution. Prebuilt packages are attached to every release, built on Ubuntu 22.04 against Qt 6.2 so one package covers a whole family of distributions rather than a single release.

Distribution Package
Debian 12+, Ubuntu 22.04+ vanta_<version>_amd64.deb
Fedora, openSUSE, RHEL vanta-<version>-1.x86_64.rpm
Arch, Manjaro, CachyOS vanta-<version>-1-x86_64.pkg.tar.zst
Anything else vanta-<version>-linux-x86_64.tar.gz
# Debian / Ubuntu
sudo apt install ./vanta_<version>_amd64.deb

# Fedora / openSUSE
sudo dnf install ./vanta-<version>-1.x86_64.rpm

# Arch / Manjaro / CachyOS
sudo pacman -U vanta-<version>-1-x86_64.pkg.tar.zst

Packages are unsigned, so verify the checksum first:

sha256sum -c SHA256SUMS --ignore-missing

The tarball holds the same tree rooted at the archive instead of /usr:

tar -xzf vanta-<version>-linux-x86_64.tar.gz
sudo cp -a vanta-<version>-linux-x86_64/usr/. /usr/local/

Building

Debian and Ubuntu

sudo apt update
sudo apt install build-essential cmake ninja-build \
    qt6-base-dev qt6-svg-dev libqt6svg6-dev libgl1-mesa-dev
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build

Fedora

sudo dnf install gcc-c++ cmake ninja-build \
    qt6-qtbase-devel qt6-qtsvg-devel mesa-libGL-devel
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build

Arch Linux and derivatives

sudo pacman -S --needed base-devel cmake ninja qt6-base qt6-svg mesa
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build

Any distribution

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j"$(nproc)"

The binary is written to build/vanta. The build enables -Wall -Wextra, QT_NO_CAST_FROM_ASCII and QT_USE_QSTRINGBUILDER and compiles without warnings.

Installing

sudo cmake --install build --prefix /usr/local

This installs:

File Destination
vanta <prefix>/bin/vanta
vanta.svg <prefix>/share/icons/hicolor/scalable/apps/vanta.svg
vanta.desktop <prefix>/share/applications/vanta.desktop
README.md, ONLINEFIX.md, LICENSE <prefix>/share/doc/vanta/

To install into your home directory instead:

cmake --install build --prefix "$HOME/.local"

Run it from the application menu or with vanta.

Usage

Adding a game

Press Add game (Ctrl+N) or the + button in the header. The editor has four tabs:

  • General — name, source, executable, arguments, working folder and cover image. There is no separate game folder field: the folder is always the executable's parent directory.
  • Runner — runner type, platform, runner path, prefix folder, WineD3D, native Wayland, Steam overlay, SteamLinuxRuntime wrapping, BepInEx compatibility, DLL overrides and wrapper arguments.
  • OnlineFix — per-game mode (Auto, Force, Disabled), detection, app IDs, fix folder and Photon folder.
  • Environment — one KEY=VALUE pair per line. Blank lines and lines starting with # are ignored.

Point the executable row at a .exe and Vanta selects Proton plus the Windows platform for you, since the library is for games rather than Windows utilities. A native Linux binary selects Native instead. Both are only defaults: change the runner in the Runner tab whenever you need to.

The cover row has a Find cover art… button that looks the game name up on the Steam store and SteamGridDB and opens the artwork picker. The game's own Steam library art is offered first, followed by every SteamGridDB grid with its size and author. The search is fuzzy, so "Testris" resolves to "Tetris Ultimate", and the Steam match is release-checked, so a sequel or a spin-off never supplies another game's Steam art. Thumbnails stream in as they arrive and the selected image is previewed full size before you commit. Covers are downloaded automatically for new games unless you turn that off in Settings → Covers.

Double-click a card to launch. Right-click for play/stop, details, edit, favourites, rescan, cover art, OnlineFix and folder actions.

Selecting a game fills the detail strip along the bottom with its cover, name, last played date and total playtime, plus a Launch button. The arrow beside it opens the same menu as a right-click. When a fix signature is present the OnlineFix chip next to the name is on by default, so the launch applies the configuration the fix expects; click it to launch without the fix for one run. Setting the game's OnlineFix mode to Disabled hides the chip, the card badge and every other OnlineFix marker, because a launch would ignore the fix; the game details sheet still reports what was detected and says that the mode is off. Nothing is applied silently — every file Vanta touches is backed up first, and detection is still not proof that a fix works.

Prefix layout

If you do not set a prefix folder, Vanta uses Vanta Prefix next to the game executable:

  • Wine uses Vanta Prefix/pfx as WINEPREFIX.
  • Proton uses Vanta Prefix as STEAM_COMPAT_DATA_PATH; teardown uses Vanta Prefix/pfx.

Environment rules

Vanta starts from the current process environment, applies the environment you stored for the game, prepends the forced DXVK override chain, appends your stored overrides, and finally adds the OnlineFix and BepInEx modules. The following keys are managed by Vanta and rejected in the editor because changing them would break the launch:

WINEPREFIX, WINEDLLOVERRIDES, WINEDEBUG, STEAM_COMPAT_DATA_PATH, STEAM_COMPAT_CLIENT_INSTALL_PATH, PROTON_USE_WINED3D, PROTON_ENABLE_WAYLAND, STEAMAPPID, STEAMGAMEID, STEAMOVERLAYGAMEID, ENABLE_VK_LAYER_VALVE_STEAM_OVERLAY_1 and LD_PRELOAD.

Runner management

Open Settings → Runners or Main menu → Download runners…:

  • System Wine uses the package manager detected from your distribution (apt-get, dnf, pacman, zypper, apk, eopkg or xbps-install). Vanta runs it directly when it is root, otherwise through pkexec, then through sudo -n. If no elevation path works it shows the exact command to run yourself and offers the portable Wine build instead. When no known package manager is found the panel says so and only the portable options remain.
  • Portable Wine downloads the latest Kron4ek Wine build (WoW64, typically around 100 MB).
  • GE-Proton downloads the latest GloriousEggroll release (usually around 550 MB).

Managed runners are unpacked under $XDG_DATA_HOME/vanta/runners/{wine,proton} and appear in the editor immediately. Downloads run through QNetworkAccessManager with progress, cancellation and a size/bin/ sanity check after extraction.

Mods and BepInEx

Right-click a Windows game and choose Mods…, or open the same dialog from Game details. Vanta looks for BepInEx next to the executable (and in the game folder) and reports whether the doorstop files (winhttp.dll, doorstop_config.ini, .doorstop_version) are present.

  • Enable and disable. Every plugin and patcher is listed with its kind and state. Ticking a row, pressing Toggle, or pressing Space on a selected row renames the file between name.dll and name.dll.disabled. The DLL bytes are never modified and nothing is deleted, so a mod can always be restored the same way. Symbolic links are never followed or renamed.
  • Add mod file… imports a single .dll or a .zip. A ZIP is inspected in memory first: entries are mapped into BepInEx/plugins, BepInEx/patchers, BepInEx/config or the game root, BepInExPack/ wrappers are stripped, and documentation files such as manifest.json, README.md and CHANGELOG.md are skipped. The archive reader rejects ZIP64, encrypted entries, absolute paths, .. traversal and symbolic links, so it cannot write outside the game folder.
  • Browse Thunderstore… opens the community browser. Vanta guesses the community from the game name (or remembers the one you pick), lists its packages, searches by name, shows versions and dependencies, and installs a package together with everything it needs. A package link can also be pasted directly. BepInExPack is skipped when BepInEx is already installed, and r2modman is refused because it is a mod manager, not a BepInEx plugin. Installing the BepInExPack itself is the supported way to bootstrap a game that has no loader yet; if BepInEx is already present, Vanta asks before the pack replaces the installed core DLLs, and backs every replaced file up. A dependency pinned to a release that the community does not publish is installed at the newest available release, and the result says so.
  • Backups. If an install would overwrite an existing file, Vanta asks first and then copies the old file to BepInEx/.vanta-backups/<timestamp>/ before writing. The dialog reports the backup folder. All downloads are parsed before anything is written, so a failed install leaves the game folder untouched.

Enabling BepInEx compatibility (the winhttp=n,b DLL override) is still a per-game setting in the Runner tab. Vanta turns it on the first time it finds BepInEx for a game you launch, and the launch plan only applies it while BepInEx files are actually present.

Launch logs

Every launch keeps its output. Right-click a game and choose Logs…, use the Logs… entry in the main menu, or press the Logs… button in the game details sheet, and the terminal-styled viewer shows the log of that game's newest launch. The launch dropdown above the pane switches between earlier launches for the same game.

A log starts with a short header (game, runner, start and finish time, exit code, result), then the exact command Vanta composed, the working directory, the environment overrides and every diagnostic from the launch plan. After that comes the output of the process itself, with stderr separated. The viewer opens scrolled to the newest line, because that is where a failure usually appears.

  • Wine output. Settings → Runners → Wine log detail controls what Wine writes: Off (WINEDEBUG=-all), Errors only (the default, -all,err+all), Warnings and errors, or Everything (verbose). Wine's fixme chatter is suppressed at the default level, which keeps real failures readable.
  • Storage. Logs live under $XDG_DATA_HOME/vanta/logs/<game id>/, one plain text file per launch. The newest 20 launches per game are kept and older ones are pruned. Nothing points outside the log directory: the viewer only reads, and Clear logs deletes stored logs of that game and nothing else.
  • After a crash. When a game exits with a non-zero code or crashes, Vanta offers to open the log for that launch instead of only showing a diagnostic box. A close from the Play button is reported as stopped, not crashed.
  • Native games. Their output is captured the same way; the Logs entry simply appears once a log exists.

A log records what Vanta ran and what the process printed. It cannot prove why a game failed, and Vanta makes no such claim.

Update notifications

Vanta asks https://api.github.com/repos/ArthurSimin/Vanta/releases/latest for the newest published release once, a couple of seconds after start, and again when you pick Main menu → Check for updates….

When the release is newer than the running build, a banner appears above the library with its version and an Open release page button. The button opens the release in your browser; there is no download and no self-update, because Vanta is installed by your distribution's package manager and replacing its own files would fight it. Dismissing the banner keeps it away for the session; checking manually brings it back.

Version comparison is numeric per segment, so 1.0.10 is newer than 1.0.9. A suffix made of letters marks a pre-release (1.0.3-beta is older than 1.0.3), while a packaging suffix does not (1.0.3-1 equals 1.0.3). A build without a numeric version — a development build from the working tree — skips the check entirely. A failed check is reported in the status bar only when you asked for it.

Files

Purpose Path
Library $XDG_CONFIG_HOME/vanta/library.json
Settings $XDG_CONFIG_HOME/vanta/settings.json
Scan cache $XDG_CACHE_HOME/vanta/scan-cache.json
Managed runners $XDG_DATA_HOME/vanta/runners/
Downloaded cover art $XDG_DATA_HOME/vanta/covers/
Launch logs $XDG_DATA_HOME/vanta/logs/<game id>/

All JSON is written atomically with QSaveFile (temporary file, fsync, rename), so a crash never leaves a half-written library. A corrupt file is quarantined next to the original and Vanta starts with defaults instead of overwriting your data.

Privacy

Vanta makes network requests in exactly four situations:

  1. Checking for a newer release when Vanta starts and when you choose Check for updates…. The request reads the public GitHub releases API, sends no information about you or your library, and writes nothing.
  2. Downloading a runner (GitHub release metadata and the release asset).
  3. Looking a game name up on the Steam store and SteamGridDB when fetching cover art, which sends only the name you asked it to look up. Turn off "Fetch missing cover art automatically" in Settings → Covers to keep lookups entirely manual.
  4. Browsing or installing from Thunderstore, which sends the community slug, the package or search text you entered, and the package downloads themselves. Opening the mod manager alone makes no request.

Nothing else leaves the machine. There is no telemetry, no analytics and no account.

Everything else is local. The scanner only reads file names, sizes, timestamps and, for Windows executables, the PE header architecture.

Limitations

  • Vanta cannot verify that an OnlineFix configuration works, and never claims that detected files are functional. It does not patch executables and does not download fix files.
  • Detection is filename- and INI-based. A file that matches a signature may be unrelated, and a working fix may be missed.
  • Playtime is measured while Vanta is running the game. Launching outside Vanta is not tracked.
  • Steam integration is limited to discovering Steam libraries, the Steam Linux Runtime and starting Steam when you ask it to from the OnlineFix prompt. Vanta is not a Steam client and does not read your Steam credentials.
  • Cover matching is a heuristic. A title that shares a name with a sequel or a spin-off can resolve to the wrong entry; the editor always shows the matched name before you save, and you can browse for your own image instead.
  • The mod manager understands BepInEx 5 and 6 layouts by file name. It cannot tell whether a plugin actually loads, whether it matches the game version, or whether a Thunderstore package is compatible with the installed BepInEx build.
  • Thunderstore support covers BepInEx communities. Games that use a different loader (MelonLoader, and packs that only ship r2modman) are not supported.
  • The update check only reports a newer release. Vanta does not download or install it, and cannot tell whether your distribution has packaged that version yet.

Credits

  • OnlineFix Linux (OFLL) by ZzEdovec — the launcher-side OnlineFix behaviour in Vanta is a port of that project: https://github.com/ZzEdovec/onlinefix-linux
  • Qt 6, CMake and Ninja.
  • The Vanta logo and interface glyphs are original to Vanta. The Steam, GOG, Epic Games, EA and Ubisoft marks under resources/icons/brand/ come from Simple Icons (CC0 1.0) and remain trademarks of their respective owners; they are used only to identify the store a game came from.

Development

Build and contribution conventions are documented in AGENTS.md. GitHub Actions builds every push with both GCC and Clang and fails on any compiler warning.

Translations

The interface is translated into Russian, Portuguese (Brazil), Portuguese and Spanish, with catalogs for more languages in progress. Translations are community-maintained; see docs/TRANSLATIONS.md for how to improve one or add a language.

License

Vanta is licensed under the GNU Affero General Public License v3.0. See LICENSE. Because the OnlineFix behaviour is derived from OFLL, which is AGPL-3.0, the same license applies to this project.

About

Linux game launcher with Wine, Proton and OnlineFix support, built with Qt 6

Topics

Resources

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages