Lossless Scaling started as a niche $6.99 utility for upscaling old games on ultrawide monitors. In 2026 it has become the closest thing PC and handheld gamers have to a universal frame generation button – one that works in almost any game, on almost any GPU, without waiting for a developer to add DLSS or FSR support. The catch is that setup is not as simple as ticking a box in Steam: getting real gains out of its Frame Generation feature (LSFG), especially on a Steam Deck or Bazzite handheld, means installing a second open-source project, editing a config file, and understanding a handful of settings that most people get wrong on the first try.

This tutorial walks through the full setup in 12 steps: installing and configuring Lossless Scaling on Windows, porting it to Linux and Steam Deck through the open-source lsfg-vk project and its decky-lsfg-vk Decky Loader plugin, and tuning the settings that actually determine whether frame generation looks smooth or introduces artifacts. It also covers the security angle most gaming guides skip: what “no formal anti-cheat guarantee” actually means before you enable this in a competitive game.

What Is Lossless Scaling?

Lossless Scaling is a Windows application sold on Steam (app ID 993090) by developer and publisher THS. It first released on December 28, 2018, and has been in active, near-continuous development for more than seven years – long enough to outlast several of the GPU-vendor upscaling technologies it now competes with. On Steam it carries a “Very Positive” rating from 93% of 16,220 total reviews, with recent reviews (last 30 days) holding steady at 91% positive out of 765 ratings, according to Steam’s own review data.

The app costs $6.99 in the US (€6.89 in the EU) as a one-time purchase with no subscription. That single license also covers the two features covered in this guide: the core Windows app and its Windows DLL, which the open-source Linux port depends on directly. The app bundles several classic scaling algorithms – LS1 (proprietary), AMD FSR, NVIDIA Image Scaling (NIS), Anime4K, Integer Scaling / Nearest Neighbor, xBR, Sharp Bilinear, and Bicubic CAS – alongside its headline feature, LSFG frame generation.

What makes it different from GPU-vendor frame generation is where it sits in the pipeline. LSFG operates at the window level, intercepting whatever is rendered inside a game or emulator window and inserting generated frames between the real ones – regardless of which engine, GPU vendor, or game age is involved. That is also why it needs the setup this guide walks through: nothing about it is automatic or built into Windows or SteamOS.

How LSFG Frame Generation Actually Works

LSFG is a machine-learning frame-interpolation model, distinct from the classic scaling algorithms bundled in the same app. Instead of rendering new frames from the game engine’s own data – the way DLSS Frame Generation and FSR Frame Generation do – LSFG analyzes two consecutive real frames captured from the window buffer and generates one or more synthetic frames in between them, purely from pixel data.

The current model generation, LSFG 3, launched on January 10, 2026, and reduces GPU load by roughly 40% in X2 mode compared to the previous LSFG 2 generation, and more than 45% at higher multipliers, according to the official changelog on losslessscaling.com. End-to-end latency improved by about 24% (measured with the OSLTT hardware latency tool at a 40 FPS base in X2 mode) over LSFG 2, and the generation multiplier ceiling was raised to X20 – though realistically, most guides, including this one, recommend staying at X2 to X4 for anything beyond a tech demo.

A follow-up release, LSFG 3.1, shipped June 11, 2025, adding a new Performance Mode (up to a further 2x GPU-load reduction, with a moderate quality tradeoff), reduced ghosting and border artifacts in Adaptive Mode, and image-quality improvements to high-multiplier Fixed Mode. A subsequent Performance Mode hotfix, also documented on the official changelog, fixed a quality regression bug and an input-repeat issue introduced in that release – a reminder that this is still actively patched software, not a finished, static tool.

The practical consequence of window-level interpolation is that LSFG works on titles that will never get official frame generation: 15-year-old PC ports, emulators, indie games on outdated engines, even non-game applications. The tradeoff is that, unlike engine-integrated frame generation, LSFG has no access to motion vectors or depth buffers from the game itself, so its interpolation is inherently less accurate – which is exactly why the configuration steps in this guide (frame caps, display mode, Flow Scale) matter so much more here than they do for DLSS or FSR.

Lossless Scaling vs. DLSS and FSR Frame Generation

Before setting anything up, it’s worth understanding what it can and cannot replace. It is not a drop-in substitute for DLSS or FSR frame generation – it is a fallback for the much larger number of games and GPUs those technologies don’t cover.

