Short of a couple of games, there's one app that's made the switch to Linux difficult — Lossless Scaling. It's actually an app I need more on Linux than I do on Windows, as both AMD and Nvidia don't offer their driver-level frame generation features on Linux. Officially, Lossless Scaling only works on Windows. However, one developer, with some help from the Lossless Scaling devs, is working on an open-source project to bring Lossless Scaling's excellent frame generation to Linux.

It works, and you can get set up with Lossless Scaling on Linux now, provided you own the app on Steam. It's far from a finished product, but frame generation on Linux has come a long way in just a few weeks.

Lossless Scaling on Linux... but how?

You can't just throw Proton at the problem

Lossless Scaling is tricky. It's a DirectX 11 application, essentially, but it's not a game and it doesn't do any rendering. Although you might assume that you can just throw Proton at the problem, you can't. Lossless Scaling won't work on Linux, even with Proton. The developer of lsfg-vk, which is the project porting Lossless Scaling's frame generation to Linux, says that they accomplished the port in two parts. First, the DirectX 11 shaders are translated to Vulkan with DXVK, which itself is basically the backbone of Proton. Then, they had to rewrite the shader pipeline in DirectX 11 so it could be converted with DXVK to Vulkan.

"The first step to translating D3D11 to Vulkan, is to not translate D3D11 to Vulkan. Instead, it is to translate D3D11 to D3D11, and then to Vulkan," writes the developer.

If you've used Lossless Scaling on Windows before, the setup process is a bit different on Linux. First, you need to install Lossless Scaling through Steam. After that's done, you can pull the shell script with the following command (or clone the GitHub):

curl -sSf https://pancake.gay/lsfg-vk.sh | sh

There are a few options for different distros, including Arch, Debian, and Fedora-based distros. The project was started on Arch, and I'm using CachyOS, which is based on Arch. If you're using a different distro, you might encounter issues.

That's all you need to do to install the project. Configuring it is a bit more involved. All the configuration options are handled as environment variables, which you can set up either through the command line or as a launch option in Steam. Thankfully, the developer has a document detailing all the variables, fit with optimal settings, notes, and even a short tutorial on setting environment variables up.

The easiest way to configure it, though, is to just set launch options in Steam. This is the most consistent setup I had while testing:

ENABLE_LSFG=1 LSFG_MULTIPLIER=4 DXVK_FRAME_RATE=60 %COMMAND%

​​​​​​​I'm using a 240Hz monitor, so I set an fps cap at 60 and used a 4x multiplier with Lossless Scaling. I mainly wanted to test out if 4x frame generation would work on Linux, and it does, but I'll probably swap back to 2x frame generation and set the DXVK cap at 120. There are variables available for the big-ticket features in Lossless Scaling, including flow scale, performance mode, and HDR support, but the more variables you add, the less consistently Lossless Scaling works. You'll probably need to adjust the settings on a per-game basis, but the basics should be enabling LSFG, setting your multiplier, and setting an fps cap.

When it works, it works

And when it doesn't, it doesn't

The top of the GitHub page for lsfg-vk states very clearly: "This is a work-in-progress. While frame generation has worked in quite a few games, compatibility in many games as well as frame pacing issues still need to be fixed." It's shocking that the port works as well as it does given how much is going on behind the scenes, but it won't just work across games like Lossless Scaling does on Windows. There are problems, and depending on your GPU, distro, monitor, game, LSFG settings, and even game settings, you might run into issues.

I tried it out in Elden Ring: Nightreign, Lies of P, and Stellar Blade, and frame generation worked perfectly in Nightreign and Stellar Blade. My biggest complaint is that there's no way to tell if frame generation is working. I used a 4x scale to go from 60 to 240, so it was pretty obvious that frame generation was on. In a situation where you're going from 120 to 240, however, it can be difficult to tell. The game launches with LSFG enabled from the start, so there's no point of reference when you're going from already high frame rates to even higher ones.

I couldn't get it working in Lies of P, though, which is on the list of compatible games. Thankfully, you can spit out a log, and the developer seems very active in the Lossless Scaling Discord. But if you're expecting a seamless experience, you won't find it right now. The developer has a list of quirks on GitHub, and it includes everything from setting an fps cap to running games in windowed mode.

Frankly, though, it works much better than I expected. The project is less than a month old at the time of writing, and it's already seen 143 commits on GitHub (it might be even more depending on when you're reading this). It's extremely impressive given that this project is from a solo developer who's still in school. Further, they're extremely active in the Lossless Scaling Discord, and they've already managed to get LSFG 3.1 and the flow scale setting working with the help of the Lossless Scaling developer. Lsfg-vk doesn't have the full seal of approval yet, but given enough patches, it might eventually work its way into official Lossless Scaling.

Where does it go from here?

There's been a ton of progress already

PancakeTAS's most recent update on lsfg-vk hinted that some "pretty big changes" are coming to the project soon, but it's not clear what those changes are or when they'll arrive. I suspect the next update will target frame pacing issues. Apparently, due to how the project works right now, you'll encounter stuttering and frame pacing issues depending on the game you're playing, and the frame rate you're playing at. There could be work to make the injection more consistent than it is now, and hopefully less dependent on specific games and configurations.

That's just a guess, though. I'm more interested in where this project ends up a few months down the line. One of the obvious next steps would be a GUI, even if it could just spit out a string of launch variables for Steam based on what you have set up. Unlike Lossless Scaling proper, this is an open-source project, so if you can throw together a simple GUI, you know where to contribute.

It would be great for official Linux support somewhere down the road, too. That could be the plan, given that the developer of Lossless Scaling is helping out with the lsfg-vk project, but that's just speculation on my part. It might not be possible to have as seamless of an experience on Linux as Lossless Scaling offers on Windows. I'm not sure how official support would arrive, either, given that lsfg-vk is an open-source project.

We're off to the races

There's been a ton of progress on lsfg-vk in just a few weeks, which is great to see. I'm certainly not alone in wanting Lossless Scaling to work on Linux, and lsfg-vk makes what seemed like a pipedream a reality. It's far from perfect, but lsfg-vk works enough of the time that it's worth installing now.