ProtonLaunch

A PyQt6 GUI application for creating and managing Proton-based launch scripts on Linux.

ProtonLaunch provides a graphical interface for building, editing, and deploying bash scripts that run Windows applications through Steam's Proton compatibility tool with the Steam Linux Runtime — no Steam library integration required.

---

Overview

Running Windows applications on Linux with Proton typically requires hand-crafting bash scripts with the correct environment variables, prefix paths, and runtime invocations. ProtonLaunch eliminates that friction by offering a tabbed GUI where every aspect of the launch environment can be configured visually. Configurations are stored as annotated bash scripts (in ~/.local/share/protonlaunch/) that can be re-opened and edited in the GUI at any time, while remaining perfectly runnable on their own.

Features

• Graphical editor — tabbed interface for every aspect of the Proton launch environment
• App management — create, duplicate, and delete app configurations from a sidebar list
• Proton version detection — auto-discovers GE-Proton and Valve Proton installations from ~/.steam/root/compatibilitytools.d/ and Steam's common directory
• GE-Proton downloads — browse and download new GE-Proton releases directly from GitHub
• Steam Runtime selection — pick the appropriate runtime variant (sniper, scout, soldier, etc.)
• Wine configuration — set Windows version, manage winetricks packages with multi-select list and custom entries
• Immediate command execution — run winetricks, winecfg, wineserver, prefix init/kill/delete through Proton with real-time log output
• Winetricks flags — quiet mode (-q) and force (--force) toggles
• WebView2 bootstrapper — download and install Microsoft Edge WebView2 Runtime through Proton
• Environment variables — key=value editor with quick-toggle checkboxes for common options (MangoHUD, DXVK, FSR, etc.)
• DLL overrides — visual editor for WINEDLLOVERRIDES with categorized presets (DirectX, audio, input, NVIDIA)
• Custom drive mappings — map Wine drive letters to host directories (e.g. Y: → game base directory)
• Desktop entry generation — deploy .desktop files to ~/.local/share/applications/ for app menu integration
• Round-trip script editing — generated scripts use ## @protonlaunch annotations so they can be re-imported losslessly
• AppImage support — build a portable AppImage with the included build script

Requirements

Requirement	Details
Operating system	Linux
Python	3.10 or newer
PyQt6	≥ 6.6
requests	≥ 2.31
Steam	Installed with access to the Steam Linux Runtime
Proton	GE-Proton recommended (can be downloaded through the app)
winetricks	Must be installed on the system for package management features

Installation

From Source

git clone https://git.crashcat.net/voibe/protonlaunch.git
cd protonlaunch
pip install -r requirements.txt

Using a Virtual Environment

git clone https://git.crashcat.net/voibe/protonlaunch.git
cd protonlaunch
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

AppImage

Build a portable AppImage using the included build script (see Building below).

Usage

Launch the GUI:

python -m protonlaunch

Or run the AppImage directly:

./ProtonLaunch-*.AppImage

Quick Start

1. Create an app — click the + button in the sidebar or toolbar
2. Set the executable — on the Paths tab, browse to the Windows .exe file; exe_dir and base_dir auto-populate
3. Choose a Proton version — on the Proton tab, select an installed version or download a new GE-Proton release
4. Configure Wine settings — on the Wine tab, set the Windows version and add any winetricks packages
5. Save — press Ctrl+S or click Save to generate the launch script and .desktop entry
6. Run — execute the generated script directly, or launch from your desktop environment's app menu

Configuration Tabs

General

Basic app metadata: name, description, icon (XDG icon name or file path), and desktop categories. These values populate the .desktop file and the app list entry.

Paths

Configure the executable path, exe directory, base directory, and App ID. Setting the executable path auto-fills exe_dir and base_dir. The App ID determines the STEAM_COMPAT_DATA_PATH, creating a separate Wine prefix per application.

Proton

