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.
The screenshot shows a clean Vanta installation: the library starts empty and Vanta never adds entries on its own.
- 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 inscan-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
.dlland.dll.disabled. You never rename or move files yourself, and DLL contents are never changed. Mods can be added from a local.dllor.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 toBepInEx/.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.
- 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.
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 | shIt 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 -- --helpArch, Manjaro and CachyOS users can skip the script and install from the AUR with any AUR helper:
yay -S vanta
# or
paru -S vantaThat 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.
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.zstPackages are unsigned, so verify the checksum first:
sha256sum -c SHA256SUMS --ignore-missingThe 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/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 buildsudo 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 buildsudo pacman -S --needed base-devel cmake ninja qt6-base qt6-svg mesa
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build buildcmake -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.
sudo cmake --install build --prefix /usr/localThis 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.
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=VALUEpair 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.
If you do not set a prefix folder, Vanta uses Vanta Prefix next to the game
executable:
- Wine uses
Vanta Prefix/pfxasWINEPREFIX. - Proton uses
Vanta PrefixasSTEAM_COMPAT_DATA_PATH; teardown usesVanta Prefix/pfx.
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.
Open Settings → Runners or Main menu → Download runners…:
- System Wine uses the package manager detected from your distribution
(
apt-get,dnf,pacman,zypper,apk,eopkgorxbps-install). Vanta runs it directly when it is root, otherwise throughpkexec, then throughsudo -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.
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.dllandname.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
.dllor a.zip. A ZIP is inspected in memory first: entries are mapped intoBepInEx/plugins,BepInEx/patchers,BepInEx/configor the game root,BepInExPack/wrappers are stripped, and documentation files such asmanifest.json,README.mdandCHANGELOG.mdare 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.
BepInExPackis skipped when BepInEx is already installed, andr2modmanis refused because it is a mod manager, not a BepInEx plugin. Installing theBepInExPackitself 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.
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, orEverything (verbose). Wine'sfixmechatter 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.
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.
| 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.
Vanta makes network requests in exactly four situations:
- 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.
- Downloading a runner (GitHub release metadata and the release asset).
- 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.
- 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.
- 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.
- 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.
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.
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.
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.
