Running the WildStar client on a Steam Deck

Status: Untested. SteamOS runs Windows games via Proton, a compatibility layer, and the Bezgelor launch script, tools/linux/wildstar-proton.sh, runs the client through it and connects it to Bezgelor. The same script has been tested on Arch Linux with Intel graphics (Linux client guide). On the Deck it is expected to work in Desktop Mode, and from the Steam library in Game Mode with the Deck's controls mapped to keyboard and mouse. This configuration has not yet been tested. If you have a Steam Deck, please follow the steps below and report the results with the Tester checklist. Details that are most likely to need correction are marked (unverified).

You need your own copy of the WildStar client. Bezgelor does not distribute it, and nothing on this page downloads it.

What you need

• A Steam Deck with the default SteamOS. Nothing below changes the read-only system files, uses pacman or needs a sudo password. Everything goes in your home folder, which SteamOS updates leave in place.
• About 20 GB of free space: about 14 GB for the client, the rest for Proton and the Wine prefix. The client can go on a microSD card (see Storage).
• Your WildStar client folder, the one that contains Client64/WildStar64.exe.
• The server address. The commands below use bezgelor.com; for another server, put its address in its place. The Deck must reach ports 6600, 23115 and 24000 on that server (self-hosting).
• A keyboard and mouse make the first setup easier. Without them, Steam+X opens the on-screen keyboard and the right trackpad moves the pointer.

Setup

An installer script for this platform is planned. Until then, the steps are manual.

1. Switch to Desktop Mode. Press the Steam button, choose Power, then Switch to Desktop. Open Konsole from the taskbar. To copy the commands, open this page in the Deck's browser.

2. Copy the client to the Deck, so that ~/bezgelor/client/Client64/WildStar64.exe exists. From a USB drive, or over the network from another computer:

   mkdir -p ~/bezgelor/client
   rsync -a --info=progress2 user@other-pc:/path/to/WildStar/ ~/bezgelor/client/

   To keep the client on a microSD card instead, see Storage.

3. Get the Bezgelor tools. SteamOS includes git:

   cd ~/bezgelor
   git clone https://github.com/Bezgelor/bezgelor.git src

   Without git, download the repository as a ZIP file in the browser and unpack it so that ~/bezgelor/src/tools/linux/wildstar-proton.sh exists.

4. Install umu-launcher. umu-launcher starts Proton. Download the zipapp (a single umu-run file) from the umu-launcher releases page, then:

   mkdir -p ~/.local/bin
   mv ~/Downloads/umu-run ~/.local/bin/umu-run      # use the file name of your download
   chmod +x ~/.local/bin/umu-run
   ~/.local/bin/umu-run --help | head -3

   The launch script finds ~/.local/bin/umu-run by itself. The zipapp uses the system python3, which SteamOS includes. If --help reports a missing Python module, note its name in your report (unverified).

5. Check the 32-bit loader and the Vulkan driver. SteamOS includes both, because Steam needs them:

   ls /lib/ld-linux.so.2 && vulkaninfo --summary 2>/dev/null | grep -i -E 'deviceName|driverName' | head

   The output lists ld-linux.so.2 and an AMD ... (RADV ...) device. If vulkaninfo is not installed, skip the second half of the check.

6. Start the game for the first time, still in Desktop Mode:

   cd ~/bezgelor/src
   WILDSTAR_CLIENT_DIR="$HOME/bezgelor/client" tools/linux/wildstar-proton.sh bezgelor.com

   The first start takes several minutes: umu-launcher downloads the Steam Linux Runtime (about 700 MB) and GE-Proton (about 500 MB) and creates the Wine prefix. The client then asks for its language and shows the user agreement. Read it and accept it. The login dialog appears.

7. Create a launcher file for Steam. Steam runs this short file, which holds the client folder and the server address:

   cat > ~/bezgelor/wildstar-deck.sh <<'EOF'
   #!/usr/bin/env bash
   export WILDSTAR_CLIENT_DIR=$HOME/bezgelor/client
   exec "$HOME/bezgelor/src/tools/linux/wildstar-proton.sh" bezgelor.com
   EOF
   chmod +x ~/bezgelor/wildstar-deck.sh

8. Add it to Steam. In Steam (Desktop Mode), choose Games, then Add a Non-Steam Game to My Library, then Browse. Set the file filter to all files, select ~/bezgelor/wildstar-deck.sh and add it. In its Properties, rename it to WildStar. Leave the launch options empty, and do not select "Force the use of a specific Steam Play compatibility tool": the script runs Proton itself.

9. Start it from Steam. Press Play in the Desktop Mode library. The same window as in step 6 opens. If it reports python3 not found, add export PATH=/usr/bin:$PATH to the launcher file (unverified).

10. Set up the controls (Controller layout), then choose Return to Gaming Mode on the desktop and start WildStar from the library.

Controller layout