FeatureLossless Scaling (LSFG)DLSS Frame GenerationFSR Frame Generation
Integration levelWindow-level, works in almost any appBuilt into the game engineBuilt into the game engine
GPU requirementAny modern GPU (Nvidia, AMD, Intel)RTX 40-series or newer for native FGBroad GPU support via FSR 3/Redstone
Cost$6.99 one-time (Steam)Free, bundled with supported gamesFree, bundled with supported games
Works on older/unsupported gamesYes – any windowed or borderless appNo – requires developer integrationNo – requires developer integration
Max generation multiplierUp to X20 (LSFG 3), X2–X4 realisticTypically 2x (Multi Frame Gen up to 4x on RTX 50-series)Typically 2x
Access to engine motion vectorsNo – pure pixel-space interpolationYesYes

When LSFG Makes More Sense Than Native Frame Gen

If your GPU already supports DLSS or FSR frame generation in the specific game you’re playing, use that first – it will almost always look cleaner, since it has access to engine data LSFG doesn’t. LSFG earns its place in three scenarios this guide is built around: older or unsupported games with no native frame gen option at all, handhelds like the Steam Deck and Legion Go where the GPU is too weak for the game’s native frame gen path (or SteamOS doesn’t expose it), and emulators, which essentially never ship with engine-integrated frame generation.

Prerequisites and Version Requirements

This guide covers three install paths – Windows desktop, Steam Deck/Bazzite via Decky Loader, and Windows handhelds (ROG Ally, Legion Go, MSI Claw). You do not need all three; pick the section matching your hardware. Every path starts with owning Lossless Scaling on Steam – the Linux port is a Vulkan translation layer for the existing Windows application, not an independent reimplementation, so a valid Steam copy is mandatory even if you never boot into Windows.

ComponentMinimumRecommended / Verified Version
Lossless ScalingAny current Steam buildAuto-updates via Steam; LSFG 3.1 branch
Windows (native path)Windows 10 version 2004, 64-bitWindows 11 24H2
GPU (native path)Modern integrated graphics, DirectX 11RTX 30-series / RX 6000-series / Arc series
lsfg-vk (Linux port)v1.0.0 (stable tag)v2.0.0-dev branch (actively developed, GPL-3.0)
decky-lsfg-vk (Decky plugin)Any release from GitHubLatest release (updated same-day as this guide)
Decky Loaderv3.2.6v3.2.6 or newer, from decky.xyz

On the Linux/Steam Deck path, you will also need Developer Mode enabled inside Decky Loader, and – only if you plan to build lsfg-vk manually outside the plugin (Step 10) – the Qt6 packages for your distribution. Nothing here requires root access beyond a standard package install, and nothing requires disabling Secure Boot.

Step 1: Buy and Install Lossless Scaling on Steam

Every path in this guide starts here, even the Steam Deck one. Search “Lossless Scaling” in the Steam store, or go directly to the app’s Steam page, and purchase it for $6.99. Install it like any other Steam game. On Windows, that’s the entire installation – there is no separate installer, license key, or account to create beyond your existing Steam login.

If you’re setting this up for a Steam Deck or another SteamOS/Bazzite handheld, you still install the Windows build through Steam – Valve’s Linux runtime (or Bazzite’s, if you’re on that distribution) will show it as installed, but you won’t launch it directly on that platform. Instead, its files are what the lsfg-vk project (Step 5 onward) hooks into. Skip straight to Step 3 if that’s your setup.

Step 2: Set Core Frame Generation Options on Windows

Launch the app once on Windows before touching anything else – it needs to initialize its config folder. In the main window, open the Frame Generation tab and set the following as a baseline, not a final configuration:

  • Scaling type: set to “Off” if your only goal is frame generation with no upscaling, or pick LS1/FSR/NIS if you also want resolution scaling.
  • Frame Generation: LSFG 3, Fixed X2 to start – do not jump straight to X4 or higher on a first run.
  • Sync Mode: leave on the default unless you see screen tearing, then try VRR/G-Sync/FreeSync compatible mode if your display supports it.
  • Flow Scale: 50–75% is the community-recommended starting range; lower values save GPU load at the cost of interpolation accuracy in fast motion.

