Linux gaming's stuttering problem isn't Proton and a new kernel patch could reveal what it actually is

Published Aug 8, 2026, 9:00 AM EDT Richard is the PC Hardware Lead at XDA and has been covering the technology industry for almost two decades. He's been building PCs since young, and when not creating content, you can often find him inside a chassis somewhere. Linux has come leaps and bounds for gaming and general productivity. The more mature kernel and array of distros offer Windows and Mac converts a viable alternative to corporate walled ecosystems. A large part of the push for gaming on Linux has been the onslaught of gaming handhelds and the development of Proton by Valve, which allows Windows games to run as well as, if not better than, they do natively on Windows, depending on the game. It hasn't been perfect, however, but a new kernel patch suggests that some problems may be caused by other elements, including drivers. How frame timing affects gameplay It's all (quite literally) in the numbers Frame time is the precise duration it takes a system to render a single individual frame, measured in milliseconds (ms). While frame rate (FPS) is useful for measuring how well the game performs as a whole on average, frame time measures the space of time between each rendered frame. It's all interlinked because, to calculate frame time, one has to divide 1,000 milliseconds by the FPS. For instance, 60 FPS equates to an approximate 16.7ms frame time. Consistent frame times generally correlate with smoother gameplay. Let's say you have an average FPS of 60. That's pretty good for a demanding game and should result in smooth gameplay, but if the time between frames isn't consistent, you could be looking at anywhere from 16ms to 50ms, if not higher, for each frame, which is what can cause micro-stuttering. This is why we don't typically provide average FPS alone, since it doesn't provide the wider picture. A 60 FPS average reading could hide a 1% low that really drags performance down. The 1% low in a game represents the average frame rate of the slowest 1% of all frames. Let's say that a 60 FPS average reading jumps around the high 50s for a while. This isn't terrible in and of itself, but if a performance spike sends the frame rate down to 15 FPS, this will be noticeable but may not be clearly reflected in the average frame rate. That's where 1% lows come into play, allowing you to see if there are frequent hits to performance. Generally, the closer the 1% low is to the average reading, the smoother the experience should be. Frame timing can also help provide context. If a PC renders a succession of frames almost instantly with around 5ms between them, but then pauses before rendering the following frames, the counter may still report an average of 60 FPS even though the visual experience won't reflect this. Modern technologies such as Variable Refresh Rate (VRR), Nvidia G-Sync, and AMD FreeSync can help reduce the visual impact of system instability while playing games, smoothing out delivery so these inconsistencies are less noticeable. Linux has a compatibility problem Which Proton tries its level best to address Activating Proton through Steam on Linux. Most games aren't made for Linux. That's the crux of the issue. They're designed for Windows and sometimes macOS. Sure, developers can and often do release support for the open platform, but it's never guaranteed. Valve wanted to release the Steam Deck, a Linux-powered gaming handheld designed to take on the console market. Gaming on Linux wasn't perfect, so this handheld wouldn't have performed nearly as well without Valve pouring resources into Proton, a compatibility layer that utilizes other tools such as Wine, whose name stands for Wine Is Not an Emulator. There are various cogs in the machine that could be blamed for issues relating to gaming, be it Proton, DXVK, or some other part of the puzzle, but there's often something else that's completely overlooked in discussions about game performance: the kernel, CPU drivers, and system firmware. That's precisely what new kernel patches from Meta kernel developer David Vernet could look to address for AMD systems. Though testing has so far focused on the Steam Deck and its AMD APU, the epp_boost patch could benefit other supported AMD systems too. Vernet discovered a failure mode in AMD's active Energy Performance Preference (EPP) control. Though not developed by AMD, this patch is currently being reviewed by the company's Linux power-management engineers. The issue the patch aims to address relates to what happens when a latency-sensitive game thread briefly stops running while waiting for another task, a GPU fence, or a synchronization event. During these short pauses, the processor's performance-demand signal can decay, causing the thread to resume at a lower clock speed and potentially miss its frame deadline, reducing 1% lows. That's where the epp_boost patch comes in. AMD P-State delegates much of the decision-making to the platform, using minimum and maximum performance bounds alongside EPP to provide a desired balance between speed and efficiency. This is especially important for handheld and portable devices with internal batteries and limited runtime. Vernet discovered that the busy core on a Steam Deck was falling from 3.5GHz to around 2.4GHz after the game thread briefly slept. This lower operating frequency could persist for around 8ms and, in some cases, as long as a couple of seconds after the thread woke up. Testing suggested that the problem was related to firmware or the system-management unit's demand estimation rather than Proton or the compatibility layer itself. The behavior was particularly visible in a CPU-heavy game such as Civilization VI. Where epp_boost fits in It's not as simple as running everything at 100% The easy answer would be, "Well, just peg everything at 100% performance or power," but this would be detrimental to portable devices such as the Steam Deck and other gaming handhelds. That's where epp_boost can lend a helping hand by sampling each core's C0 residency, which measures how much time the core has spent actively executing work rather than sitting idle. When a sample shows that the core has been at least 50% utilized, the driver patch temporarily writes the maximum-performance value of zero to its EPP field. The previous EPP request is restored when 300ms passes without another qualifying sample. This is a much better approach than cranking all cores up to compensate. It avoids applying a maximum-performance bias to the entire CPU, helping to preserve the limited power budget shared between the processor and integrated graphics. Rather than raising the minimum frequency of the busy core or forcing every core into a performance-focused mode, epp_boost essentially provides a temporary bias to cores it finds running sustained work. The device can otherwise control the cores as usual, but it has slightly more insight into when a particular core requires a rapid performance response. So, how much performance gain is on the table? Vernet ran interleaved testing and comparisons using six iterations of Civilization VI on the LCD Steam Deck. Under default settings, the primary thread's core had a median frequency of 2.43 GHz, despite being 98% utilized throughout the benchmark. Enabling epp_boost raised this median to 3.5 GHz and improved 1% lows by 31.8%. Setting EPP to performance globally also raised the median frequency to 3.5 GHz and improved 1% lows by around 16%, but it applied the performance preference to every core and workload. A separate experiment that raised the busy core's minimum performance worsened the most extreme p999 frame times by between 13% and 21%. It's not always Proton This proposed fix shows that when you encounter performance issues, they may not always be related to Proton. Though it's usually among the first targets blamed by gamers, there can be more to the picture than first realized. It's important to consider alternatives and perform rigorous testing to see whether it's possible to narrow down precisely what could be causing performance stuttering. The epp_boost patch is still an RFC rather than an accepted mainline Linux feature, and its implementation may change as it goes through review. For AMD-powered handhelds, however, this potential kernel patch could be rather exciting. Dimensions 11.7 x 4.6 x 1.9 inches (298 x 117 x 49mm) Brand Valve Weight 1.48 pounds (669 grams) Chipset Custom AMD Zen 2-based processor (4 cores, 8 threads, up to 3.5GHz) RAM 16GB LPDDR5 5600MHz Storage Up to 512GB M.2 2230 SSD Valve's first portable gaming PC, the Steam Deck, is one of the coolest handheld gaming consoles on the market, with a huge library of games to play and the ability to take them on the go.