WildStar has no gamepad support; it uses keyboard and mouse only. The Deck therefore sends keyboard and mouse input, which is what the Steam Input template "Keyboard (WASD) and Mouse" does. Start from that template (Controller settings, Templates, "Keyboard (WASD) and Mouse") and change the rows below. The keys listed are WildStar's defaults; check Options, Keybinding in the game and adjust either side to match. This layout has not yet been tested. It is a starting point that takes about ten minutes to set up.

Notes:

• Action sets. In the configurator, add the action sets "Combat" (above), "UI" (right trackpad as mouse with tap-to-click, left trackpad scrolls, R2 = left click, L2 = right click) and "Chat" (face buttons Enter/Escape/Backspace). Switch between them with a button you assign (for example, Select cycles Combat to UI) or with a mode shift. To keep it simple, start with Combat and add UI later.
• Camera. WildStar turns the camera while the right mouse button is held. L2 as a hold on the right mouse button, with the right trackpad as the mouse, gives drag-to-look. The game's options may include a mouse-look mode that makes the camera follow the trackpad without L2 (unverified).
• Gyro (optional): enable it for the right trackpad's mouse while you touch it ("gyro to mouse, on touch") for fine aim on telegraphs. Leave it off until the rest of the layout is set.
• Hotbar keys. The in-game numbers are the first row of keys (1 to 0). If your hotbar differs (the Limited Action Set has eight slots), change the table. Keys not in the table, such as the Path ability and the Q/E strafe keys, belong on the radial menu.
• Sharing. Save a finished layout with Export layout, name it "WildStar" and include its name in your report, so it can be shared with other players.
• In Game Mode, open the configurator from the game's page: the controller icon, Controller Settings, then Edit Layout.

Storage