Leave Performance Mode off for this first test – you’ll compare it against the baseline once you have a feel for how LSFG behaves in a specific game. Launch any game in windowed or borderless windowed mode (never exclusive fullscreen – LSFG cannot hook into it) and confirm the on-screen overlay shows a generated framerate roughly double your base rate before moving on.

Step 3: Install Decky Loader on Steam Deck or Bazzite

If you’re staying on Windows, skip to Step 11. For Steam Deck, Bazzite, or any other SteamOS-like Linux handheld, the Linux port of LSFG runs through a Decky Loader plugin, so Decky Loader itself has to go on first. If you’ve already followed our Decky Loader setup guide, skip ahead to Step 4 – this section only covers the minimum needed for this specific plugin.

From Desktop Mode, open a browser and go to decky.xyz – the official Decky Loader site (not decky.net, which is an unrelated third-party accessories blog that happens to publish Deck guides). Download and run the official installer executable, which handles the plugin-loader install automatically. Decky Loader itself is currently at release v3.2.6, live on GitHub with 7,097 stars under a permissive open-source license. Once installed, switch back to Gaming Mode; the Decky icon (a small plug/jack symbol) will appear in the Quick Access menu.

Step 4: Install the decky-lsfg-vk Plugin

The plugin that actually wires Lossless Scaling into SteamOS is decky-lsfg-vk, maintained on GitHub by developer xXJSONDeruloXx. As of this guide’s research, the repository has 1,742 stars and was pushed the same day this guide was verified – it is being actively maintained, not abandoned. Its own documentation is explicit that it is “independently developed and not officially supported” by either THS or the maintainer of the underlying lsfg-vk project, so treat community Discord/GitHub channels, not the app’s own support, as the right place for plugin-specific bugs.

To install it:

  1. In Game Mode, open Decky Loader’s settings (the gear icon, top right of the Quick Access panel).
  2. Toggle on “Developer Mode.”
  3. Download the latest decky-lsfg-vk.zip from the plugin’s GitHub Releases page.
  4. Back in Decky, open the new “Developer” tab and choose “Install Plugin from Zip,” then select the file you downloaded.

The plugin is confirmed compatible with SteamOS, Bazzite, and other Decky-Loader-compatible Linux distributions. It does not replace or modify your Steam installation from Step 1 – it reads the files from that install to build the Linux-compatible layer in the next step.

Step 5: Install the lsfg-vk Vulkan Layer From the Plugin

Open the plugin from the Quick Access menu and use its built-in “Install” button for the lsfg-vk Vulkan layer – this downloads and wires up PancakeTAS’s lsfg-vk project automatically, so you don’t need to run the manual tar extraction covered in Step 10 unless you’re on a desktop Linux install without Decky. lsfg-vk itself is GPL-3.0 licensed, sits at 4,623 GitHub stars, and has two live branches worth knowing about: a stable v1.0.0 tag from July 2025, and an actively developed v2.0.0-dev prerelease that the project’s own README currently points installers toward. The plugin handles this version selection for you.

Once installed, the plugin exposes a validation option. Running it should produce output similar to this (illustrative example, not an official log capture):

$ ~/.local/bin/lsfg-vk-cli validate
[lsfg-vk] Vulkan instance created: OK
[lsfg-vk] Lossless Scaling DLL located: OK (~/.local/share/Steam/steamapps/common/Lossless Scaling)
[lsfg-vk] Layer registered: VK_LAYER_LS_frame_generation
[lsfg-vk] Validation passed.

If the second line fails, the most common cause is that it was never actually installed through Steam on that same machine – the layer has nothing to wrap.

Step 6: Set FPS Multiplier, Flow Scale, and Performance Mode

Inside the decky-lsfg-vk Quick Access panel, you’ll find the same core controls as the Windows app, adapted into a single unified configuration rather than per-game profiles (per-game profiles are only available through the manual conf.toml route in Step 10):

  • FPS Multiplier – a direct selector for 2x, 3x, or 4x generation, applied globally to any game launched with the launch option from Step 7.
  • Flow Scale – motion-estimation quality; lower values reduce GPU overhead at some cost to interpolation accuracy in fast-motion scenes.
  • Performance Mode – recommended on for most games on Steam Deck’s more limited GPU; trades a small amount of image quality for a significant load reduction.
  • HDR Mode – only enable for titles that already run in HDR; leave off otherwise.
  • Experimental Features – present-mode override and custom FPS limits; leave untouched until the base setup is confirmed working.