Select the Proton version and Steam Linux Runtime variant. Installed versions are auto-detected from ~/.steam/root/compatibilitytools.d/ and Steam's steamapps/common/ directory. The Download Proton button opens a dialog to browse and download GE-Proton releases from GitHub.

Wine

Set the target Windows version (win11, win10, win81, win8, win7, winxp) and manage winetricks packages:

• Multi-select list of common packages (corefonts, DXVK, .NET runtimes, Visual C++ redistributables, etc.)
• Custom package entry for arbitrary winetricks verbs
• Quiet (-q) and force (--force) toggle checkboxes
• Install Now buttons that run winetricks through Proton with real-time log output
• Prefix initialization, apply, kill processes, and delete prefix actions

WebView

Choose a WebView engine (webview2, gecko, or none) and configure the WebView2 download URL. The Install WebView2 Now button downloads and installs the Microsoft Edge WebView2 Runtime through Proton — useful for applications that depend on it.

Environment

Manage custom environment variables and DLL overrides:

• Quick-toggle checkboxes for common variables (MangoHUD, DXVK_ASYNC, DXVK_HUD, FSR, PROTON_LOG)
• Free-form table for arbitrary KEY=VALUE environment variables
• Visual DLL override editor with categorized presets for DirectX, input, audio, and NVIDIA DLLs

Drives

Map Wine drive letters to host directories. For example, mapping Y: to the base directory allows Windows applications to access those files via the drive letter. A Y: mapping is automatically created when base_dir is set. Drive mappings are applied as symlinks in the Wine prefix.

Generated Scripts

When you save an app, ProtonLaunch generates two files:

1. Launch script — ~/.local/share/protonlaunch/<app-name>.sh
2. Desktop entry — ~/.local/share/applications/protonlaunch-<app-name>.desktop

Launch Script Structure

The generated bash script is fully self-contained and runnable:

#!/usr/bin/env bash

set -euo pipefail

## @protonlaunch name=My App
## @protonlaunch description=Launch app via Proton
## @protonlaunch icon=wine
## @protonlaunch categories=Game;

PROTON_DIR="$HOME/.steam/root/compatibilitytools.d/GE-Proton10-34"
STEAM_RUNTIME="$HOME/.steam/root/steamapps/common/SteamLinuxRuntime_sniper"
BASE_DIR="/path/to/game"
EXE_DIR="${BASE_DIR}"
EXE_PATH="${EXE_DIR}/game.exe"
STEAM_COMPAT_DATA_PATH="${EXE_DIR}/12345"

# ... validation, environment exports, drive mappings ...

"${STEAM_RUNTIME}/run" -- "${PROTON_DIR}/proton" waitforexitandrun "${EXE_PATH}" "$@"

Key characteristics:

• ## @protonlaunch annotations — header metadata and section markers that bash ignores but the parser reads for round-trip editing
• Relative path references — EXE_DIR and EXE_PATH use ${BASE_DIR} references where possible for portability
• Validation — checks that proton, the executable, and the Steam Runtime exist before launching
• Environment block — custom env vars and WINEDLLOVERRIDES wrapped in # @protonlaunch env / # @protonlaunch endenv markers
• Drive mappings — symlink commands wrapped in # @protonlaunch drives / # @protonlaunch enddrives markers
• Pass-through arguments — "$@" forwards any command-line arguments to the Windows executable

Desktop Entry

The .desktop file integrates the launch script into your desktop environment's application menu with the configured name, icon, and categories.

Building

Prerequisites

• Python 3.10+
• pip, venv
• git (for version detection)

Build an AppImage

./build-appimage.sh [version]

The build script will:

1. Create a virtual environment and install dependencies
2. Run PyInstaller to bundle the application
3. Assemble an AppDir structure
4. Download appimagetool if needed
5. Produce a portable AppImage in the project directory

You can optionally pass a version string as an argument. Otherwise, it is derived from git describe --tags.

License

This project is provided as-is for educational and personal use.