• Internal storage is the simplest choice and loads fastest. On the 64 GB model, check the free space: the client takes about 14 GB and Proton and the prefix a few GB more.
• microSD works for the client, because the script only reads it (the install folder in the prefix is a symlink to the client). Mount the card in Desktop Mode (Dolphin, select the card; it mounts under /run/media/<name or deck>/...) and set WILDSTAR_CLIENT_DIR to the folder there, both in the step 6 command and in the launcher file. Use a card formatted as ext4 (Game Mode's own Format SD card does this). exFAT and FAT cards may work, because the symlinks are made in the prefix and not on the card, but case sensitivity and permissions on them have not been tested.
• Keep the Wine prefix on internal storage (the default, ~/.local/share/bezgelor/prefix); Wine performs poorly on slow cards.
• The client writes its logs, settings and add-on data under the client folder and the prefix's user profile, so the card must be writable (unverified).

Performance

The Deck's screen is 1280x800 at 60 Hz, with a handheld APU (4 Zen 2 cores, 8 RDNA 2 compute units). The client draws through DXVK (Direct3D 11 to Vulkan). On Linux it has been tested with Intel Iris Xe integrated graphics and ran without stutter, so the graphics load is expected to be light. Suggested starting settings (unverified):

• In the client's graphics options, set the resolution to 1280x800, windowed or borderless full screen, and pick the Medium preset. Raise the view distance only when the frame rate holds.
• Cap the frame rate in the Quick Access menu (the "..." button): Performance, Frame limit 40 (or 30). A lower cap saves battery and keeps the frame time steady.
• Limit the power: Performance, advanced view, Thermal power (TDP) limit 8 W to 10 W.
• To show the frame rate, add export DXVK_HUD=fps,devinfo to the launcher file. The Deck's Performance overlay level slider also shows battery and frame rate.
• Steam's shader pre-caching does not apply to this setup. Shader compilation may cause stutter during the first minutes of play (unverified).
• Crowded areas (a city, a raid) and the Field Kit add-on are the heaviest cases. Test the base game first.

Suspend, resume and the network

Suspending the Deck (the power button) drops the network connection to the server. The client is expected to show a disconnect, and may or may not recover; log in again after a resume. Do not suspend in the middle of anything you want kept: the server decides what was saved. This behaviour has not yet been tested. A Wi-Fi connection that sleeps and reconnects can also cause a lost connection without a suspend.

Troubleshooting

• The game starts in Desktop Mode but not in Game Mode. Run the launcher file in Konsole and read the messages. Game Mode starts it under gamescope; try adding export PROTON_ENABLE_WAYLAND=0 to the launcher file.

• The game window shows but the controls do nothing, or the cursor is stuck. The game window is started by the script, so Steam Input may target the wrong window (unverified). In the shortcut's controller settings, enable "Allow desktop configuration" so that the trackpads move a plain mouse pointer. Please report this case: it is the main open question of this setup. The alternative is a Proton shortcut (below).

• umu-run not found, or a Python error. Repeat step 4 and run ~/.local/bin/umu-run --help.

• The user agreement shows, then the window closes. The 32-bit libraries are missing; see linux-client.md. SteamOS includes them, so please report this with the log.

• A 14 GB copy starts, or a launcher window with a Play button appears. The install-folder link in the prefix is missing; see "Why the script does two unusual things" in linux-client.md.

• Logs. With export PROTON_LOG=1 in the launcher file, the Proton log is written to ~/.local/share/bezgelor/logs/. The client's own NcPlatform.log is in the client folder.

• Alternative: a Proton shortcut. If the native shortcut does not work, create the starter program by hand and add it as a Steam Play shortcut:

  python3 -I ~/bezgelor/src/tools/linux/mkstart.py ~/bezgelor/wildstar-start.exe \
    'C:\Program Files (x86)\NCSOFT\WildStar\Client64\WildStar64.exe' \
    '/auth bezgelor.com /authNc bezgelor.com /lang en /patcher bezgelor.com /SettingsKey WildStar /realmDataCenterId 9'

  Add ~/bezgelor/wildstar-start.exe as a non-Steam game and force GE-Proton for it (install GE-Proton with ProtonUp-Qt from Discover, then restart Steam). Start it once so that Steam creates its prefix, at ~/.local/share/Steam/steamapps/compatdata/<id>/pfx; the newest folder in ls -t ~/.local/share/Steam/steamapps/compatdata | head -3 is <id>. Then link the client into that prefix:

  mkdir -p "<prefix>/drive_c/Program Files (x86)/NCSOFT"
  ln -s ~/bezgelor/client "<prefix>/drive_c/Program Files (x86)/NCSOFT/WildStar"

  The server address is part of the starter, so each server needs its own starter. This route has more steps; use it only if the native shortcut fails.

How it works

SteamOS already includes what the Linux desktop setup installs by hand: the 32-bit libraries and the AMD (RADV) Vulkan driver, in 32-bit and 64-bit versions, because Steam needs them. The Linux launch script therefore runs unchanged in Desktop Mode. The script starts GE-Proton through umu-launcher itself.

For Game Mode, Steam runs the launcher file as a native non-Steam shortcut, without a Steam compatibility tool. This keeps one script for Linux and the Deck, and avoids the two difficult parts of a regular Proton shortcut: finding the shortcut's compatdata/<appid>/pfx prefix to place the install-folder link in, and passing the /auth command line. Steam's launch options put the program name first, which the client does not accept; the starter program that the script builds (tools/linux/mkstart.py) passes the command line in the form the client expects. Steam applies the Deck's controls to the programs it starts, so Steam Input is expected to reach the game window, which a child process opens (unverified).

Sources

• Proton-GE install on a Steam Deck (TechRadar) and ProtonUp-Qt on Steam Deck and Linux (GamingOnLinux): install through Discover, choose the tool per game, restart Steam.
• ProtonUp-Qt: distributed as a Flatpak on Flathub.
• umu-launcher: WINEPREFIX, GAMEID, PROTONPATH.
• Customizing Steam Deck controls (Tom's Guide) and Deck back-button mappings (Evezone): input types per button, per-game layouts, back grips.
• Steam Deck Game Mode and Desktop Mode prefix locations (Steam Community thread) and Proton-GE 9-3 COPYPREFIX: where non-Steam prefixes live.
• No WildStar entry on ProtonDB and no published WildStar controller layout for the Deck were found. The layout on this page is original. If you know of one, please report it.

Tester checklist

This appendix is the form for test reports. Work through the items in order and record the result of each: pass, fail, or what you saw. If a step fails, keep NcPlatform.log (in the client folder), any Errors/WildStar64.*.txt file and the Proton log.

1. Setup. Did steps 1 to 6 complete in Desktop Mode? If one stopped, which one, and with what message? Does umu-run --help work (step 4)? Do ls /lib/ld-linux.so.2 and vulkaninfo show the expected output (step 5)?
2. Start. Does the client window open from Konsole? How long did the first start take?
3. Login. Do the user agreement and the login dialog appear, and does login work, first with a keyboard and then with the on-screen keyboard (Steam+X)?
4. Character list. Does it appear, and does the character preview render?
5. In the world. Does the world render, with sound? Which resolution does the game use?
6. Game Mode. Steps 7 to 10: does the game start from the library in Game Mode? Do the Steam overlay and the Quick Access menu work over it? If the controls do nothing, say so (see Troubleshooting).
7. Camera and movement. With the layout: walk (stick), look (right trackpad), hold right-click (L2), jump. Is it usable? What is the weakest part?
8. Combat. Target (Tab), use the hotbar through the face buttons, back grips and radial menu, interact (F). Is anything out of reach in a fight? Which keys did you move?
9. UI and menus. Open the inventory, the map and the quest log; click and drag items. Does the touchscreen help? Is a UI action set needed?
10. Chat. Open chat, type a line with the on-screen keyboard and send it. Does the keyboard open, does Enter work, and does the text go to the right box?
11. Frame rate. Record the frame rate in a quiet zone and in a busy one, with the frame cap and TDP used. Does it stutter, and for how long after you enter an area?
12. Battery. Battery percentage used after 30 minutes of play at your settings, with the screen brightness.
13. Suspend. Suspend the Deck for a minute and wake it. Does the client continue, show a disconnect, or stop responding? Does the Wi-Fi reconnect by itself?
14. Details. The Deck model (64/256/512 GB or OLED), the SteamOS version, whether the client was on internal storage or microSD, the name of your exported layout, and any corrections to this page.