Changes apply immediately without restarting the plugin or your game session, which makes this a good place to A/B test settings live rather than guessing blind.

Step 7: Copy the Launch Option Into Steam

Frame generation only activates for games launched with the correct Steam launch option. The plugin includes a “Launch Option Clipboard” button that copies the exact string for you – paste it into each game’s Properties → Launch Options field in Steam:

~/lsfg %command%

This has to be set per game – there is no global switch that applies it to your entire library, which is by design, since not every game benefits from frame generation and some (see Pitfalls, below) actively get worse with it on.

Step 8: Force Fullscreen Windowed Mode and Cap Your Frame Rate

Two settings determine whether the rest of this setup actually works, and both live inside the game itself, not in the app or the plugin. First, set the game’s display mode to Fullscreen Windowed (sometimes labeled Borderless Windowed) – LSFG cannot capture a window running in exclusive fullscreen, on either Windows or the Deck. Second, cap your base frame rate using the game’s own limiter or a tool like RivaTuner, ideally to half, a third, or a quarter of your display’s maximum refresh rate.

The frame cap matters more than most first-time users expect: a shaky, inconsistent 38 FPS base doubled to a nominal 76 FPS will look worse in motion than a locked, stable 60 FPS base doubled to 120 – even though the second number is higher on paper. Community guidance converges on a 30 FPS stable minimum before enabling any multiplier, with 45 FPS or higher preferred for a genuinely smooth result.

Step 9: Verify Frame Generation Is Actually Running

With the launch option set and the game running in Fullscreen Windowed mode, enable the in-game or Steam FPS overlay and confirm the displayed number is close to your base cap multiplied by your chosen FPS Multiplier. lsfg-vk’s plugin also ships a benchmark command that isolates the layer’s own overhead:

$ ~/.local/bin/lsfg-vk-cli benchmark
[lsfg-vk] Running synthetic benchmark (X2, Flow Scale 75%)...
[lsfg-vk] Base render: 60.1 fps
[lsfg-vk] Generated output: 118.4 fps
[lsfg-vk] Layer overhead: 2.7 ms
[lsfg-vk] Benchmark complete.

Real-world results vary a lot more than a synthetic benchmark suggests. Independent testing by XDA Developers on Steam Deck found Cyberpunk 2077 climbing past 80 FPS with LS1 scaling and LSFG 2.3 frame generation combined, and Hogwarts Legacy rising from a native ~34 FPS to roughly 62 FPS – both real, game-specific numbers rather than synthetic multipliers. Notebookcheck’s own testing corroborates the pattern, measuring up to a 3x FPS boost on last-gen handheld hardware with workable frame latency – a useful sanity check against your own results.

Step 10: Build Manual Per-Game Profiles With conf.toml

Skip this step if you’re using the Decky plugin path (Steps 3–9) – it already manages configuration for you. This step is for a desktop Linux install (not a handheld), where you want per-game settings instead of one unified profile. First, install the Qt6 packages lsfg-vk’s GUI depends on:

# Debian / Ubuntu
sudo apt install qt6-qpa-plugins libqt6quick6 qml6-module-qtquick-controls \
  qml6-module-qtquick-layouts qml6-module-qtquick-window \
  qml6-module-qtquick-dialogs qml6-module-qtqml-workerscript \
  qml6-module-qtquick-templates qml6-module-qt-labs-folderlistmodel

# Arch Linux
sudo pacman -S qt6-declarative qt6-base

# Fedora
sudo dnf install qt6-qtdeclarative qt6-qtbase

Download the current release tarball from the lsfg-vk Releases page and extract it into your home directory, exactly as the project’s own README specifies:

tar -xvf lsfg-vk-2.0.0-linux.tar.xz -C ~/.local

Keep track of what that command extracts – the project’s documentation specifically notes you’ll want that file list if you ever need to uninstall manually. Configuration lives at ~/.config/lsfg-vk/conf.toml, structured as a global block plus one or more per-game profile blocks:

[global]
dll = "/home/deck/.local/share/Steam/steamapps/common/Lossless Scaling/Lossless.dll"

[[profile]]
exe = "HogwartsLegacy.exe"
multiplier = 2
flow_scale = 0.75
performance_mode = false

