Running the Cyberpunk 2077 Benchmark from the Ubuntu Terminal (With Proton) – My Journey

Intro

At first, I did everything the hard way.

Launch the game.
Open the graphics menu.
Double-check that DLSS is off.
Make sure ray tracing is really off — not just partially.
Confirm the resolution is correct.
Run the benchmark.
Wait.
Take a screenshot of the results screen.
Write the numbers down.

Then change one setting.

Run it again.

And again.

And again.

Very quickly, benchmarking Cyberpunk 2077 stopped feeling like testing and started feeling like accounting. I had screenshots everywhere. Notes scattered across files. Tables half-filled. At some point, I couldn’t even remember whether that “High” preset had ray-traced reflections enabled or if that was the previous run. Was FSR set to Performance or Balanced? Was Frame Generation actually off that time?

When you run one test, it’s manageable.
When you run twenty, it’s chaos.
When you plan to repeat everything on different hardware, it becomes impossible.

That was the moment I realized something: if I’m going to compare GPUs seriously — across presets, ray tracing modes, upscalers, and even different machines — I can’t be the benchmark runner anymore.

The benchmark has to run itself.

There’s something deeply satisfying about running a massive AAA Windows game entirely from a Linux terminal. No clicking. No launcher UI. Just raw command-line control. But this time, it wasn’t about being clever. It was about survival.

This is the story of how manual benchmarking turned into automation — and how Cyberpunk 2077 went from a screenshot-taking exercise to a fully scriptable, repeatable performance pipeline on Ubuntu with Proton.

My Setup

Here’s what I’m running:

• Ubuntu Linux
• Steam installed locally
• GE-Proton 10-25
• Cyberpunk 2077 installed on /mnt/Data
• Game AppID: 1091500

Instead of launching through Steam’s GUI, I wanted to run:

• The game executable directly
• Skip the launcher
• Skip intro videos
• Set resolution
• Run the built-in benchmark
• Save the results to a file

From the terminal. Simple idea. Not simple in reality.

The Command Line

There’s a moment when a messy process becomes a system.

I wanted to move from starting Steam with Compatibility Tools and Launch Options to running Proton directly from Bash with all the same parameters that Steam uses.

I remember staring at it, thinking: this is it. No Steam window. No Play button. No overlays. Just a blinking cursor and one long line or saying to Proton to run the game file:

STEAM_RUNTIME=1 PROTON_LOG=1 \
/home/pavel/.local/share/Steam/compatibilitytools.d/GE-Proton10-25/proton run \
/mnt/Data/Games/Steam/steamapps/common/Cyberpunk\ 2077/bin/x64/Cyberpunk2077.exe

It doesn’t look glamorous. But that line is doing far more than it seems.

STEAM_RUNTIME=1

That part is me telling the system, “Use Steam’s controlled environment. Don’t depend on whatever random libraries happen to be installed on this machine.” It’s about stability. Reproducibility. If I’m going to run the same benchmark on different hardware, I need the software environment to behave exactly the same way every time.

Then comes:

PROTON_LOG=1

That’s the moment I stopped guessing.

Before that, if something failed, I’d squint at the screen and wonder what went wrong. With logging enabled, Proton writes everything down — what Vulkan device it picked, how DXVK initialized, which DLLs loaded, and whether ray tracing was detected. Suddenly, the benchmark wasn’t a black box anymore. It was transparent.

Then we get to the heart of it:

.../GE-Proton10-25/proton run

This is where things get interesting.

I’m not clicking “Play” in Steam. I’m not asking politely through a launcher. I’m calling Proton directly — like it’s just another runtime on my system.

It feels almost rebellious.

Proton isn’t just some background magic anymore. It’s a tool I’m invoking intentionally. I’m telling it: “Take this Windows executable and make it run here. Now.”

And finally, the real star of the show:

Cyberpunk2077.exe

That’s it. The Windows binary. The same file that would normally expect a Windows desktop, DirectX drivers, and Microsoft’s ecosystem.

Instead, it’s being launched from a Linux shell prompt.

Under the hood, something incredible happens every time I press Enter.

Wine initializes.
The Proton prefix loads.
DXVK translates DirectX calls into Vulkan.
VKD3D handles DirectX 12.
The GPU driver kicks in.

And then — somehow — Night City appears on my Linux desktop like nothing unusual just happened.

The First Error: “Proton: No compat data path?”

The very first time I tried launching Cyberpunk manually, I ran:

STEAM_RUNTIME=1 PROTON_LOG=1 \
/home/pavel/.local/share/Steam/compatibilitytools.d/GE-Proton10-25/proton run \
/mnt/Data/Games/Steam/steamapps/common/Cyberpunk\ 2077/bin/x64/Cyberpunk2077.exe

And Proton replied:

Proton: No compat data path?

That message looks small.

But it’s actually Proton saying:

“I have no idea where to create the Windows environment.”

What is “compat data”?

Proton creates a Wine prefix for every Steam game.
This lives in:

steamapps/compatdata/<AppID>/

For Cyberpunk 2077, that means:

steamapps/compatdata/1091500/

Inside it is a fake Windows structure:

pfx/
  drive_c/
    users/
      steamuser/

Without this path, Proton cannot run anything.

The Fix: Define STEAM_COMPAT_DATA_PATH

So I added:

STEAM_COMPAT_DATA_PATH="/mnt/Data/Games/Steam/steamapps/compatdata/1091500"

And suddenly, Proton knew where to build its fake Windows C: drive.

That fixed the first error.

The Second Error: “Skipping fix execution”

Then came this one:

ProtonFixes WARN: Skipping fix execution. We are probably running an unit test.

This happens because GE-Proton expects to be launched by Steam.

When you run Proton manually, it doesn’t detect a proper Steam environment.

So it goes into “safe mode”.

The game may still run — but without game-specific fixes.

For Cyberpunk, that can mean instability or crashes.

Making Proton Think Steam Is Running

To fix that, I exported:

export SteamAppId=1091500
export SteamGameId=1091500
export STEAM_COMPAT_CLIENT_INSTALL_PATH="/home/pavel/.local/share/Steam"
export STEAM_COMPAT_DATA_PATH="/mnt/Data/Games/Steam/steamapps/compatdata/1091500"
export PROTON_VERB="waitforexitandrun"

Now Proton knows:

• Which game is running
• Where Steam lives
• Where the prefix lives
• That it should behave like a real Steam launch

That removed the warning.

The Working Command

Here’s the clean working version with all the parameters:

SteamAppId=1091500 SteamGameId=1091500 \
PROTON_VERB="waitforexitandrun" \
STEAM_COMPAT_CLIENT_INSTALL_PATH="/home/pavel/.local/share/Steam" \
STEAM_COMPAT_DATA_PATH="/mnt/Data/Games/Steam/steamapps/compatdata/1091500" \
STEAM_RUNTIME=1 PROTON_LOG=1 VKD3D_FEATURE_LEVEL=12_0 \
/home/pavel/.local/share/Steam/compatibilitytools.d/GE-Proton10-25/proton run \
"/mnt/Data/Games/Steam/steamapps/common/Cyberpunk 2077/bin/x64/Cyberpunk2077.exe" \
--launcher-skip --intro-skip --resolution 1920x1080

And yes. The game launched. From the terminal. On Linux. Running DirectX 12 through Vulkan. Absolutely beautiful.

Running the Built-In Benchmark

Cyberpunk 2077 includes an internal benchmark mode.

To launch it directly, just add at the end of the command:

-benchmark

So the final benchmark command becomes:

SteamAppId=1091500 SteamGameId=1091500 \
PROTON_VERB="waitforexitandrun" \
STEAM_COMPAT_CLIENT_INSTALL_PATH="/home/pavel/.local/share/Steam" \
STEAM_COMPAT_DATA_PATH="/mnt/Data/Games/Steam/steamapps/compatdata/1091500" \
STEAM_RUNTIME=1 PROTON_LOG=1 VKD3D_FEATURE_LEVEL=12_0 \
/home/pavel/.local/share/Steam/compatibilitytools.d/GE-Proton10-25/proton run \
"/mnt/Data/Games/Steam/steamapps/common/Cyberpunk 2077/bin/x64/Cyberpunk2077.exe" \
--launcher-skip --intro-skip --resolution 1920x1080 -benchmark

What happens next?

Game skips the menu. Benchmark scene starts immediately. No results screen appears. Game exits. All automatic.

Where Are Benchmark Results Saved?

Here’s the part most people miss:

You do NOT need to manually save results. Cyberpunk automatically writes a JSON file. Inside your Proton prefix:

$STEAM_COMPAT_DATA_PATH/pfx/drive_c/users/steamuser/Documents/CD Projekt Red/Cyberpunk 2077/benchmarkResults/

For me, that’s:

/mnt/Data/Games/Steam/steamapps/compatdata/1091500/pfx/drive_c/users/steamuser/Documents/CD Projekt Red/Cyberpunk 2077/benchmarkResults/

Inside you’ll find files like:

benchmark_2026_02_22_18_30_12/summary.json

These contain:

• Average FPS
• Min FPS
• Max FPS
• Resolution
• Settings
• Hardware info

Pure gold for performance testing.

Automatically Saving Terminal Output

If you also want to save everything printed in the terminal:

... -benchmark > ~/cp2077_terminal_output.txt 2>&1

Now:

• > saves standard output
• 2>&1 redirects errors too