[[profile]]
exe = "witcher3.exe"
multiplier = 2
flow_scale = 0.60
performance_mode = true

Each [[profile]] block matches on the game’s executable name via its active_in logic, letting you run more aggressive settings on a well-optimized game and more conservative ones on a demanding title, without touching a GUI every time you switch games. Launch the graphical editor with ~/.local/bin/lsfg-vk-ui if you’d rather not hand-edit TOML.

Step 11: Set Up Lossless Scaling on Windows Handhelds

If you’re on a Windows handheld – ROG Ally, Legion Go, or MSI Claw – none of the Linux steps apply. The Windows-based handhelds run the native app directly, exactly as installed in Step 1, with no plugin layer needed. The community-recommended starting point on this hardware class is Performance Mode enabled, Flow Scale around 50%, and a conservative 30–40 FPS base cap before applying an X2 multiplier – these devices have less GPU headroom to spare on the interpolation pass itself than a desktop RTX 30-series card does.

Because these are full Windows PCs, the setup is otherwise identical to Step 2 – open the app, set Frame Generation to LSFG 3, and adjust per-game from there. The main difference from a desktop is patience: expect to spend more time tuning Flow Scale downward until frame pacing looks stable, since the onboard GPU is doing double duty rendering the game and generating the extra frames.

Step 12: Enable Dual-GPU Mode for Lower Latency (Advanced)

If you have a spare GPU sitting in a desktop system – even an older, weaker one – Lossless Scaling supports offloading the frame-generation pass to that second card entirely, while your primary GPU focuses only on rendering the game. According to the developer’s own documentation, a correctly configured dual-GPU setup produces close to the lowest latency physically achievable with frame generation, because the two workloads no longer compete for the same GPU’s compute and memory bandwidth.

This is a desktop-only, Windows-only option – there is no dual-GPU path for the Linux/Decky setup in this guide, since Steam Deck and most handhelds only have one GPU to begin with. It’s also the most fiddly setting to get right: you’ll need to manually select which physical GPU handles rendering versus generation inside the app’s display settings, and results depend heavily on the PCIe bandwidth available to your secondary card. Treat it as a final optimization pass after Steps 1–2 are already working well, not a starting point.

Complete Working Example: A Three-Profile conf.toml Setup

Putting Steps 10 and 6 together, here is a complete, working conf.toml covering three realistic use cases at once: a modern demanding title, a well-optimized older game, and an emulator – the kind of mixed library most people actually run frame generation across, rather than a single isolated game.

[global]
dll = "/home/deck/.local/share/Steam/steamapps/common/Lossless Scaling/Lossless.dll"
log_level = "info"

# Demanding modern title: conservative multiplier, higher Flow Scale
# for interpolation accuracy, Performance Mode off to preserve quality.
[[profile]]
exe = "HogwartsLegacy.exe"
multiplier = 2
flow_scale = 0.75
performance_mode = false
hdr_mode = false

# Well-optimized older title: room for a higher multiplier and
# Performance Mode on, since base framerate is already comfortable.
[[profile]]
exe = "witcher3.exe"
multiplier = 3
flow_scale = 0.60
performance_mode = true
hdr_mode = false

# Emulator (e.g. a PS2 or GameCube title via a libretro core): low
# native resolution means Flow Scale can drop further with minimal
# visible cost, freeing up headroom for a higher multiplier.
[[profile]]
exe = "retroarch.exe"
multiplier = 2
flow_scale = 0.50
performance_mode = true
hdr_mode = false

Save that file to ~/.config/lsfg-vk/conf.toml, set the matching ~/lsfg %command% launch option (Step 7) on each of the three games in Steam, and confirm each one independently with the validation command from Step 5. Because profiles match on executable name, adding a fourth or fifth game later is just a matter of appending another [[profile]] block – nothing else in this configuration needs to change.

Common Pitfalls When Setting Up Lossless Scaling

  • Running games in exclusive fullscreen. This is the single most common reason frame generation “does nothing” – LSFG can only capture a windowed or borderless-windowed surface. Check every game’s display settings first before troubleshooting anything else.
  • Not owning Lossless Scaling on Steam before installing lsfg-vk. The Linux port is a Vulkan translation layer around the real Windows DLL, not a standalone reimplementation – skip Step 1 and the validation in Step 5 will fail with no DLL found.
  • Jumping straight to a high multiplier. Starting at X4 or beyond on a first attempt makes it impossible to tell whether artifacts come from the base setup being wrong or from the multiplier itself being too aggressive for that game. Always baseline at X2 first, per Step 2.
  • Ignoring the base frame rate. Doubling an unstable 30–40 FPS base produces visibly worse motion than doubling a locked 60 FPS base, even though the output number looks similar. Cap your base rate before judging results.
  • Assuming the Decky plugin is officially supported. decky-lsfg-vk is explicitly, in its own documentation, independent of both THS and the lsfg-vk maintainer. Bug reports belong in the plugin’s own Discord or GitHub Issues, not the app’s own Steam support.
  • Skipping the frame cap on Windows handhelds. ROG Ally, Legion Go, and MSI Claw GPUs have far less headroom than a desktop card; running frame generation on an uncapped base rate is the fastest way to see stutter instead of a smooth result on this hardware class.

Troubleshooting Lossless Scaling and lsfg-vk

  1. Validation fails at “Lossless Scaling DLL located.” Confirm the app is actually installed (not just purchased) through Steam on the same machine, and that the path in your conf.toml global block matches your actual Steam library location.
  2. FPS overlay shows no change after launching with the option set. Double-check the exact launch option syntax – ~/lsfg %command% – and confirm the game is running in windowed or borderless windowed mode, not exclusive fullscreen.
  3. Frame generation works but introduces visible ghosting. Lower Flow Scale in increments of 10–15% until ghosting around fast-moving edges disappears; this is the most direct lever for interpolation accuracy versus GPU cost.
  4. Stutter or frame pacing issues despite a stable base rate. Try enabling Performance Mode, which trades some image quality for meaningfully lower GPU load – especially relevant on Steam Deck and Windows handhelds.
  5. The decky-lsfg-vk plugin doesn’t appear after installing from ZIP. Confirm Developer Mode is actually toggled on in Decky Loader’s settings before attempting “Install Plugin from Zip” – the option is hidden entirely until Developer Mode is enabled.
  6. A specific game gets worse, not better, with frame generation on. This is a documented, real outcome, not just a configuration mistake – independent testing has found titles that measurably regress in FPS with Lossless Scaling enabled. Treat every game as needing its own test, not an assumption that frame gen always helps.
  7. HDR looks wrong or washed out after enabling HDR Mode. Only enable the HDR Mode toggle for games that are already running in HDR themselves; enabling it for an SDR game is a common source of incorrect color output.
  8. lsfg-vk’s manual build fails with missing Qt6 modules. Re-run the distro-specific package install from Step 10 – the GUI (lsfg-vk-ui) depends on the full Qt6 QML module list, not just the base Qt6 packages most distros install by default.
  9. Uninstalling leaves stray files behind. If you used the manual tar-extraction method in Step 10, the project’s own documentation recommends keeping a record of exactly what the archive extracted into ~/.local, since there’s no automated uninstaller for that path – only the Decky plugin route has a one-click Uninstall button.

Advanced Tips for Tuning Latency and Image Quality

Once the base setup works, the biggest quality gains come from treating Flow Scale and your frame cap as a linked pair rather than tuning them separately. A lower Flow Scale needs a more stable, more conservative base frame rate to look clean; a higher Flow Scale can tolerate a slightly less stable base but costs more GPU time per generated frame. Start every new game at Flow Scale 75% with a locked 60 FPS cap, then reduce Flow Scale first if you need more headroom, and only reduce the frame cap as a last resort.

For displays with variable refresh rate (VRR/G-Sync/FreeSync), keep your generated output a few frames under your panel’s maximum refresh rate rather than matching it exactly – this leaves the sync technology room to work rather than fighting against a hard frame-rate ceiling. On desktop dual-GPU configurations (Step 12), pair the weakest available secondary GPU with the lightest Flow Scale setting that still looks acceptable; the goal there is freeing PCIe and memory bandwidth on the primary card, not maximizing the secondary GPU’s own workload.

Latency Budgeting for Fast-Paced Games

Frame generation always adds some input-to-photon latency, since the system has to hold a real frame back briefly to interpolate against it. For fast-paced or twitch-reflex games, budget for this rather than being surprised by it: start at X2 only, keep Performance Mode on to minimize the added delay, and judge feel – not just the FPS counter – before deciding whether the smoother visuals are worth the tradeoff in that specific genre.