Everything goes into a text file.

Automatically Copying Latest Benchmark File

Here’s where it gets fun.

Let’s create a script that:

1. Runs benchmark
2. Waits for it to finish
3. Copies the latest JSON file to a results folder

Create Script: run_cp2077_benchmark.sh

Here is the full command packaged into small script with all needed parameters

#!/bin/bash

export GAME_ID=1091500
export STEAM_PATH="${HOME}/.local/share/Steam"
export STEAM_ROOT="${HOME}/.steam/root"
export CUSTOM_LIBRARY_PATH="/mnt/Data/Games/Steam"
export PROTON_VERSION="GE-Proton10-25"
export PROTON_VERB="waitforexitandrun"


export STEAM_COMPAT_DATA_PATH="$CUSTOM_LIBRARY_PATH/steamapps/compatdata/$GAME_ID"
export STEAM_COMPAT_CLIENT_INSTALL_PATH="$STEAM_PATH"

export proton_path="$STEAM_PATH/compatibilitytools.d/$PROTON_VERSION"
export exe_path="$CUSTOM_LIBRARY_PATH/steamapps/common/Cyberpunk 2077/bin/x64/Cyberpunk2077.exe"


SteamAppId=${GAME_ID} \
SteamGameId=${GAME_ID} \
PROTON_VERB="waitforexitandrun" \
STEAM_COMPAT_CLIENT_INSTALL_PATH="$STEAM_PATH" \
STEAM_COMPAT_DATA_PATH="$CUSTOM_LIBRARY_PATH/steamapps/compatdata/$GAME_ID" \
STEAM_RUNTIME=1 \
PROTON_LOG=1 \
VKD3D_FEATURE_LEVEL=12_0 \
"$proton_path/proton" run \
"$exe_path" \
--launcher-skip --intro-skip -benchmark

LATEST=$(ls -t "$RESULTS_DIR"/*.json | head -n 1)
cp "$LATEST" "$EXPORT_DIR"

echo "Latest benchmark copied to $EXPORT_DIR"

Make it executable:

chmod +x run_cp2077_benchmark.sh

Run it:

./run_cp2077_benchmark.sh

Boom.

Fully automated benchmarking pipeline.

Optional: Extract FPS Automatically

Want just the average FPS?

jq '.Data.averageFps' Benchmark_*/summary.json

Or automate it:

AVG=$(jq '.Data.averageFps' "$LATEST")
echo "Average FPS: $AVG"

Now you have scriptable performance testing.

Important Notes About NTFS Drives

If your Steam library is on /mnt/Data and that drive is NTFS:

You may experience:

• Prefix corruption
• Permission issues
• Hanging at fsync: up and running

If that happens:

Move only the prefix to home:

export STEAM_COMPAT_DATA_PATH="$HOME/cp2077_prefix"

Keep game files on NTFS.

That alone fixes many mysterious Proton issues.

Why This Is So Powerful

Because now you can:

• Run benchmarks headless
• Automate GPU testing
• Compare Proton versions
• Build performance dashboards
• Script regression tests

All from Ubuntu.

No GUI.

No clicking.

Just Linux.

Conclusion

It started with a single, frustrating line:

“Proton: No compat data path?”

At the time, it felt like a wall. The game wouldn’t launch the way I expected. The benchmark wouldn’t run cleanly. And instead of clean performance numbers, I got cryptic terminal output.

But that error turned out to be the beginning.

Because once you decide not to give up, something shifts. You stop treating the system like a black box and start opening it up.

I learned how Proton actually works under the hood.
I dug into Wine prefixes and how Steam creates compatdata folders.
I figured out why GE-Proton sometimes behaves like it’s running a unit test.
I stopped relying on screenshots and started exporting benchmark results automatically.
And eventually, I built something reusable — a small Linux benchmarking pipeline I could run on any machine.

What began as a launch error became a process.
And that process became automation.

And honestly?

That’s why I love Linux gaming.

It’s not just about playing the game. It’s about understanding the layers beneath it — how Windows calls turn into Vulkan commands, how environment variables shape behavior, how a single shell script can replace hours of manual testing.

By the end of this journey, Cyberpunk 2077 wasn’t just a game I launched.

It was a workload.
A repeatable test case.
A controlled experiment I could run across different GPUs, drivers, and Proton versions — without touching a single menu.

That’s the difference between clicking “Play” and owning the stack.

And the best part?

This doesn’t have to stop here.

From this foundation, you can:

• Automatically compare Proton versions
• Log GPU statistics during every benchmark run
• Export results straight into CSV for analysis
• Or build a full benchmarking framework around it

Because once the game runs from the terminal, the rest is just scripting.

So the next time you see a strange Proton error, don’t close the terminal.

It might be the start of something much more interesting.