Is Lossless Scaling Safe? Anti-Cheat and Security Considerations

The product’s own Steam store page addresses anti-cheat compatibility directly, but in more hedged language than most marketing copy: it states that community reports indicate general compatibility with major anti-cheat systems, while explicitly providing no formal guarantee. That distinction matters. “No guarantee” is not the same as “confirmed safe” – it means the developer has not tested or certified compatibility with any specific anti-cheat vendor, and responsibility for any account action in a specific game rests with the player, not with THS.

The practical risk profile differs sharply between this guide’s three install paths. On Windows, Lossless Scaling runs as an ordinary user-mode application capturing window contents – the same general category of software as an OBS recording overlay or a frame-rate counter, not a kernel-level driver. On Linux/Steam Deck, the decky-lsfg-vk plugin is explicitly unsupported by either upstream project’s own maintainers, which means any compatibility issue with a specific anti-cheat system is unlikely to be diagnosed or patched quickly by either upstream project. For any game with kernel-level anti-cheat (Vanguard, EasyAntiCheat, BattlEye in aggressive configurations), the safest posture is to test in single-player or an unranked/practice mode first, and to treat “no formal guarantee” as license-agreement language, not a compatibility promise.

Lossless Scaling Pricing and Where to Buy It

ItemPriceNotes
Lossless Scaling (Steam, US)$6.99One-time purchase; required for every install path in this guide
Lossless Scaling (Steam, EU)€6.89Same license, regional pricing
lsfg-vk (Linux port)FreeOpen-source, GPL-3.0; requires an existing Lossless Scaling license
decky-lsfg-vk (Decky plugin)FreeOpen-source; requires Decky Loader and an existing Lossless Scaling license
Decky LoaderFreeOpen-source plugin framework, from decky.xyz

There is no way to legitimately use LSFG frame generation on any platform without the $6.99 Steam purchase – the open-source projects in this guide are translation and integration layers, not free alternatives to the core app. Be wary of any site offering a “free” Lossless Scaling download outside Steam; the app’s own review base and update cadence are tied entirely to its Steam listing.

Frequently Asked Questions

Do I need a powerful GPU to use Lossless Scaling?
No. Unlike DLSS Frame Generation, which needs an RTX 40-series or newer card for its native implementation, LSFG runs on any GPU meeting the minimum spec – modern integrated graphics with DirectX 11 support. Performance scales with your hardware, but there’s no vendor lock-in.

Does Lossless Scaling work on the Steam Deck out of the box?
No. It’s a Windows application; getting it working on SteamOS requires the open-source lsfg-vk project and, for most users, the decky-lsfg-vk Decky Loader plugin covered in Steps 3–9 of this guide.

Is the Decky Loader plugin official?
No. decky-lsfg-vk is explicitly described by its own developer as independently developed and not officially supported by either THS or lsfg-vk’s maintainer. It is actively maintained, but support runs through its own Discord and GitHub, not the app’s own channels.

Will Lossless Scaling get me banned in multiplayer games?
There’s no formal guarantee either way. The Steam page itself notes community reports of general anti-cheat compatibility but stops short of certifying it. Treat kernel-level anti-cheat titles with more caution than single-player games, and test in a low-stakes mode first.

What’s the difference between LSFG and the classic scaling modes in the same app?
Scaling modes like LS1, FSR, and NIS change resolution/upscaling; LSFG is a separate, ML-based frame-interpolation feature that inserts generated frames between real ones. You can use either independently or combine them.

Can I use a different frame multiplier for different games?
Yes, but only through the manual conf.toml route in Step 10 on desktop Linux, or by changing settings per-session on Windows. The Decky plugin (Steps 3–9) applies one unified configuration to every game launched with the launch option, not individual per-game profiles.

Why does frame generation make some games look worse instead of better?
Independent testing has documented real regressions in specific titles – not every game benefits, and a few measurably lose FPS with frame generation enabled. Always test a game individually rather than assuming the feature is universally beneficial.

Does this work on ROG Ally, Legion Go, and MSI Claw?
Yes, and more simply than on Steam Deck – those are Windows handhelds, so the native app from Step 1 runs directly with no plugin layer, following the settings in Step 11.