More UI adjustments

CMakeLists.txt

@@ -339,13 +339,26 @@ if (CXX_GCC OR CXX_CLANG)
         endif()
     elseif(ARCHITECTURE_arm64)
         # See https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html
-        set(YUZU_BUILD_PRESET "custom" CACHE STRING "Build preset to use. One of: custom, generic, armv9, native")
         set(mtune generic)
+        set(armv8_2_target armv8.2-a+fp16+dotprod)
 
-        if (${YUZU_BUILD_PRESET} STREQUAL "generic")
-            set(march armv8-a)
-        elseif (${YUZU_BUILD_PRESET} STREQUAL "armv9")
-            set(march armv9-a)
+        if (ANDROID)
+            set(YUZU_BUILD_PRESET "custom" CACHE STRING "Build preset to use. One of: custom, armv8.2, armv9, native")
+            set(march ${armv8_2_target})
+
+            if (${YUZU_BUILD_PRESET} STREQUAL "armv9")
+                set(march armv9-a)
+            endif()
+        else()
+            set(YUZU_BUILD_PRESET "custom" CACHE STRING "Build preset to use. One of: custom, generic, armv8.2, armv9, native")
+
+            if (${YUZU_BUILD_PRESET} STREQUAL "generic")
+                set(march armv8-a)
+            elseif (${YUZU_BUILD_PRESET} STREQUAL "armv8.2")
+                set(march ${armv8_2_target})
+            elseif (${YUZU_BUILD_PRESET} STREQUAL "armv9")
+                set(march armv9-a)
+            endif()
         endif()
     endif()
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -38,6 +38,8 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_VERTEX_INPUT_DYNAMIC_STATE("vertex_input_dynamic_state"),
     RENDERER_SAMPLE_SHADING("sample_shading"),
     RENDERER_FRAME_GEN("frame_gen"),
+    RENDERER_FRAME_GEN_FP16("frame_gen_fp16"),
+    RENDERER_FRAME_GEN_FLOW_SCALE_AUTO("frame_gen_flow_scale_auto"),
     RENDERER_FRAME_GEN_DUMP_FLOW("frame_gen_dump_flow"),
     GPU_UNSWIZZLE_ENABLED("gpu_unswizzle_enabled"),
     PICTURE_IN_PICTURE("picture_in_picture"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt

@@ -19,6 +19,10 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
     RENDERER_ASTC_DECODE_METHOD("accelerate_astc"),
     RENDERER_ACCURACY("gpu_accuracy"),
     RENDERER_RESOLUTION("resolution_setup"),
+    RENDERER_FRAME_GEN_MULTIPLIER("frame_gen_multiplier"),
+    RENDERER_FRAME_GEN_TARGET_RATE("frame_gen_target_rate"),
+    RENDERER_FRAME_GEN_QUEUE_TARGET("frame_gen_queue_target"),
+    RENDERER_FRAME_GEN_FLOW_SCALE("frame_gen_flow_scale"),
     RENDERER_VSYNC("use_vsync"),
     RENDERER_SCALING_FILTER("scaling_filter"),
     RENDERER_ANTI_ALIASING("anti_aliasing"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/Settings.kt

@@ -11,6 +11,7 @@ object Settings {
         SECTION_ROOT(R.string.advanced_settings),
         SECTION_SYSTEM(R.string.preferences_system),
         SECTION_RENDERER(R.string.preferences_graphics),
+        SECTION_FRAME_GEN(R.string.frame_gen),
         SECTION_PERFORMANCE_STATS(R.string.stats_overlay_options),
         SECTION_INPUT_OVERLAY(R.string.input_overlay_options),
         SECTION_SOC_OVERLAY(R.string.soc_overlay_options),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -21,6 +21,7 @@ import org.yuzu.yuzu_emu.features.settings.model.LongSetting
 import org.yuzu.yuzu_emu.features.settings.model.ShortSetting
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
 import org.yuzu.yuzu_emu.network.NetDataValidators
+import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
 import org.yuzu.yuzu_emu.utils.NativeConfig
 
 /**
@@ -65,6 +66,19 @@ abstract class SettingsItem(
                 return NativeLibrary.isFirmwareAvailable()
             }
 
+            if (setting.key in frameGenKeys &&
+                !(LosslessScalingHelper.isInstalled() && LosslessScalingHelper.isSupportedByGpu())
+            ) {
+                return false
+            }
+
+            // A frame rate target moves the multiplier on its own
+            if (setting.key == IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key &&
+                frameGenTargetRate != 0
+            ) {
+                return false
+            }
+
             // Can't edit settings that aren't saveable in per-game config even if they are switchable
             if (NativeConfig.isPerGameConfigLoaded() && !setting.isSaveable) {
                 return false
@@ -88,7 +102,31 @@ abstract class SettingsItem(
     val clearable: Boolean
         get() = !setting.global && NativeConfig.isPerGameConfigLoaded()
 
+    private val frameGenTargetRate: Int
+        get() {
+            val key = IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key
+            val needsGlobal = if (NativeLibrary.isRunning() &&
+                !NativeConfig.isPerGameConfigLoaded()
+            ) {
+                !NativeConfig.usingGlobal(key)
+            } else {
+                NativeConfig.usingGlobal(key)
+            }
+            return IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.getInt(needsGlobal)
+        }
+
     companion object {
+        private val frameGenKeys = setOf(
+            BooleanSetting.RENDERER_FRAME_GEN.key,
+            IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key,
+            IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key,
+            IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET.key,
+            BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.key,
+            IntSetting.RENDERER_FRAME_GEN_FLOW_SCALE.key,
+            BooleanSetting.RENDERER_FRAME_GEN_FP16.key,
+            BooleanSetting.RENDERER_FRAME_GEN_DUMP_FLOW.key
+        )
+
         const val TYPE_HEADER = 0
         const val TYPE_SWITCH = 1
         const val TYPE_SINGLE_CHOICE = 2
@@ -614,6 +652,57 @@ abstract class SettingsItem(
                     descriptionId = R.string.frame_gen_description
                 )
             )
+            put(
+                SingleChoiceSetting(
+                    IntSetting.RENDERER_FRAME_GEN_MULTIPLIER,
+                    titleId = R.string.frame_gen_multiplier,
+                    descriptionId = R.string.frame_gen_multiplier_description,
+                    choicesId = R.array.frameGenMultiplierNames,
+                    valuesId = R.array.frameGenMultiplierValues
+                )
+            )
+            put(
+                SingleChoiceSetting(
+                    IntSetting.RENDERER_FRAME_GEN_TARGET_RATE,
+                    titleId = R.string.frame_gen_target_rate,
+                    descriptionId = R.string.frame_gen_target_rate_description,
+                    choicesId = R.array.frameGenTargetRateNames,
+                    valuesId = R.array.frameGenTargetRateValues
+                )
+            )
+            put(
+                SingleChoiceSetting(
+                    IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET,
+                    titleId = R.string.frame_gen_queue_target,
+                    descriptionId = R.string.frame_gen_queue_target_description,
+                    choicesId = R.array.frameGenQueueTargetNames,
+                    valuesId = R.array.frameGenQueueTargetValues
+                )
+            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO,
+                    titleId = R.string.frame_gen_flow_scale_auto,
+                    descriptionId = R.string.frame_gen_flow_scale_auto_description
+                )
+            )
+            put(
+                SliderSetting(
+                    IntSetting.RENDERER_FRAME_GEN_FLOW_SCALE,
+                    titleId = R.string.frame_gen_flow_scale,
+                    descriptionId = R.string.frame_gen_flow_scale_description,
+                    min = 25,
+                    max = 100,
+                    units = "%"
+                )
+            )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_FRAME_GEN_FP16,
+                    titleId = R.string.frame_gen_fp16,
+                    descriptionId = R.string.frame_gen_fp16_description
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.RENDERER_FRAME_GEN_DUMP_FLOW,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsDialogFragment.kt

@@ -382,7 +382,9 @@ class SettingsDialogFragment : DialogFragment(), DialogInterface.OnClickListener
                 }
                 scSetting.setSelectedValue(value)
 
-                if (scSetting.setting.key == IntSetting.RENDERER_SCALING_FILTER.key) {
+                if (scSetting.setting.key == IntSetting.RENDERER_SCALING_FILTER.key ||
+                    scSetting.setting.key == IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key
+                ) {
                     settingsViewModel.setShouldReloadSettingsList(true)
                 }
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragment.kt

@@ -33,7 +33,6 @@ import org.yuzu.yuzu_emu.features.input.NativeInput
 import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.features.settings.model.view.PathSetting
 import org.yuzu.yuzu_emu.fragments.MessageDialogFragment
-import org.yuzu.yuzu_emu.fragments.ProgressDialogFragment
 import org.yuzu.yuzu_emu.utils.PathUtil
 import org.yuzu.yuzu_emu.utils.ViewUtils.updateMargins
 import org.yuzu.yuzu_emu.utils.*
@@ -115,10 +114,6 @@ class SettingsFragment : Fragment() {
             viewLifecycleOwner,
             resetState = { settingsViewModel.setShouldReloadSettingsList(false) }
         ) { if (it) presenter.loadSettingsList() }
-        settingsViewModel.shouldShowLosslessInstaller.collect(
-            viewLifecycleOwner,
-            resetState = { settingsViewModel.setShouldShowLosslessInstaller(false) }
-        ) { if (it) losslessDllPickerLauncher.launch(arrayOf("*/*")) }
         settingsViewModel.adapterItemChanged.collect(
             viewLifecycleOwner,
             resetState = { settingsViewModel.setAdapterItemChanged(-1) }
@@ -272,33 +267,6 @@ private fun getPlayerIndex(): Int =
         directoryPickerLauncher.launch(null)
     }
 
-    private val losslessDllPickerLauncher = registerForActivityResult(
-        ActivityResultContracts.OpenDocument()
-    ) { uri ->
-        if (uri == null) {
-            return@registerForActivityResult
-        }
-
-        val resultStrings = resources.getStringArray(R.array.losslessDllResults)
-        ProgressDialogFragment.newInstance(
-            requireActivity(),
-            R.string.lossless_scaling_installing,
-            false
-        ) { _, _ ->
-            val result = LosslessScalingHelper.install(uri)
-            if (result == LosslessScalingHelper.RESULT_OK) {
-                getString(R.string.lossless_scaling_install_success)
-            } else {
-                MessageDialogFragment.newInstance(
-                    titleId = R.string.lossless_scaling_install_failed,
-                    descriptionString = resultStrings[result]
-                )
-            }
-        }.apply {
-            onDialogComplete = { settingsViewModel.setShouldReloadSettingsList(true) }
-        }.show(parentFragmentManager, ProgressDialogFragment.TAG)
-    }
-
     private val directoryPickerLauncher = registerForActivityResult(
         ActivityResultContracts.OpenDocumentTree()
     ) { uri ->

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -79,27 +79,6 @@ class SettingsFragmentPresenter(
 
     private fun addFrameGenSettings(sl: ArrayList<SettingsItem>) {
         sl.apply {
-            add(HeaderSetting(R.string.frame_gen))
-
-            val installed = LosslessScalingHelper.isInstalled()
-
-            add(
-                RunnableSetting(
-                    titleId = if (installed) {
-                        R.string.lossless_scaling_replace
-                    } else {
-                        R.string.lossless_scaling_install
-                    },
-                    descriptionId = if (installed) {
-                        R.string.lossless_scaling_replace_description
-                    } else {
-                        R.string.lossless_scaling_install_description
-                    },
-                    isRunnable = !NativeLibrary.isRunning(),
-                    iconId = R.drawable.ic_install
-                ) { settingsViewModel.setShouldShowLosslessInstaller(true) }
-            )
-
             if (!LosslessScalingHelper.isSupportedByGpu()) {
                 add(
                     RunnableSetting(
@@ -108,15 +87,28 @@ class SettingsFragmentPresenter(
                         isRunnable = false
                     ) {}
                 )
-                return@apply
-            }
-
-            if (!installed) {
-                return@apply
+            } else if (!LosslessScalingHelper.isInstalled()) {
+                add(
+                    RunnableSetting(
+                        titleId = R.string.lossless_scaling_missing,
+                        descriptionId = R.string.lossless_scaling_missing_description,
+                        isRunnable = false
+                    ) {}
+                )
             }
 
             add(BooleanSetting.RENDERER_FRAME_GEN.key)
-            add(BooleanSetting.RENDERER_FRAME_GEN_DUMP_FLOW.key)
+            add(IntSetting.RENDERER_FRAME_GEN_TARGET_RATE.key)
+            add(IntSetting.RENDERER_FRAME_GEN_MULTIPLIER.key)
+            add(IntSetting.RENDERER_FRAME_GEN_QUEUE_TARGET.key)
+            add(BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.key)
+            if (!BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.getBoolean(
+                    getNeedsGlobalForKey(BooleanSetting.RENDERER_FRAME_GEN_FLOW_SCALE_AUTO.key)
+                )
+            ) {
+                add(IntSetting.RENDERER_FRAME_GEN_FLOW_SCALE.key)
+            }
+            add(BooleanSetting.RENDERER_FRAME_GEN_FP16.key)
         }
     }
 
@@ -164,6 +156,7 @@ class SettingsFragmentPresenter(
             MenuTag.SECTION_ROOT -> addConfigSettings(sl)
             MenuTag.SECTION_SYSTEM -> addSystemSettings(sl)
             MenuTag.SECTION_RENDERER -> addGraphicsSettings(sl)
+            MenuTag.SECTION_FRAME_GEN -> addFrameGenSettings(sl)
             MenuTag.SECTION_PERFORMANCE_STATS -> addPerformanceOverlaySettings(sl)
             MenuTag.SECTION_SOC_OVERLAY -> addSocOverlaySettings(sl)
             MenuTag.SECTION_INPUT_OVERLAY -> addInputOverlaySettings(sl)
@@ -324,8 +317,6 @@ class SettingsFragmentPresenter(
             }
             add(IntSetting.RENDERER_ANTI_ALIASING.key)
 
-            addFrameGenSettings(this)
-
             add(HeaderSetting(R.string.advanced))
 
             add(IntSetting.RENDERER_ACCURACY.key)
@@ -348,7 +339,6 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key)
             add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
             add(BooleanSetting.EMULATE_BGR565.key)
-            add(BooleanSetting.RESCALE_HACK.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
             add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
@@ -1342,6 +1332,7 @@ class SettingsFragmentPresenter(
                 add(BooleanSetting.DUMP_GUEST_SHADERS.key)
                 add(BooleanSetting.GPU_LOG_SHADER_DUMPS.key)
                 add(BooleanSetting.DUMP_MACROS.key)
+                add(BooleanSetting.RENDERER_FRAME_GEN_DUMP_FLOW.key)
                 add(BooleanSetting.GPU_LOG_MEMORY_TRACKING.key)
                 add(BooleanSetting.GPU_LOG_DRIVER_DEBUG.key)
                 add(IntSetting.GPU_LOG_RING_BUFFER_SIZE.key)

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsSubscreenActivity.kt

@@ -29,6 +29,7 @@ enum class SettingsSubscreen {
     DRIVER_MANAGER,
     DRIVER_FETCHER,
     FREEDRENO_SETTINGS,
+    LOSSLESS_MANAGER,
     APPLET_LAUNCHER,
     INSTALLABLE,
     GAME_FOLDERS,
@@ -126,6 +127,7 @@ class SettingsSubscreenActivity : AppCompatActivity() {
             SettingsSubscreen.DRIVER_MANAGER -> R.id.driverManagerFragment
             SettingsSubscreen.DRIVER_FETCHER -> R.id.driverFetcherFragment
             SettingsSubscreen.FREEDRENO_SETTINGS -> R.id.freedrenoSettingsFragment
+            SettingsSubscreen.LOSSLESS_MANAGER -> R.id.losslessManagerFragment
             SettingsSubscreen.APPLET_LAUNCHER -> R.id.appletLauncherFragment
             SettingsSubscreen.INSTALLABLE -> R.id.installableFragment
             SettingsSubscreen.GAME_FOLDERS -> R.id.gameFoldersFragment

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsViewModel.kt

@@ -36,9 +36,6 @@ class SettingsViewModel : ViewModel() {
     val shouldReloadSettingsList: StateFlow<Boolean> get() = _shouldReloadSettingsList
     private val _shouldReloadSettingsList = MutableStateFlow(false)
 
-    val shouldShowLosslessInstaller: StateFlow<Boolean> get() = _shouldShowLosslessInstaller
-    private val _shouldShowLosslessInstaller = MutableStateFlow(false)
-
     val sliderProgress: StateFlow<Int> get() = _sliderProgress
     private val _sliderProgress = MutableStateFlow(-1)
 
@@ -88,10 +85,6 @@ class SettingsViewModel : ViewModel() {
         _shouldReloadSettingsList.value = value
     }
 
-    fun setShouldShowLosslessInstaller(value: Boolean) {
-        _shouldShowLosslessInstaller.value = value
-    }
-
     fun setSliderTextValue(value: Float, units: String) {
         _sliderProgress.value = value.toInt()
         _sliderTextValue.value = String.format(

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/GamePropertiesFragment.kt

@@ -369,6 +369,21 @@ class GamePropertiesFragment : Fragment() {
                     )
                 )
             }
+            add(
+                SubmenuProperty(
+                    R.string.frame_gen,
+                    R.string.frame_gen_per_game_description,
+                    R.drawable.ic_duck,
+                    action = {
+                        val action = HomeNavigationDirections.actionGlobalSettingsActivity(
+                            args.game,
+                            Settings.MenuTag.SECTION_FRAME_GEN
+                        )
+                        binding.root.findNavController().navigate(action)
+                    }
+                )
+            )
+
             if (GpuDriverHelper.isAdrenoGpu()) {
                 add(
                     SubmenuProperty(

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/HomeSettingsFragment.kt

@@ -13,7 +13,6 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.Toast
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.app.ActivityCompat
 import androidx.core.app.NotificationCompat
@@ -176,8 +175,14 @@ class HomeSettingsFragment : Fragment() {
                 HomeSetting(
                     R.string.lossless_scaling,
                     R.string.lossless_scaling_description,
-                    R.drawable.ic_frames,
-                    { onLosslessScalingClicked() },
+                    R.drawable.ic_duck,
+                    {
+                        val action = HomeNavigationDirections.actionGlobalSettingsSubscreenActivity(
+                            SettingsSubscreen.LOSSLESS_MANAGER,
+                            null
+                        )
+                        binding.root.findNavController().navigate(action)
+                    },
                     { true },
                     0,
                     0,
@@ -354,48 +359,6 @@ class HomeSettingsFragment : Fragment() {
         LosslessScalingHelper.refreshStatus()
     }
 
-    private fun onLosslessScalingClicked() {
-        if (!LosslessScalingHelper.isInstalled()) {
-            getLosslessDllLauncher.launch(arrayOf("*/*"))
-            return
-        }
-
-        MessageDialogFragment.newInstance(
-            requireActivity(),
-            titleId = R.string.lossless_scaling,
-            descriptionId = R.string.lossless_scaling_installed_description,
-            positiveButtonTitleId = R.string.lossless_scaling_replace,
-            positiveAction = { getLosslessDllLauncher.launch(arrayOf("*/*")) },
-            showNegativeButton = true,
-            negativeButtonTitleId = R.string.lossless_scaling_remove,
-            negativeAction = { LosslessScalingHelper.remove() }
-        ).show(parentFragmentManager, MessageDialogFragment.TAG)
-    }
-
-    private val getLosslessDllLauncher =
-        registerForActivityResult(ActivityResultContracts.OpenDocument()) { result ->
-            if (result == null) {
-                return@registerForActivityResult
-            }
-
-            val resultStrings = resources.getStringArray(R.array.losslessDllResults)
-            ProgressDialogFragment.newInstance(
-                requireActivity(),
-                R.string.lossless_scaling_installing,
-                false
-            ) { _, _ ->
-                val installResult = LosslessScalingHelper.install(result)
-                if (installResult == LosslessScalingHelper.RESULT_OK) {
-                    getString(R.string.lossless_scaling_install_success)
-                } else {
-                    MessageDialogFragment.newInstance(
-                        titleId = R.string.lossless_scaling_install_failed,
-                        descriptionString = resultStrings[installResult]
-                    )
-                }
-            }.show(parentFragmentManager, ProgressDialogFragment.TAG)
-        }
-
     override fun onDestroyView() {
         super.onDestroyView()
         _binding = null

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/LosslessManagerFragment.kt

@@ -0,0 +1,174 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.fragments
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.updatePadding
+import androidx.fragment.app.Fragment
+import androidx.recyclerview.widget.GridLayoutManager
+import com.google.android.material.transition.MaterialSharedAxis
+import org.yuzu.yuzu_emu.NativeLibrary
+import org.yuzu.yuzu_emu.R
+import org.yuzu.yuzu_emu.adapters.HomeSettingAdapter
+import org.yuzu.yuzu_emu.databinding.FragmentLosslessManagerBinding
+import org.yuzu.yuzu_emu.features.fetcher.SpacingItemDecoration
+import org.yuzu.yuzu_emu.model.HomeSetting
+import org.yuzu.yuzu_emu.utils.LosslessScalingHelper
+import org.yuzu.yuzu_emu.utils.ViewUtils.updateMargins
+import org.yuzu.yuzu_emu.utils.collect
+
+class LosslessManagerFragment : Fragment() {
+    private var _binding: FragmentLosslessManagerBinding? = null
+    private val binding get() = _binding!!
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enterTransition = MaterialSharedAxis(MaterialSharedAxis.X, true)
+        returnTransition = MaterialSharedAxis(MaterialSharedAxis.X, false)
+        reenterTransition = MaterialSharedAxis(MaterialSharedAxis.X, false)
+        exitTransition = MaterialSharedAxis(MaterialSharedAxis.X, true)
+    }
+
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        _binding = FragmentLosslessManagerBinding.inflate(inflater, container, false)
+        return binding.root
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+
+        binding.toolbarLossless.setNavigationOnClickListener {
+            requireActivity().onBackPressedDispatcher.onBackPressed()
+        }
+
+        binding.losslessOptionsList.apply {
+            layoutManager =
+                GridLayoutManager(requireContext(), resources.getInteger(R.integer.grid_columns))
+            addItemDecoration(
+                SpacingItemDecoration(resources.getDimensionPixelSize(R.dimen.spacing_small))
+            )
+        }
+
+        LosslessScalingHelper.statusText.collect(viewLifecycleOwner) { refreshOptions() }
+
+        setInsets()
+    }
+
+    private fun refreshOptions() {
+        binding.losslessOptionsList.adapter = HomeSettingAdapter(
+            requireActivity() as AppCompatActivity,
+            viewLifecycleOwner,
+            buildOptions()
+        )
+    }
+
+    private fun buildOptions(): List<HomeSetting> {
+        val installed = LosslessScalingHelper.isInstalled()
+        return listOf(
+            HomeSetting(
+                if (installed) R.string.lossless_scaling_replace else R.string.lossless_scaling_install,
+                if (installed) {
+                    R.string.lossless_scaling_replace_description
+                } else {
+                    R.string.lossless_scaling_install_description
+                },
+                R.drawable.ic_install,
+                { dllPickerLauncher.launch(arrayOf("*/*")) },
+                { !NativeLibrary.isRunning() },
+                R.string.lossless_scaling_locked,
+                R.string.lossless_scaling_locked_description,
+                LosslessScalingHelper.statusText
+            ),
+            HomeSetting(
+                R.string.lossless_scaling_remove,
+                R.string.lossless_scaling_remove_description,
+                R.drawable.ic_delete,
+                { confirmRemoval() },
+                { installed && !NativeLibrary.isRunning() },
+                if (installed) {
+                    R.string.lossless_scaling_locked
+                } else {
+                    R.string.lossless_scaling_remove_unavailable
+                },
+                if (installed) {
+                    R.string.lossless_scaling_locked_description
+                } else {
+                    R.string.lossless_scaling_remove_unavailable_description
+                }
+            )
+        )
+    }
+
+    private fun confirmRemoval() {
+        MessageDialogFragment.newInstance(
+            requireActivity(),
+            titleId = R.string.lossless_scaling_remove,
+            descriptionId = R.string.lossless_scaling_remove_confirmation,
+            positiveButtonTitleId = R.string.lossless_scaling_remove,
+            positiveAction = { LosslessScalingHelper.remove() },
+            showNegativeButton = true,
+            negativeAction = {}
+        ).show(parentFragmentManager, MessageDialogFragment.TAG)
+    }
+
+    private val dllPickerLauncher =
+        registerForActivityResult(ActivityResultContracts.OpenDocument()) { result ->
+            if (result == null) {
+                return@registerForActivityResult
+            }
+
+            val resultStrings = resources.getStringArray(R.array.losslessDllResults)
+            ProgressDialogFragment.newInstance(
+                requireActivity(),
+                R.string.lossless_scaling_installing,
+                false
+            ) { _, _ ->
+                val installResult = LosslessScalingHelper.install(result)
+                if (installResult == LosslessScalingHelper.RESULT_OK) {
+                    getString(R.string.lossless_scaling_install_success)
+                } else {
+                    MessageDialogFragment.newInstance(
+                        titleId = R.string.lossless_scaling_install_failed,
+                        descriptionString = resultStrings[installResult]
+                    )
+                }
+            }.show(parentFragmentManager, ProgressDialogFragment.TAG)
+        }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        _binding = null
+    }
+
+    private fun setInsets() =
+        ViewCompat.setOnApplyWindowInsetsListener(binding.root) { _, windowInsets ->
+            val barInsets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars())
+            val cutoutInsets = windowInsets.getInsets(WindowInsetsCompat.Type.displayCutout())
+
+            binding.appbarLossless.updateMargins(
+                left = barInsets.left + cutoutInsets.left,
+                right = barInsets.right + cutoutInsets.right
+            )
+
+            binding.scrollViewLossless.updatePadding(bottom = barInsets.bottom)
+
+            binding.losslessOptionsList.updatePadding(
+                left = barInsets.left + cutoutInsets.left,
+                right = barInsets.right + cutoutInsets.right
+            )
+
+            windowInsets
+        }
+}

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/SetupFragment.kt

@@ -205,7 +205,7 @@ class SetupFragment : Fragment() {
                         )
                         add(
                             PageButton(
-                                R.drawable.ic_frames,
+                                R.drawable.ic_duck,
                                 R.string.lossless_scaling,
                                 R.string.lossless_scaling_setup_description,
                                 {

src/android/app/src/main/jni/android_config.cpp

@@ -33,8 +33,8 @@ void AndroidConfig::SaveAllValues() {
 }
 
 void AndroidConfig::ReadAndroidValues() {
+    ReadAndroidUIValues();
     if (global) {
-        ReadAndroidUIValues();
         ReadUIValues();
         BeginGroup(Settings::TranslateCategory(Settings::Category::DataStorage));
         Settings::values.ext_content_from_game_dirs = ReadBooleanSetting(
@@ -223,8 +223,8 @@ void AndroidConfig::ReadAndroidControlValues() {
 }
 
 void AndroidConfig::SaveAndroidValues() {
+    SaveAndroidUIValues();
     if (global) {
-        SaveAndroidUIValues();
         SaveUIValues();
         SaveOverlayValues();
     }

src/android/app/src/main/jni/android_settings.h

@@ -147,7 +147,7 @@ namespace AndroidSettings {
                                                       &show_performance_overlay};
 
 
-        Settings::Setting<s32> pipeline_worker_count{linkage, 4, "pipeline_worker_count",
+        Settings::SwitchableSetting<s32> pipeline_worker_count{linkage, 2, "pipeline_worker_count",
                                  Settings::Category::Android,
                                  Settings::Specialization::Default,
                                  true,

src/android/app/src/main/jni/emu_window/emu_window.cpp

@@ -124,9 +124,18 @@ float EmuWindow_Android::GetFrameTimeVerifiedHint() const {
     return QuantizeFrameRateHint(verified_rate);
 }
 
+float EmuWindow_Android::GetPresentedFrameMultiplier() {
+    if (!Settings::values.frame_gen.GetValue()) {
+        return 1.0f;
+    }
+    return static_cast<float>(std::clamp<u32>(Settings::values.frame_gen_multiplier.GetValue(), 2, 4));
+}
+
 float EmuWindow_Android::GetFrameRateHint() const {
-    const float observed_rate = std::clamp(m_smoothed_present_rate, 0.0f, 240.0f);
-    const float frame_time_verified_hint = GetFrameTimeVerifiedHint();
+    const float presented_multiplier = GetPresentedFrameMultiplier();
+    const float observed_rate =
+        std::clamp(m_smoothed_present_rate * presented_multiplier, 0.0f, 240.0f);
+    const float frame_time_verified_hint = GetFrameTimeVerifiedHint() * presented_multiplier;
 
     if (m_last_frame_rate_hint > 0.0f && observed_rate > 0.0f) {
         const float tolerance = std::max(m_last_frame_rate_hint * 0.12f, 4.0f);
@@ -150,9 +159,9 @@ float EmuWindow_Android::GetFrameRateHint() const {
         return frame_time_verified_hint;
     }
 
-    constexpr float NominalFrameRate = 60.0f;
+    const float nominal_rate = 60.0f * presented_multiplier;
     if (!Settings::values.use_speed_limit.GetValue()) {
-        return NominalFrameRate;
+        return QuantizeFrameRateHint(nominal_rate);
     }
 
     const u16 speed_limit = Settings::SpeedLimit();
@@ -161,7 +170,7 @@ float EmuWindow_Android::GetFrameRateHint() const {
     }
 
     const float speed_limited_rate =
-        NominalFrameRate * (static_cast<float>(std::min<u16>(speed_limit, 100)) / 100.0f);
+        nominal_rate * (static_cast<float>(std::min<u16>(speed_limit, 100)) / 100.0f);
     return QuantizeFrameRateHint(speed_limited_rate);
 }
 

src/android/app/src/main/jni/emu_window/emu_window.h

@@ -61,6 +61,7 @@ private:
     void UpdateObservedFrameRate();
     [[nodiscard]] float GetFrameRateHint() const;
     [[nodiscard]] float GetFrameTimeVerifiedHint() const;
+    [[nodiscard]] static float GetPresentedFrameMultiplier();
     [[nodiscard]] static float QuantizeFrameRateHint(float frame_rate);
 
     float m_window_width{};

src/android/app/src/main/res/drawable/ic_duck.xml

@@ -0,0 +1,19 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:pathData="M11,10.6a8,5.2 0 1,0 0,10.4a8,5.2 0 1,0 0,-10.4z" />
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:pathData="M4.6,12.6L0.8,10.2L3.2,15.5z" />
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:fillType="evenOdd"
+        android:pathData="M15.3,3.5a4,4 0 1,0 0,8a4,4 0 1,0 0,-8zM16.6,4.9a1,1 0 1,0 0,2a1,1 0 1,0 0,-2z" />
+    <path
+        android:fillColor="?attr/colorControlNormal"
+        android:pathData="M18.6,6.5L23.2,7.8L18.6,9.3z" />
+</vector>

src/android/app/src/main/res/layout/fragment_lossless_manager.xml

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="?attr/colorSurface">
+
+    <com.google.android.material.appbar.AppBarLayout
+        android:id="@+id/appbar_lossless"
+        style="@style/Widget.Eden.TransparentTopAppBarLayout"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:fitsSystemWindows="true"
+        android:touchscreenBlocksFocus="false"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent">
+
+        <com.google.android.material.appbar.MaterialToolbar
+            android:id="@+id/toolbar_lossless"
+            style="@style/Widget.Eden.TransparentTopToolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            android:touchscreenBlocksFocus="false"
+            app:navigationIcon="@drawable/ic_back"
+            app:title="@string/lossless_scaling" />
+
+    </com.google.android.material.appbar.AppBarLayout>
+
+    <androidx.core.widget.NestedScrollView
+        android:id="@+id/scroll_view_lossless"
+        android:layout_width="0dp"
+        android:layout_height="0dp"
+        android:background="@android:color/transparent"
+        android:clipToPadding="false"
+        android:defaultFocusHighlightEnabled="false"
+        android:fadeScrollbars="false"
+        android:scrollbars="vertical"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/appbar_lossless">
+
+        <androidx.appcompat.widget.LinearLayoutCompat
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical"
+            android:paddingHorizontal="16dp"
+            android:paddingTop="16dp">
+
+            <androidx.recyclerview.widget.RecyclerView
+                android:id="@+id/lossless_options_list"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:clipToPadding="false"
+                android:nestedScrollingEnabled="false" />
+
+        </androidx.appcompat.widget.LinearLayoutCompat>
+
+    </androidx.core.widget.NestedScrollView>
+
+</androidx.constraintlayout.widget.ConstraintLayout>

src/android/app/src/main/res/navigation/settings_subscreen_navigation.xml

@@ -47,6 +47,12 @@
             android:defaultValue="@null" />
     </fragment>
 
+    <fragment
+        android:id="@+id/losslessManagerFragment"
+        android:name="org.yuzu.yuzu_emu.fragments.LosslessManagerFragment"
+        android:label="@string/lossless_scaling"
+        tools:layout="@layout/fragment_lossless_manager" />
+
     <fragment
         android:id="@+id/appletLauncherFragment"
         android:name="org.yuzu.yuzu_emu.fragments.AppletLauncherFragment"

src/android/app/src/main/res/values/arrays.xml

@@ -162,6 +162,48 @@
         <item>@string/resolution_four</item>
     </string-array>
 
+    <string-array name="frameGenMultiplierNames">
+        <item>@string/frame_gen_multiplier_2x</item>
+        <item>@string/frame_gen_multiplier_3x</item>
+        <item>@string/frame_gen_multiplier_4x</item>
+    </string-array>
+
+    <integer-array name="frameGenMultiplierValues">
+        <item>2</item>
+        <item>3</item>
+        <item>4</item>
+    </integer-array>
+
+    <string-array name="frameGenTargetRateNames">
+        <item>@string/frame_gen_target_rate_off</item>
+        <item>@string/frame_gen_target_rate_60</item>
+        <item>@string/frame_gen_target_rate_90</item>
+        <item>@string/frame_gen_target_rate_120</item>
+        <item>@string/frame_gen_target_rate_144</item>
+        <item>@string/frame_gen_target_rate_165</item>
+    </string-array>
+
+    <integer-array name="frameGenTargetRateValues">
+        <item>0</item>
+        <item>60</item>
+        <item>90</item>
+        <item>120</item>
+        <item>144</item>
+        <item>165</item>
+    </integer-array>
+
+    <string-array name="frameGenQueueTargetNames">
+        <item>@string/frame_gen_queue_target_0</item>
+        <item>@string/frame_gen_queue_target_1</item>
+        <item>@string/frame_gen_queue_target_2</item>
+    </string-array>
+
+    <integer-array name="frameGenQueueTargetValues">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+    </integer-array>
+
     <string-array name="rendererVSyncNames">
         <item>@string/renderer_vsync_immediate</item>
         <item>@string/renderer_vsync_mailbox</item>

src/android/app/src/main/res/values/strings.xml

@@ -299,14 +299,39 @@
     <string name="gpu_driver_manager">GPU driver manager</string>
     <string name="install_gpu_driver_description">Install alternative drivers for potentially better performance or accuracy</string>
     <string name="frame_gen">Frame generation</string>
-    <string name="frame_gen_description">Insert an interpolated frame between every pair of real frames using Lossless Scaling. Adds about one frame of input latency.</string>
-    <string name="frame_gen_dump_flow">Dump flow pyramid</string>
-    <string name="frame_gen_dump_flow_description">Write the optical flow mip levels to the lossless/debug folder once, for troubleshooting</string>
+    <string name="frame_gen_per_game_description">Configure frame generation for this game</string>
+    <string name="frame_gen_description">Insert interpolated frames between rendered ones using Lossless Scaling. Forces FIFO presentation while enabled.</string>
+    <string name="frame_gen_multiplier">Frame multiplier</string>
+    <string name="frame_gen_multiplier_description">How many frames to display for each rendered frame. Higher values cost proportionally more GPU time. Asking for more than your display can present will slow emulation down.</string>
+    <string name="frame_gen_multiplier_2x">2x</string>
+    <string name="frame_gen_multiplier_3x">3x</string>
+    <string name="frame_gen_multiplier_4x">4x</string>
+    <string name="frame_gen_target_rate">Target frame rate</string>
+    <string name="frame_gen_target_rate_description">Pick the rate your display can actually show. The multiplier then rises or falls on its own to hold it, and rolls back any step that makes the game itself run slower.</string>
+    <string name="frame_gen_target_rate_off">Use a fixed multiplier</string>
+    <string name="frame_gen_target_rate_60">60 FPS</string>
+    <string name="frame_gen_target_rate_90">90 FPS</string>
+    <string name="frame_gen_target_rate_120">120 FPS</string>
+    <string name="frame_gen_target_rate_144">144 FPS</string>
+    <string name="frame_gen_target_rate_165">165 FPS</string>
+    <string name="frame_gen_queue_target">Frame queue target</string>
+    <string name="frame_gen_queue_target_description">How many finished frames may wait ahead of the display. Larger queues absorb GPU spikes at the cost of input latency.</string>
+    <string name="frame_gen_queue_target_0">Lowest latency (Unbuffered)</string>
+    <string name="frame_gen_queue_target_1">Balanced (1 frame)</string>
+    <string name="frame_gen_queue_target_2">Smoothest (2 frames)</string>
+    <string name="frame_gen_flow_scale_auto">Match motion estimation to the game</string>
+    <string name="frame_gen_flow_scale_auto_description">Estimate motion at the resolution the game actually renders instead of the upscaled output. Costs nothing in accuracy, since upscaling adds no motion detail.</string>
+    <string name="frame_gen_flow_scale">Motion estimation resolution</string>
+    <string name="frame_gen_flow_scale_description">Resolution of the optical flow pass, as a fraction of the output. Lowering it is the cheapest way to reclaim performance.</string>
+    <string name="frame_gen_fp16">Half precision shaders</string>
+    <string name="frame_gen_fp16_description">Use the 16-bit shader variant. Falls back automatically if the driver or the file lacks it.</string>
+    <string name="frame_gen_dump_flow">Dump generated frame</string>
+    <string name="frame_gen_dump_flow_description">Write the optical flow mip levels and the interpolated frame to the lossless/debug folder once, for troubleshooting</string>
     <string name="frame_gen_unsupported">Frame generation unavailable</string>
     <string name="frame_gen_unsupported_description">This GPU driver does not support the Vulkan memory model, which the Lossless Scaling shaders require.</string>
     <string name="lossless_scaling_setup_description">Optional. Provide your own Lossless.dll to enable frame generation later</string>
     <string name="lossless_scaling_install">Install Lossless.dll</string>
-    <string name="lossless_scaling_install_description">Frame generation needs your own copy of Lossless.dll from Lossless Scaling</string>
+    <string name="lossless_scaling_install_description">Frame generation needs your own legal copy of Lossless.dll from Lossless Scaling</string>
     <string name="lossless_scaling_replace_description">Select a different copy of Lossless.dll</string>
     <string name="frame_generation_support">Frame generation</string>
     <string name="frame_generation_supported">Supported</string>
@@ -315,9 +340,16 @@
     <string name="lossless_scaling_description">Provide your own copy of Lossless.dll to enable frame generation</string>
     <string name="lossless_scaling_installed">Installed</string>
     <string name="lossless_scaling_not_installed">Not installed</string>
-    <string name="lossless_scaling_installed_description">Lossless.dll is installed and contains every shader frame generation needs.</string>
     <string name="lossless_scaling_replace">Replace</string>
     <string name="lossless_scaling_remove">Remove</string>
+    <string name="lossless_scaling_remove_description">Delete the installed Lossless.dll and its prepared shaders</string>
+    <string name="lossless_scaling_remove_confirmation">Frame generation will stop working until you install Lossless.dll again. Your original file is not affected.</string>
+    <string name="lossless_scaling_missing">Lossless.dll not installed</string>
+    <string name="lossless_scaling_missing_description">Install it from Settings › Lossless Scaling to use frame generation.</string>
+    <string name="lossless_scaling_locked">Close the game first</string>
+    <string name="lossless_scaling_locked_description">Lossless.dll cannot be changed while a game is running.</string>
+    <string name="lossless_scaling_remove_unavailable">Nothing to remove</string>
+    <string name="lossless_scaling_remove_unavailable_description">Lossless.dll is not installed yet.</string>
     <string name="lossless_scaling_installing">Preparing frame generation shaders…</string>
     <string name="lossless_scaling_install_success">Lossless.dll installed successfully</string>
     <string name="lossless_scaling_install_failed">Could not install Lossless.dll</string>

src/common/settings.cpp

@@ -380,6 +380,28 @@ void UpdateRescalingInfo() {
     TranslateResolutionInfo(setup, info);
 }
 
+u32 FrameGenMultiplier() {
+    return std::clamp(values.frame_gen_multiplier.GetValue(), MIN_FRAME_GEN_MULTIPLIER,
+                      MAX_FRAME_GEN_MULTIPLIER);
+}
+
+size_t FrameGenGenerations() {
+    if (!values.frame_gen.GetValue()) {
+        return 0;
+    }
+    return FrameGenMultiplier() - 1;
+}
+
+size_t FrameGenMaxGenerations() {
+    if (!values.frame_gen.GetValue()) {
+        return 0;
+    }
+    if (values.frame_gen_target_rate.GetValue() != 0) {
+        return MAX_FRAME_GEN_MULTIPLIER - 1;
+    }
+    return FrameGenMultiplier() - 1;
+}
+
 void RestoreGlobalState(bool is_powered_on) {
     // If a game is running, DO NOT restore the global settings state
     if (is_powered_on) {

src/common/settings.h

@@ -352,7 +352,7 @@ struct Values {
                                                   true};
 
     SwitchableSetting<ScalingFilter> scaling_filter{linkage,
-                                                    ScalingFilter::Bilinear,
+                                                    ScalingFilter::NearestNeighbor,
                                                     "scaling_filter",
                                                     Category::Renderer,
                                                     Specialization::Default,
@@ -389,7 +389,65 @@ struct Values {
                                                   true};
 
     SwitchableSetting<bool> frame_gen{linkage, false, "frame_gen", Category::Renderer,
-                                      Specialization::Default, true, true};
+                                      Specialization::Default, true, false};
+
+    SwitchableSetting<u32, true> frame_gen_multiplier{linkage,
+                                                      2,
+                                                      2,
+                                                      4,
+                                                      "frame_gen_multiplier",
+                                                      Category::Renderer,
+                                                      Specialization::Countable,
+                                                      true,
+                                                      false,
+                                                      &frame_gen};
+
+    SwitchableSetting<u32, true> frame_gen_target_rate{linkage,
+                                                       0,
+                                                       0,
+                                                       240,
+                                                       "frame_gen_target_rate",
+                                                       Category::Renderer,
+                                                       Specialization::Countable,
+                                                       true,
+                                                       true,
+                                                       &frame_gen};
+
+    SwitchableSetting<bool> frame_gen_flow_scale_auto{linkage,
+                                                      true,
+                                                      "frame_gen_flow_scale_auto",
+                                                      Category::Renderer,
+                                                      Specialization::Default,
+                                                      true,
+                                                      false,
+                                                      &frame_gen};
+
+    SwitchableSetting<u32, true> frame_gen_flow_scale{linkage,
+                                                      75,
+                                                      25,
+                                                      100,
+                                                      "frame_gen_flow_scale",
+                                                      Category::Renderer,
+                                                      Specialization::Countable |
+                                                          Specialization::Percentage,
+                                                      true,
+                                                      true,
+                                                      &frame_gen};
+
+    SwitchableSetting<u32, true> frame_gen_queue_target{linkage,
+                                                        1,
+                                                        0,
+                                                        2,
+                                                        "frame_gen_queue_target",
+                                                        Category::Renderer,
+                                                        Specialization::Countable,
+                                                        true,
+                                                        false,
+                                                        &frame_gen};
+
+    SwitchableSetting<bool> frame_gen_fp16{linkage,      true,  "frame_gen_fp16", Category::Renderer,
+                                           Specialization::Default, true, false, &frame_gen};
+
     SwitchableSetting<bool> frame_gen_dump_flow{linkage, false, "frame_gen_dump_flow",
                                                 Category::Renderer};
 
@@ -574,13 +632,8 @@ struct Values {
     SwitchableSetting<bool> emulate_bgr565{linkage, false, "emulate_bgr565",
                                             Category::RendererHacks};
 
-    SwitchableSetting<bool> rescale_hack{linkage,
-#ifdef __ANDROID__
-        true,
-#else
-        false,
-#endif
-        "rescale_hack", Category::RendererHacks};
+    SwitchableSetting<bool> rescale_hack{linkage, false, "rescale_hack",
+                                         Category::RendererHacks};
     SwitchableSetting<bool> enable_gpu_buffer_readback{linkage,
                                                        false,
                                                        "enable_gpu_buffer_readback",
@@ -880,10 +933,20 @@ struct Values {
 
     // Per-game overrides
     bool use_squashed_iterated_blend;
+
 };
 
 extern Values values;
 
+constexpr u32 MIN_FRAME_GEN_MULTIPLIER = 2;
+constexpr u32 MAX_FRAME_GEN_MULTIPLIER = 4;
+
+[[nodiscard]] u32 FrameGenMultiplier();
+
+[[nodiscard]] size_t FrameGenGenerations();
+
+[[nodiscard]] size_t FrameGenMaxGenerations();
+
 bool getDebugKnobAt(u8 i);
 
 void UpdateGPUAccuracy();

src/video_core/CMakeLists.txt

@@ -127,6 +127,22 @@ add_library(video_core STATIC
     renderer_vulkan/present/filters.h
     renderer_vulkan/present/frame_gen.cpp
     renderer_vulkan/present/frame_gen.h
+    renderer_vulkan/present/frame_gen_pacer.cpp
+    renderer_vulkan/present/frame_gen_pacer.h
+    renderer_vulkan/present/lsfg_alpha.cpp
+    renderer_vulkan/present/lsfg_alpha.h
+    renderer_vulkan/present/lsfg_beta.cpp
+    renderer_vulkan/present/lsfg_beta.h
+    renderer_vulkan/present/lsfg_chain.cpp
+    renderer_vulkan/present/lsfg_chain.h
+    renderer_vulkan/present/lsfg_common.cpp
+    renderer_vulkan/present/lsfg_common.h
+    renderer_vulkan/present/lsfg_delta.cpp
+    renderer_vulkan/present/lsfg_delta.h
+    renderer_vulkan/present/lsfg_gamma.cpp
+    renderer_vulkan/present/lsfg_gamma.h
+    renderer_vulkan/present/lsfg_generate.cpp
+    renderer_vulkan/present/lsfg_generate.h
     renderer_vulkan/present/lsfg_mipmaps.cpp
     renderer_vulkan/present/lsfg_mipmaps.h
     renderer_vulkan/present/lsfg_shaders.cpp

src/video_core/frame_gen/lossless_dll.cpp

@@ -45,7 +45,7 @@ constexpr u32 PERFORMANCE_SHADER_ID_FIRST = 280;
 constexpr u32 PERFORMANCE_SHADER_ID_LAST = 302;
 
 constexpr u32 CACHE_MAGIC = 0x4746534C;
-constexpr u32 CACHE_VERSION = 1;
+constexpr u32 CACHE_VERSION = 2;
 
 struct CacheHeader {
     u32 magic;
@@ -53,6 +53,7 @@ struct CacheHeader {
     u64 source_size;
     u64 source_hash;
     u32 module_count;
+    u32 variant;
 };
 
 struct Section {
@@ -276,14 +277,54 @@ template <typename Map>
     return std::ranges::all_of(ids, [&](u32 id) { return resources.contains(id); });
 }
 
+[[nodiscard]] u32 VariantOffset(ShaderVariant variant) {
+    switch (variant) {
+    case ShaderVariant::NativeFp16:
+        return PerformanceShader::NATIVE_FP16_OFFSET;
+    case ShaderVariant::NativeFp32:
+        return PerformanceShader::NATIVE_FP32_OFFSET;
+    default:
+        return 0;
+    }
+}
+
+template <typename Map>
+[[nodiscard]] bool HasNativeVariant(const Map& resources, ShaderVariant variant) {
+    const u32 offset = VariantOffset(variant);
+    return std::ranges::all_of(PerformanceShaderIds(), [&](u32 id) {
+        const auto hit = resources.find(id + offset);
+        return hit != resources.end() && IsSpirvModule(hit->second);
+    });
+}
+
+[[nodiscard]] ShaderVariant SelectVariant(const ResourceSpans& resources, bool prefer_fp16) {
+    if (prefer_fp16 && HasNativeVariant(resources, ShaderVariant::NativeFp16)) {
+        return ShaderVariant::NativeFp16;
+    }
+    if (HasNativeVariant(resources, ShaderVariant::NativeFp32)) {
+        return ShaderVariant::NativeFp32;
+    }
+    return ShaderVariant::TranslatedDxbc;
+}
+
 [[nodiscard]] LosslessStatus TranslateAll(const ResourceSpans& resources,
-                                          ShaderModules& out_modules) {
+                                          ShaderModules& out_modules,
+                                          ShaderVariant variant) {
+    const u32 offset = VariantOffset(variant);
     out_modules.clear();
     for (const u32 id : PerformanceShaderIds()) {
-        const auto hit = resources.find(id);
+        const auto hit = resources.find(id + offset);
         if (hit == resources.end()) {
             return LosslessStatus::MissingShaders;
         }
+        if (variant != ShaderVariant::TranslatedDxbc) {
+            std::vector<u32> adopted = AdoptSpirvModule(hit->second);
+            if (adopted.empty()) {
+                return LosslessStatus::TranslationFailed;
+            }
+            out_modules.emplace(id, std::move(adopted));
+            continue;
+        }
 
         std::vector<u32> words = TranslateComputeShader(hit->second);
         if (words.empty()) {
@@ -313,7 +354,7 @@ template <typename Map>
 }
 
 [[nodiscard]] bool ReadShaderCache(const std::filesystem::path& path, u64 source_size,
-                                   u64 source_hash, ShaderModules& out_modules) {
+                                   u64 source_hash, u32 variant, ShaderModules& out_modules) {
     if (!Common::FS::Exists(path)) {
         return false;
     }
@@ -325,7 +366,8 @@ template <typename Map>
         return false;
     }
     if (header.magic != CACHE_MAGIC || header.version != CACHE_VERSION ||
-        header.source_size != source_size || header.source_hash != source_hash) {
+        header.source_size != source_size || header.source_hash != source_hash ||
+        header.variant != variant) {
         return false;
     }
 
@@ -452,7 +494,21 @@ LosslessStatus GetInstalledLosslessStatus() {
     return ValidateLosslessDll(GetLosslessDllPath());
 }
 
-LosslessStatus LoadShaderModules(ShaderModules& out_modules) {
+ShaderVariant GetAvailableVariant(bool prefer_fp16) {
+    std::vector<u8> image;
+    if (ReadImageFile(GetLosslessDllPath(), image) != LosslessStatus::Ok) {
+        return ShaderVariant::TranslatedDxbc;
+    }
+
+    ResourceSpans spans;
+    if (ParseShaderSpans(image, spans) != LosslessStatus::Ok) {
+        return ShaderVariant::TranslatedDxbc;
+    }
+
+    return SelectVariant(spans, prefer_fp16);
+}
+
+LosslessStatus LoadShaderModules(ShaderModules& out_modules, bool prefer_fp16) {
     std::vector<u8> image;
     const LosslessStatus read_status = ReadImageFile(GetLosslessDllPath(), image);
     if (read_status != LosslessStatus::Ok) {
@@ -464,17 +520,20 @@ LosslessStatus LoadShaderModules(ShaderModules& out_modules) {
         Common::CityHash64(reinterpret_cast<const char*>(image.data()), image.size());
     const std::filesystem::path cache_path = GetShaderCachePath();
 
-    if (ReadShaderCache(cache_path, source_size, source_hash, out_modules)) {
-        return LosslessStatus::Ok;
-    }
-
     ResourceSpans spans;
     const LosslessStatus parse_status = ParseShaderSpans(image, spans);
     if (parse_status != LosslessStatus::Ok) {
         return parse_status;
     }
 
-    const LosslessStatus translate_status = TranslateAll(spans, out_modules);
+    const ShaderVariant variant = SelectVariant(spans, prefer_fp16);
+
+    if (ReadShaderCache(cache_path, source_size, source_hash, static_cast<u32>(variant),
+                        out_modules)) {
+        return LosslessStatus::Ok;
+    }
+
+    const LosslessStatus translate_status = TranslateAll(spans, out_modules, variant);
     if (translate_status != LosslessStatus::Ok) {
         return translate_status;
     }
@@ -485,6 +544,7 @@ LosslessStatus LoadShaderModules(ShaderModules& out_modules) {
         .source_size = source_size,
         .source_hash = source_hash,
         .module_count = static_cast<u32>(out_modules.size()),
+        .variant = static_cast<u32>(variant),
     };
     if (!WriteShaderCache(cache_path, header, out_modules)) {
         void(Common::FS::RemoveFile(cache_path));

src/video_core/frame_gen/lossless_dll.h

@@ -1,6 +1,9 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 #pragma once
 
 #include <array>
@@ -25,6 +28,12 @@ enum class LosslessStatus : u32 {
 using ShaderResources = std::map<u32, std::vector<u8>>;
 using ShaderModules = std::map<u32, std::vector<u32>>;
 
+enum class ShaderVariant : u32 {
+    TranslatedDxbc,
+    NativeFp32,
+    NativeFp16,
+};
+
 namespace PerformanceShader {
 constexpr u32 MIPMAPS = 255;
 constexpr u32 GENERATE = 256;
@@ -32,6 +41,9 @@ constexpr std::array<u32, 4> ALPHA{290, 291, 292, 293};
 constexpr std::array<u32, 5> BETA{298, 299, 300, 301, 302};
 constexpr std::array<u32, 5> GAMMA{280, 282, 283, 284, 285};
 constexpr std::array<u32, 10> DELTA{280, 286, 287, 288, 289, 281, 294, 295, 296, 297};
+
+constexpr u32 NATIVE_FP16_OFFSET = 49;
+constexpr u32 NATIVE_FP32_OFFSET = 98;
 } // namespace PerformanceShader
 
 [[nodiscard]] std::filesystem::path GetLosslessDllPath();
@@ -47,7 +59,10 @@ constexpr std::array<u32, 10> DELTA{280, 286, 287, 288, 289, 281, 294, 295, 296,
 
 [[nodiscard]] LosslessStatus BuildShaderCache();
 
-[[nodiscard]] LosslessStatus LoadShaderModules(ShaderModules& out_modules);
+[[nodiscard]] ShaderVariant GetAvailableVariant(bool prefer_fp16);
+
+[[nodiscard]] LosslessStatus LoadShaderModules(ShaderModules& out_modules,
+                                              bool prefer_fp16 = false);
 
 bool RemoveInstalledLosslessDll();
 

src/video_core/frame_gen/lsfg_translate.cpp

@@ -1,6 +1,11 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include <algorithm>
+#include <cstring>
+#include <map>
+#include <tuple>
+
 #include <dxbc_modinfo.h>
 #include <dxbc_module.h>
 #include <dxbc_reader.h>
@@ -13,6 +18,7 @@ namespace VideoCore::FrameGen {
 namespace {
 
 constexpr u32 DECORATION_LITERAL_WORD = 3;
+constexpr size_t SPIRV_HEADER_WORDS = 5;
 
 void RenumberBindings(dxvk::SpirvCodeBuffer& code) {
     std::vector<u32> literal_offsets;
@@ -31,8 +37,73 @@ void RenumberBindings(dxvk::SpirvCodeBuffer& code) {
     }
 }
 
+void RenumberBindingsInOrder(std::vector<u32>& words) {
+    struct Slot {
+        u32 set;
+        u32 binding;
+        size_t literal_offset;
+    };
+
+    std::map<u32, u32> sets;
+    std::vector<Slot> slots;
+
+    size_t offset = SPIRV_HEADER_WORDS;
+    while (offset + 1 <= words.size()) {
+        const u32 length = words[offset] >> spv::WordCountShift;
+        const u32 opcode = words[offset] & spv::OpCodeMask;
+        if (length == 0 || offset + length > words.size()) {
+            return;
+        }
+        if (opcode == spv::OpFunction) {
+            break;
+        }
+        if (opcode == spv::OpDecorate && length >= 4) {
+            if (words[offset + 2] == spv::DecorationDescriptorSet) {
+                sets[words[offset + 1]] = words[offset + 3];
+            } else if (words[offset + 2] == spv::DecorationBinding) {
+                slots.push_back(Slot{0, words[offset + 3], offset + DECORATION_LITERAL_WORD});
+            }
+        }
+        offset += length;
+    }
+
+    for (Slot& slot : slots) {
+        const auto hit = sets.find(words[slot.literal_offset - 2]);
+        slot.set = hit == sets.end() ? 0 : hit->second;
+    }
+
+    std::ranges::stable_sort(slots, [](const Slot& lhs, const Slot& rhs) {
+        return std::tie(lhs.set, lhs.binding) < std::tie(rhs.set, rhs.binding);
+    });
+
+    for (size_t i = 0; i < slots.size(); ++i) {
+        words[slots[i].literal_offset] = static_cast<u32>(i);
+    }
+}
+
 } // Anonymous namespace
 
+bool IsSpirvModule(std::span<const u8> blob) {
+    if (blob.size() < SPIRV_HEADER_WORDS * sizeof(u32) || blob.size() % sizeof(u32) != 0) {
+        return false;
+    }
+    u32 magic{};
+    std::memcpy(&magic, blob.data(), sizeof(magic));
+    return magic == spv::MagicNumber;
+}
+
+std::vector<u32> AdoptSpirvModule(std::span<const u8> blob) {
+    if (!IsSpirvModule(blob)) {
+        return {};
+    }
+
+    std::vector<u32> words(blob.size() / sizeof(u32));
+    std::memcpy(words.data(), blob.data(), blob.size());
+
+    RenumberBindingsInOrder(words);
+    return words;
+}
+
 std::vector<u32> TranslateComputeShader(std::span<const u8> dxbc) {
     if (dxbc.empty()) {
         return {};

src/video_core/frame_gen/lsfg_translate.h

@@ -10,6 +10,10 @@
 
 namespace VideoCore::FrameGen {
 
+[[nodiscard]] bool IsSpirvModule(std::span<const u8> blob);
+
+[[nodiscard]] std::vector<u32> AdoptSpirvModule(std::span<const u8> blob);
+
 [[nodiscard]] std::vector<u32> TranslateComputeShader(std::span<const u8> dxbc);
 
 } // namespace VideoCore::FrameGen

src/video_core/renderer_vulkan/present/frame_gen.cpp

@@ -1,7 +1,9 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include <algorithm>
 #include <string>
+#include <vector>
 
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
@@ -17,27 +19,174 @@ namespace Vulkan {
 
 namespace {
 
-constexpr f32 LSFG_FLOW_SCALE = 1.0f;
+constexpr size_t COLOR_CHANNELS = 4;
+constexpr u64 LSFG_REQUIRED_FRAMES = 2;
+constexpr u32 LSFG_RECURRENCE_FRAMES = 2;
 
-void WriteGrayscalePgm(const std::filesystem::path& path, VkExtent2D extent,
-                       std::span<const u8> pixels) {
+[[nodiscard]] f32 ManualFlowScale() {
+    return static_cast<f32>(Settings::values.frame_gen_flow_scale.GetValue()) / 100.0f;
+}
+
+[[nodiscard]] f32 ConfiguredFlowScale(VkExtent2D guest_extent, VkExtent2D presented_extent) {
+    if (!Settings::values.frame_gen_flow_scale_auto.GetValue()) {
+        return ManualFlowScale();
+    }
+    if (guest_extent.width == 0 || presented_extent.width == 0) {
+        return 1.0f;
+    }
+
+    const f32 rendered_width = static_cast<f32>(guest_extent.width) *
+                               Settings::values.resolution_info.up_factor;
+    const f32 ratio = rendered_width / static_cast<f32>(presented_extent.width);
+
+    constexpr f32 FLOW_SCALE_STEPS = 20.0f;
+    const f32 stepped = std::ceil(ratio * FLOW_SCALE_STEPS) / FLOW_SCALE_STEPS;
+    return std::clamp(stepped, 0.25f, 1.0f);
+}
+
+bool IsBlueFirst(VkFormat format) {
+    return format == VK_FORMAT_B8G8R8A8_UNORM || format == VK_FORMAT_B8G8R8A8_SRGB;
+}
+
+VkDeviceSize BytesPerTexel(VkFormat format) {
+    switch (format) {
+    case VK_FORMAT_R8_UNORM:
+        return 1;
+    case VK_FORMAT_R16G16B16A16_SFLOAT:
+        return 8;
+    default:
+        return COLOR_CHANNELS;
+    }
+}
+
+void WritePortablePixmap(const std::filesystem::path& path, const std::string& magic,
+                         VkExtent2D extent, std::span<const u8> pixels) {
     Common::FS::IOFile file{path, Common::FS::FileAccessMode::Write,
                             Common::FS::FileType::BinaryFile};
     if (!file.IsOpen()) {
         return;
     }
 
-    const std::string header =
-        "P5\n" + std::to_string(extent.width) + " " + std::to_string(extent.height) + "\n255\n";
+    const std::string header = magic + "\n" + std::to_string(extent.width) + " " +
+                               std::to_string(extent.height) + "\n255\n";
     if (file.Write(header) != header.size()) {
         return;
     }
 
-    const size_t expected = static_cast<size_t>(extent.width) * extent.height;
-    void(file.Write(pixels.subspan(0, std::min(expected, pixels.size()))));
+    void(file.Write(pixels));
     void(file.Flush());
 }
 
+void WriteGrayscalePgm(const std::filesystem::path& path, VkExtent2D extent,
+                       std::span<const u8> pixels) {
+    const size_t expected = static_cast<size_t>(extent.width) * extent.height;
+    WritePortablePixmap(path, "P5", extent, pixels.subspan(0, std::min(expected, pixels.size())));
+}
+
+void WriteRaw(const std::filesystem::path& path, std::span<const u8> pixels) {
+    Common::FS::IOFile file{path, Common::FS::FileAccessMode::Write,
+                            Common::FS::FileType::BinaryFile};
+    if (!file.IsOpen()) {
+        return;
+    }
+    void(file.Write(pixels));
+    void(file.Flush());
+}
+
+void WriteColorPpm(const std::filesystem::path& path, VkExtent2D extent,
+                   std::span<const u8> pixels, bool blue_first) {
+    const size_t pixel_count = static_cast<size_t>(extent.width) * extent.height;
+    if (pixels.size() < pixel_count * COLOR_CHANNELS) {
+        return;
+    }
+
+    std::vector<u8> rgb(pixel_count * 3);
+    for (size_t i = 0; i < pixel_count; ++i) {
+        const u8 first = pixels[i * COLOR_CHANNELS];
+        const u8 green = pixels[i * COLOR_CHANNELS + 1];
+        const u8 third = pixels[i * COLOR_CHANNELS + 2];
+        rgb[i * 3] = blue_first ? third : first;
+        rgb[i * 3 + 1] = green;
+        rgb[i * 3 + 2] = blue_first ? first : third;
+    }
+
+    WritePortablePixmap(path, "P6", extent, rgb);
+}
+
+VkImageMemoryBarrier MakeTransitionBarrier(VkImage image, VkAccessFlags src_access,
+                                           VkAccessFlags dst_access, VkImageLayout old_layout,
+                                           VkImageLayout new_layout) {
+    return VkImageMemoryBarrier{
+        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        .pNext = nullptr,
+        .srcAccessMask = src_access,
+        .dstAccessMask = dst_access,
+        .oldLayout = old_layout,
+        .newLayout = new_layout,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = image,
+        .subresourceRange{
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .baseMipLevel = 0,
+            .levelCount = 1,
+            .baseArrayLayer = 0,
+            .layerCount = 1,
+        },
+    };
+}
+
+VkImageCopy MakeCopyRegion(VkExtent2D extent) {
+    return VkImageCopy{
+        .srcSubresource{
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .mipLevel = 0,
+            .baseArrayLayer = 0,
+            .layerCount = 1,
+        },
+        .srcOffset = {},
+        .dstSubresource{
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .mipLevel = 0,
+            .baseArrayLayer = 0,
+            .layerCount = 1,
+        },
+        .dstOffset = {},
+        .extent = {.width = extent.width, .height = extent.height, .depth = 1},
+    };
+}
+
+void CopyPresentedFrame(vk::CommandBuffer cmdbuf, VkImage source, LsfgImage& destination,
+                        VkExtent2D extent) {
+    const auto make_barrier = MakeTransitionBarrier;
+
+    const std::array before{
+        make_barrier(source, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
+                     VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL),
+        make_barrier(destination.Handle(), VK_ACCESS_SHADER_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT,
+                     destination.Layout(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL),
+    };
+    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
+                               VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                           VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {}, {}, before);
+
+    cmdbuf.CopyImage(source, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, destination.Handle(),
+                     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, MakeCopyRegion(extent));
+
+    const std::array after{
+        make_barrier(source, VK_ACCESS_TRANSFER_READ_BIT, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+                     VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL),
+        make_barrier(destination.Handle(), VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
+                     VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL),
+    };
+    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                           VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
+                               VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                           0, {}, {}, after);
+
+    destination.SetLayout(VK_IMAGE_LAYOUT_GENERAL);
+}
+
 } // Anonymous namespace
 
 FrameGen::FrameGen(MemoryAllocator& memory_allocator_, Scheduler& scheduler_)
@@ -45,8 +194,21 @@ FrameGen::FrameGen(MemoryAllocator& memory_allocator_, Scheduler& scheduler_)
 
 FrameGen::~FrameGen() = default;
 
-void FrameGen::Process(const Device& device, Frame* frame) {
+void FrameGen::Process(const Device& device, Frame* frame, VkFormat format,
+                       VkExtent2D guest_extent) {
+    generated = false;
+
     if (unavailable || !Settings::values.frame_gen.GetValue()) {
+        if (chain) {
+            scheduler.Finish();
+            chain.reset();
+        }
+        warm_streak = 0;
+        return;
+    }
+
+    if (!frame->storage_view) {
+        unavailable = true;
         return;
     }
 
@@ -58,55 +220,142 @@ void FrameGen::Process(const Device& device, Frame* frame) {
         }
     }
 
+    peak_guest_extent.width = std::max(peak_guest_extent.width, guest_extent.width);
+    peak_guest_extent.height = std::max(peak_guest_extent.height, guest_extent.height);
+
     const VkExtent2D extent{.width = frame->width, .height = frame->height};
-    if (!mipmaps || built_extent.width != extent.width || built_extent.height != extent.height) {
-        Rebuild(device, extent);
+    const f32 flow_scale = ConfiguredFlowScale(peak_guest_extent, extent);
+    if (!chain || built_extent.width != extent.width || built_extent.height != extent.height ||
+        built_format != format || built_flow_scale != flow_scale) {
+        Rebuild(device, extent, format, flow_scale);
     }
 
-    mipmaps->Dispatch(device, scheduler, *frame->image_view, frame_count);
-    ++frame_count;
+    const u64 count = frame_count++;
+    last_count = count;
+    last_generations = plan.generations;
 
-    const bool dump_requested = Settings::values.frame_gen_dump_flow.GetValue();
+    const bool warm = plan.warm && count + 1 >= LSFG_REQUIRED_FRAMES;
+    warm_streak = warm ? warm_streak + 1 : 0;
+    generated = warm && warm_streak >= LSFG_RECURRENCE_FRAMES && plan.generations > 0;
+
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([this, source = *frame->image, extent, count,
+                      dispatch = warm](vk::CommandBuffer cmdbuf) {
+        CopyPresentedFrame(cmdbuf, source, chain->Input(count), extent);
+        if (dispatch) {
+            chain->DispatchShared(cmdbuf, count);
+        }
+    });
+
+    const bool dump_requested = generated && Settings::values.frame_gen_dump_flow.GetValue();
     if (!dump_requested) {
         dumped = false;
     } else if (!dumped) {
-        DumpFlowPyramid(device);
+        DumpDebugImages(count);
         dumped = true;
     }
 }
 
-void FrameGen::Rebuild(const Device& device, VkExtent2D extent) {
-    scheduler.Finish();
-    mipmaps.emplace(device, memory_allocator, *shaders, extent, LSFG_FLOW_SCALE);
-    built_extent = extent;
-    frame_count = 0;
+size_t FrameGen::WantedGenerations(size_t capacity) {
+    if (unavailable) {
+        plan = {};
+        return 0;
+    }
+    plan = pacer.Plan(capacity);
+    return plan.generations;
 }
 
-void FrameGen::DumpFlowPyramid(const Device& device) {
+size_t FrameGen::GeneratedFrameCount() const {
+    return generated ? last_generations : 0;
+}
+
+void FrameGen::GenerateInto(const Device& device, Frame* destination, size_t generation) {
+    chain->SetTarget(device, last_generations, generation, destination->index,
+                     *destination->storage_view);
+
+    const VkExtent2D extent{.width = destination->width, .height = destination->height};
+
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([this, count = last_count, generation_count = last_generations, generation,
+                      target = destination->index, image = *destination->image,
+                      extent](vk::CommandBuffer cmdbuf) {
+        chain->DispatchGeneration(cmdbuf, count, generation_count, generation, target, image,
+                                  extent);
+    });
+}
+
+void FrameGen::Rebuild(const Device& device, VkExtent2D extent, VkFormat format, f32 flow_scale) {
+    scheduler.Finish();
+    chain.reset();
+
+    built_flow_scale = flow_scale;
+
+    chain.emplace(device, memory_allocator, *shaders, extent, format, built_flow_scale);
+    built_extent = extent;
+    built_format = format;
+    frame_count = 0;
+    warm_streak = 0;
+    generated = false;
+}
+
+void FrameGen::DumpDebugImages(u64 count) {
     const std::filesystem::path directory =
         Common::FS::GetEdenPath(Common::FS::EdenPath::LosslessDir) / "debug";
     if (!Common::FS::CreateDirs(directory)) {
         return;
     }
 
-    for (size_t level = 0; level < LSFG_MIP_LEVELS; ++level) {
-        const VkExtent2D extent = mipmaps->GetLevelExtent(level);
-        const VkDeviceSize size = static_cast<VkDeviceSize>(extent.width) * extent.height;
-        vk::Buffer readback = CreateWrappedBuffer(memory_allocator, size, MemoryUsage::Download);
+    const auto dump = [&](const std::string& name, LsfgImage& image) {
+        const VkExtent2D extent = image.Extent();
+        const VkFormat format = image.Format();
+        const VkDeviceSize texel_size = BytesPerTexel(format);
+        const VkDeviceSize size =
+            static_cast<VkDeviceSize>(extent.width) * extent.height * texel_size;
+
+        vk::Buffer buffer = CreateWrappedBuffer(memory_allocator, size, MemoryUsage::Download);
 
         scheduler.RequestOutsideRenderPassOperationContext();
-        scheduler.Record([image = mipmaps->GetLevelImage(level), dst = *readback,
-                          extent](vk::CommandBuffer cmdbuf) {
-            DownloadColorImage(cmdbuf, image, dst,
-                               VkExtent3D{.width = extent.width, .height = extent.height,
-                                          .depth = 1});
-        });
+        scheduler.Record(
+            [handle = image.Handle(), dst = *buffer, extent](vk::CommandBuffer cmdbuf) {
+                DownloadColorImage(
+                    cmdbuf, handle, dst,
+                    VkExtent3D{.width = extent.width, .height = extent.height, .depth = 1});
+            });
         scheduler.Finish();
 
-        readback.Invalidate();
-        WriteGrayscalePgm(directory / ("flow_mip" + std::to_string(level) + ".pgm"), extent,
-                          readback.Mapped());
+        buffer.Invalidate();
+        const std::span<u8> mapped = buffer.Mapped();
+
+        if (format == LSFG_FLOW_FORMAT) {
+            WriteGrayscalePgm(directory / (name + ".pgm"), extent, mapped);
+        } else if (texel_size == COLOR_CHANNELS) {
+            WriteColorPpm(directory / (name + ".ppm"), extent, mapped, IsBlueFirst(format));
+        } else {
+            WriteRaw(directory / (name + "_" + std::to_string(extent.width) + "x" +
+                                  std::to_string(extent.height) + ".f16"),
+                     mapped.subspan(0, std::min<size_t>(size, mapped.size())));
+        }
+    };
+
+    dump("in0", chain->Input(0));
+    dump("in1", chain->Input(1));
+
+    for (size_t level = 0; level < LSFG_MIP_LEVELS; ++level) {
+        dump("flow_mip" + std::to_string(level), chain->FlowLevel(level));
     }
+    for (size_t index = 0; index < 2; ++index) {
+        dump("alpha0_" + std::to_string(index), chain->AlphaOutput(0, count, index));
+        dump("alpha6_" + std::to_string(index), chain->AlphaOutput(LSFG_MIP_LEVELS - 1, count,
+                                                                  index));
+    }
+    for (size_t level = 0; level < LSFG_BETA_OUTPUTS; ++level) {
+        dump("beta_" + std::to_string(level), chain->BetaOutput(level));
+    }
+
+    dump("gamma0", chain->GammaOutput(0));
+    dump("gamma6", chain->GammaOutput(LSFG_MIP_LEVELS - 1));
+    dump("delta2_out1", chain->DeltaOutput1(LSFG_DELTA_INSTANCES - 1));
+    dump("delta2_out2", chain->DeltaOutput2(LSFG_DELTA_INSTANCES - 1));
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/frame_gen.h

@@ -6,7 +6,8 @@
 #include <optional>
 
 #include "common/common_types.h"
-#include "video_core/renderer_vulkan/present/lsfg_mipmaps.h"
+#include "video_core/renderer_vulkan/present/frame_gen_pacer.h"
+#include "video_core/renderer_vulkan/present/lsfg_chain.h"
 #include "video_core/renderer_vulkan/present/lsfg_shaders.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 
@@ -21,19 +22,34 @@ public:
     explicit FrameGen(MemoryAllocator& memory_allocator, Scheduler& scheduler);
     ~FrameGen();
 
-    void Process(const Device& device, Frame* frame);
+    void Process(const Device& device, Frame* frame, VkFormat format, VkExtent2D guest_extent);
+
+    [[nodiscard]] size_t WantedGenerations(size_t capacity);
+
+    [[nodiscard]] size_t GeneratedFrameCount() const;
+
+    void GenerateInto(const Device& device, Frame* destination, size_t generation);
 
 private:
-    void Rebuild(const Device& device, VkExtent2D extent);
-    void DumpFlowPyramid(const Device& device);
+    void Rebuild(const Device& device, VkExtent2D extent, VkFormat format, f32 flow_scale);
+    void DumpDebugImages(u64 count);
 
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;
 
     std::optional<LsfgShaders> shaders;
-    std::optional<LsfgMipmaps> mipmaps;
+    std::optional<LsfgChain> chain;
+    FrameGenPacer pacer;
+    FrameGenPlan plan{};
+    VkExtent2D peak_guest_extent{};
     VkExtent2D built_extent{};
+    VkFormat built_format{VK_FORMAT_UNDEFINED};
+    f32 built_flow_scale{};
     u64 frame_count{};
+    u64 last_count{};
+    size_t last_generations{};
+    u32 warm_streak{};
+    bool generated{};
     bool unavailable{};
     bool dumped{};
 };

src/video_core/renderer_vulkan/present/frame_gen_pacer.cpp

@@ -0,0 +1,240 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+
+#include "common/settings.h"
+#include "video_core/renderer_vulkan/present/frame_gen_pacer.h"
+
+namespace Vulkan {
+
+namespace {
+
+using Clock = std::chrono::steady_clock;
+
+constexpr f32 INTERVAL_SMOOTHING = 0.25f;
+constexpr f32 MINIMUM_BASE_RATE = 10.0f;
+constexpr f32 BURST_CADENCE_RATIO = 3.0f;
+constexpr f32 BURST_TARGET_RATIO = 2.0f;
+constexpr f32 PROBE_THROUGHPUT_TOLERANCE = 0.95f;
+constexpr f32 PROBE_BASE_COLLAPSE_RATIO = 0.70f;
+constexpr f32 PROBE_MARGINAL_GAIN = 1.15f;
+constexpr f32 TARGET_SATISFIED_RATIO = 0.95f;
+constexpr f32 UNLOADED_BASE_RETENTION = 0.75f;
+constexpr f32 CREDIT_EPSILON = 1.0e-4f;
+constexpr u32 MAX_PROBE_FAILURES = 4;
+
+constexpr auto STABILIZATION_DURATION = std::chrono::seconds(1);
+constexpr auto PROBE_DURATION = std::chrono::seconds(1);
+constexpr auto DEFICIT_DURATION = std::chrono::seconds(1);
+constexpr auto PROBE_STEP_DELAY = std::chrono::milliseconds(250);
+
+[[nodiscard]] Clock::duration ProbeBackoff(u32 failures) {
+    switch (failures) {
+    case 1:
+        return std::chrono::seconds(5);
+    case 2:
+        return std::chrono::seconds(15);
+    case 3:
+        return std::chrono::seconds(30);
+    default:
+        return std::chrono::seconds(60);
+    }
+}
+
+} // Anonymous namespace
+
+FrameGenPlan FrameGenPacer::Plan(size_t capacity) {
+    const size_t ceiling = std::min(capacity, Settings::FrameGenMaxGenerations());
+    if (ceiling == 0) {
+        Reset();
+        return {};
+    }
+
+    const Clock::time_point now = Clock::now();
+    const size_t previous_generations = std::exchange(issued_generations, 0);
+    if (!last_frame) {
+        last_frame = now;
+        return {};
+    }
+
+    const Clock::duration interval = now - *last_frame;
+    const f32 interval_seconds = std::chrono::duration<f32>(interval).count();
+    last_frame = now;
+
+    if (interval_seconds <= 0.0f) {
+        Stabilize(now);
+        return {};
+    }
+
+    const f32 target_rate = static_cast<f32>(Settings::values.frame_gen_target_rate.GetValue());
+
+    if (smoothed_interval > 0.0f) {
+        f32 burst_threshold = BURST_CADENCE_RATIO / smoothed_interval;
+        if (target_rate > 0.0f) {
+            burst_threshold = std::max(burst_threshold, target_rate * BURST_TARGET_RATIO);
+        }
+        if (1.0f / interval_seconds > burst_threshold) {
+            DeferEvaluations(interval);
+            output_credit = 0.0f;
+            return {};
+        }
+    }
+
+    if (interval_seconds > 1.0f / MINIMUM_BASE_RATE) {
+        Stabilize(now);
+        return {};
+    }
+
+    smoothed_interval = smoothed_interval > 0.0f
+                            ? smoothed_interval +
+                                  (interval_seconds - smoothed_interval) * INTERVAL_SMOOTHING
+                            : interval_seconds;
+
+    if (previous_generations == 0) {
+        const f32 measured = 1.0f / smoothed_interval;
+        unloaded_base_rate =
+            unloaded_base_rate > 0.0f
+                ? unloaded_base_rate + (measured - unloaded_base_rate) * INTERVAL_SMOOTHING
+                : measured;
+    }
+
+    if (stable_until) {
+        if (now < *stable_until) {
+            return {};
+        }
+        stable_until.reset();
+    }
+
+    if (target_rate == 0.0f) {
+        limit = std::min(Settings::FrameGenGenerations(), ceiling);
+        output_credit = 0.0f;
+        issued_generations = limit;
+        return {.generations = limit, .warm = limit > 0};
+    }
+
+    UpdateLimit(now, 1.0f / smoothed_interval, target_rate, ceiling);
+
+    const size_t allowed = std::min(limit, ceiling);
+    const f32 desired_outputs = smoothed_interval * target_rate;
+    if (allowed == 0 || desired_outputs <= 1.0f) {
+        output_credit = 0.0f;
+        return {};
+    }
+
+    output_credit += desired_outputs;
+    const size_t outputs =
+        std::max<size_t>(1, static_cast<size_t>(std::floor(output_credit + CREDIT_EPSILON)));
+    const size_t generations = std::min(outputs - 1, allowed);
+
+    output_credit -= static_cast<f32>(generations + 1);
+    if (output_credit < 0.0f) {
+        output_credit = 0.0f;
+    } else if (generations == allowed && output_credit >= 1.0f) {
+        output_credit = std::fmod(output_credit, 1.0f);
+    }
+
+    issued_generations = generations;
+    return {.generations = generations, .warm = true};
+}
+
+void FrameGenPacer::UpdateLimit(Clock::time_point now, f32 base_rate, f32 target_rate,
+                                size_t ceiling) {
+    limit = std::min(limit, ceiling);
+
+    if (probe_until) {
+        if (now < *probe_until) {
+            return;
+        }
+        probe_until.reset();
+        output_credit = 0.0f;
+
+        const f32 previous_output =
+            std::min(target_rate, probe_base_rate * static_cast<f32>(probe_previous_limit + 1));
+        const f32 current_output =
+            std::min(target_rate, base_rate * static_cast<f32>(limit + 1));
+
+        const bool throughput_regressed =
+            current_output < previous_output * PROBE_THROUGHPUT_TOLERANCE;
+        const bool collapsed_for_marginal_gain =
+            base_rate < probe_base_rate * PROBE_BASE_COLLAPSE_RATIO &&
+            current_output < previous_output * PROBE_MARGINAL_GAIN;
+        const bool emulation_slowed = unloaded_base_rate > 0.0f &&
+                                      base_rate < unloaded_base_rate * UNLOADED_BASE_RETENTION;
+
+        if (throughput_regressed || collapsed_for_marginal_gain || emulation_slowed) {
+            limit = probe_previous_limit;
+            probe_failures = std::min(probe_failures + 1, MAX_PROBE_FAILURES);
+            next_probe = now + ProbeBackoff(probe_failures);
+            deficit_since.reset();
+            return;
+        }
+
+        probe_failures = 0;
+        next_probe = now + PROBE_STEP_DELAY;
+    }
+
+    if (base_rate * static_cast<f32>(limit + 1) >= target_rate * TARGET_SATISFIED_RATIO ||
+        limit >= ceiling) {
+        deficit_since.reset();
+        return;
+    }
+
+    if (!deficit_since) {
+        deficit_since = now;
+        return;
+    }
+    if (now - *deficit_since < DEFICIT_DURATION) {
+        return;
+    }
+    if (next_probe && now < *next_probe) {
+        return;
+    }
+
+    probe_previous_limit = limit;
+    probe_base_rate = base_rate;
+    ++limit;
+    probe_until = now + PROBE_DURATION;
+    deficit_since.reset();
+    output_credit = 0.0f;
+}
+
+void FrameGenPacer::DeferEvaluations(Clock::duration amount) {
+    const auto defer = [amount](std::optional<Clock::time_point>& deadline) {
+        if (deadline) {
+            *deadline += amount;
+        }
+    };
+    defer(stable_until);
+    defer(probe_until);
+    defer(next_probe);
+    deficit_since.reset();
+}
+
+void FrameGenPacer::Stabilize(Clock::time_point now) {
+    stable_until = now + STABILIZATION_DURATION;
+    probe_until.reset();
+    deficit_since.reset();
+    smoothed_interval = 0.0f;
+    output_credit = 0.0f;
+}
+
+void FrameGenPacer::Reset() {
+    last_frame.reset();
+    stable_until.reset();
+    probe_until.reset();
+    next_probe.reset();
+    deficit_since.reset();
+    smoothed_interval = 0.0f;
+    output_credit = 0.0f;
+    probe_base_rate = 0.0f;
+    unloaded_base_rate = 0.0f;
+    issued_generations = 0;
+    probe_previous_limit = 0;
+    limit = 0;
+    probe_failures = 0;
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/frame_gen_pacer.h

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <chrono>
+#include <optional>
+
+#include "common/common_types.h"
+
+namespace Vulkan {
+
+struct FrameGenPlan {
+    size_t generations{};
+    bool warm{};
+};
+
+class FrameGenPacer {
+public:
+    [[nodiscard]] FrameGenPlan Plan(size_t capacity);
+
+    void Reset();
+
+private:
+    using Clock = std::chrono::steady_clock;
+
+    void Stabilize(Clock::time_point now);
+    void DeferEvaluations(Clock::duration amount);
+    void UpdateLimit(Clock::time_point now, f32 base_rate, f32 target_rate, size_t ceiling);
+
+    std::optional<Clock::time_point> last_frame;
+    std::optional<Clock::time_point> stable_until;
+    std::optional<Clock::time_point> probe_until;
+    std::optional<Clock::time_point> next_probe;
+    std::optional<Clock::time_point> deficit_since;
+    f32 smoothed_interval{};
+    f32 output_credit{};
+    f32 probe_base_rate{};
+    f32 unloaded_base_rate{};
+    size_t issued_generations{};
+    size_t probe_previous_limit{};
+    size_t limit{};
+    u32 probe_failures{};
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_alpha.cpp

@@ -0,0 +1,140 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <vector>
+
+#include "video_core/frame_gen/lossless_dll.h"
+#include "video_core/renderer_vulkan/present/lsfg_alpha.h"
+#include "video_core/renderer_vulkan/present/lsfg_shaders.h"
+#include "video_core/renderer_vulkan/present/util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+
+namespace Vulkan {
+
+namespace {
+
+constexpr u32 DISPATCH_TILE_SHIFT = 3;
+
+[[nodiscard]] u32 GroupCount(u32 size) {
+    return (size + (1u << DISPATCH_TILE_SHIFT) - 1) >> DISPATCH_TILE_SHIFT;
+}
+
+[[nodiscard]] VkExtent2D HalveExtent(VkExtent2D extent) {
+    return VkExtent2D{
+        .width = (extent.width + 1) >> 1,
+        .height = (extent.height + 1) >> 1,
+    };
+}
+
+} // Anonymous namespace
+
+LsfgAlphaPasses::LsfgAlphaPasses(const Device& device, const LsfgShaders& shaders) {
+    using namespace VideoCore::FrameGen::PerformanceShader;
+
+    passes[0] = LsfgPass(device, shaders, ALPHA[0],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[1] = LsfgPass(device, shaders, ALPHA[1],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[2] = LsfgPass(device, shaders, ALPHA[2],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[3] = LsfgPass(device, shaders, ALPHA[3],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+}
+
+LsfgAlpha::LsfgAlpha(const Device& device, MemoryAllocator& memory_allocator,
+                     const LsfgAlphaPasses& passes_, LsfgResources& resources,
+                     vk::DescriptorPool& descriptor_pool, LsfgImage& input_)
+    : passes{&passes_}, input{&input_} {
+    const VkExtent2D half_extent = HalveExtent(input->Extent());
+    const VkExtent2D quarter_extent = HalveExtent(half_extent);
+
+    temp1 = LsfgImage(device, memory_allocator, half_extent);
+    temp2 = LsfgImage(device, memory_allocator, half_extent);
+    for (size_t i = 0; i < temp3.size(); ++i) {
+        temp3[i] = LsfgImage(device, memory_allocator, quarter_extent);
+        for (size_t j = 0; j < LSFG_HISTORY_SLOTS; ++j) {
+            out_images[j][i] = LsfgImage(device, memory_allocator, quarter_extent);
+        }
+    }
+
+    std::vector<VkDescriptorSetLayout> layouts;
+    for (size_t i = 0; i < LSFG_ALPHA_STAGES - 1; ++i) {
+        layouts.push_back(passes->Get(i).SetLayout());
+    }
+    for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+        layouts.push_back(passes->Get(3).SetLayout());
+    }
+    owned_sets = CreateWrappedDescriptorSets(descriptor_pool, layouts);
+
+    for (size_t i = 0; i < LSFG_ALPHA_STAGES - 1; ++i) {
+        descriptor_sets[i] = owned_sets[i];
+    }
+    for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+        last_descriptor_sets[i] = owned_sets[LSFG_ALPHA_STAGES - 1 + i];
+    }
+
+    const VkSampler sampler = resources.GetSampler();
+
+    LsfgDescriptorWriter(descriptor_sets[0])
+        .AddSampler(sampler)
+        .AddSampledImage(*input)
+        .AddStorageImage(temp1)
+        .Build(device);
+    LsfgDescriptorWriter(descriptor_sets[1])
+        .AddSampler(sampler)
+        .AddSampledImage(temp1)
+        .AddStorageImage(temp2)
+        .Build(device);
+    LsfgDescriptorWriter(descriptor_sets[2])
+        .AddSampler(sampler)
+        .AddSampledImage(temp2)
+        .AddStorageImages(temp3)
+        .Build(device);
+    for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+        LsfgDescriptorWriter(last_descriptor_sets[i])
+            .AddSampler(sampler)
+            .AddSampledImages(temp3)
+            .AddStorageImages(out_images[i])
+            .Build(device);
+    }
+}
+
+void LsfgAlpha::PushBarriers(LsfgBarriers& barriers, u64 frame_count, size_t stage) {
+    switch (stage) {
+    case 0:
+        barriers.WriteToRead(*input).ReadToWrite(temp1);
+        break;
+    case 1:
+        barriers.WriteToRead(temp1).ReadToWrite(temp2);
+        break;
+    case 2:
+        barriers.WriteToRead(temp2).ReadToWriteAll(temp3);
+        break;
+    default:
+        barriers.WriteToReadAll(temp3).ReadToWriteAll(out_images[frame_count % LSFG_HISTORY_SLOTS]);
+        break;
+    }
+}
+
+void LsfgAlpha::DispatchStage(vk::CommandBuffer cmdbuf, u64 frame_count, size_t stage) {
+    const VkExtent2D extent = stage < 2 ? temp1.Extent() : temp3[0].Extent();
+    const VkDescriptorSet set = stage < LSFG_ALPHA_STAGES - 1
+                                    ? descriptor_sets[stage]
+                                    : last_descriptor_sets[frame_count % LSFG_HISTORY_SLOTS];
+
+    passes->Get(stage).BindSet(cmdbuf, set);
+    cmdbuf.Dispatch(GroupCount(extent.width), GroupCount(extent.height), 1);
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_alpha.h

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
+
+namespace Vulkan {
+
+class Device;
+class LsfgShaders;
+
+constexpr size_t LSFG_ALPHA_STAGES = 4;
+
+class LsfgAlphaPasses {
+public:
+    LsfgAlphaPasses() = default;
+    LsfgAlphaPasses(const Device& device, const LsfgShaders& shaders);
+
+    [[nodiscard]] const LsfgPass& Get(size_t stage) const {
+        return passes[stage];
+    }
+
+private:
+    std::array<LsfgPass, LSFG_ALPHA_STAGES> passes;
+};
+
+class LsfgAlpha {
+public:
+    LsfgAlpha() = default;
+    LsfgAlpha(const Device& device, MemoryAllocator& memory_allocator,
+              const LsfgAlphaPasses& passes_, LsfgResources& resources,
+              vk::DescriptorPool& descriptor_pool, LsfgImage& input);
+
+    void PushBarriers(LsfgBarriers& barriers, u64 frame_count, size_t stage);
+    void DispatchStage(vk::CommandBuffer cmdbuf, u64 frame_count, size_t stage);
+
+    [[nodiscard]] LsfgImageHistory& Outputs() {
+        return out_images;
+    }
+
+private:
+    const LsfgAlphaPasses* passes{};
+    LsfgImage* input{};
+
+    std::array<VkDescriptorSet, LSFG_ALPHA_STAGES - 1> descriptor_sets{};
+    std::array<VkDescriptorSet, LSFG_HISTORY_SLOTS> last_descriptor_sets{};
+    vk::DescriptorSets owned_sets;
+
+    LsfgImage temp1;
+    LsfgImage temp2;
+    LsfgImagePair temp3;
+    LsfgImageHistory out_images;
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_beta.cpp

@@ -0,0 +1,147 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <vector>
+
+#include "video_core/frame_gen/lossless_dll.h"
+#include "video_core/renderer_vulkan/present/lsfg_beta.h"
+#include "video_core/renderer_vulkan/present/lsfg_shaders.h"
+#include "video_core/renderer_vulkan/present/util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+
+namespace Vulkan {
+
+namespace {
+
+constexpr u32 DISPATCH_TILE_SHIFT = 3;
+constexpr u32 OUTPUT_TILE_SHIFT = 5;
+
+[[nodiscard]] u32 GroupCount(u32 size, u32 shift) {
+    return (size + (1u << shift) - 1) >> shift;
+}
+
+} // Anonymous namespace
+
+LsfgBeta::LsfgBeta(const Device& device, MemoryAllocator& memory_allocator,
+                   const LsfgShaders& shaders, LsfgResources& resources,
+                   vk::DescriptorPool& descriptor_pool, LsfgImageHistory& inputs_)
+    : inputs{&inputs_} {
+    using namespace VideoCore::FrameGen::PerformanceShader;
+
+    passes[0] = LsfgPass(device, shaders, BETA[0],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {6, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    for (size_t i = 1; i < LSFG_BETA_STAGES - 1; ++i) {
+        passes[i] = LsfgPass(device, shaders, BETA[i],
+                             {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                              {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                              {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    }
+    passes[4] = LsfgPass(device, shaders, BETA[4],
+                         {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                          {1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {6, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+
+    const VkExtent2D extent = (*inputs)[0][0].Extent();
+    for (size_t i = 0; i < temp1.size(); ++i) {
+        temp1[i] = LsfgImage(device, memory_allocator, extent);
+        temp2[i] = LsfgImage(device, memory_allocator, extent);
+    }
+    for (size_t i = 0; i < LSFG_BETA_OUTPUTS; ++i) {
+        const VkExtent2D level_extent{
+            .width = extent.width >> i,
+            .height = extent.height >> i,
+        };
+        out_images[i] = LsfgImage(device, memory_allocator, level_extent, LSFG_FLOW_FORMAT);
+    }
+
+    std::vector<VkDescriptorSetLayout> layouts;
+    for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+        layouts.push_back(passes[0].SetLayout());
+    }
+    for (size_t i = 1; i < LSFG_BETA_STAGES; ++i) {
+        layouts.push_back(passes[i].SetLayout());
+    }
+    owned_sets = CreateWrappedDescriptorSets(descriptor_pool, layouts);
+
+    for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+        first_descriptor_sets[i] = owned_sets[i];
+    }
+    for (size_t i = 0; i < LSFG_BETA_STAGES - 1; ++i) {
+        descriptor_sets[i] = owned_sets[LSFG_HISTORY_SLOTS + i];
+    }
+
+    const VkSampler sampler = resources.GetSampler();
+    const VkSampler border_sampler = resources.GetSampler(
+        VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_COMPARE_OP_NEVER, true);
+
+    for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+        LsfgDescriptorWriter(first_descriptor_sets[i])
+            .AddSampler(border_sampler)
+            .AddSampledImages((*inputs)[(i + 1) % LSFG_HISTORY_SLOTS])
+            .AddSampledImages((*inputs)[(i + 2) % LSFG_HISTORY_SLOTS])
+            .AddSampledImages((*inputs)[i % LSFG_HISTORY_SLOTS])
+            .AddStorageImages(temp1)
+            .Build(device);
+    }
+    LsfgDescriptorWriter(descriptor_sets[0])
+        .AddSampler(sampler)
+        .AddSampledImages(temp1)
+        .AddStorageImages(temp2)
+        .Build(device);
+    LsfgDescriptorWriter(descriptor_sets[1])
+        .AddSampler(sampler)
+        .AddSampledImages(temp2)
+        .AddStorageImages(temp1)
+        .Build(device);
+    LsfgDescriptorWriter(descriptor_sets[2])
+        .AddSampler(sampler)
+        .AddSampledImages(temp1)
+        .AddStorageImages(temp2)
+        .Build(device);
+    LsfgDescriptorWriter(descriptor_sets[3])
+        .AddUniformBuffer(resources.GetBuffer(0.5f), LsfgResources::BufferSize())
+        .AddSampler(sampler)
+        .AddSampledImages(temp2)
+        .AddStorageImages(out_images)
+        .Build(device);
+}
+
+void LsfgBeta::Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count) {
+    const VkExtent2D extent = temp1[0].Extent();
+    const u32 groups_x = GroupCount(extent.width, DISPATCH_TILE_SHIFT);
+    const u32 groups_y = GroupCount(extent.height, DISPATCH_TILE_SHIFT);
+
+    LsfgBarriers barriers(cmdbuf);
+    for (auto& slot : *inputs) {
+        barriers.WriteToReadAll(slot);
+    }
+    barriers.ReadToWriteAll(temp1).Build();
+
+    passes[0].Bind(cmdbuf, first_descriptor_sets[frame_count % LSFG_HISTORY_SLOTS]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp1).ReadToWriteAll(temp2).Build();
+    passes[1].Bind(cmdbuf, descriptor_sets[0]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp2).ReadToWriteAll(temp1).Build();
+    passes[2].Bind(cmdbuf, descriptor_sets[1]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp1).ReadToWriteAll(temp2).Build();
+    passes[3].Bind(cmdbuf, descriptor_sets[2]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp2).ReadToWriteAll(out_images).Build();
+    passes[4].Bind(cmdbuf, descriptor_sets[3]);
+    cmdbuf.Dispatch(GroupCount(extent.width, OUTPUT_TILE_SHIFT),
+                    GroupCount(extent.height, OUTPUT_TILE_SHIFT), 1);
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_beta.h

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
+
+namespace Vulkan {
+
+class Device;
+class LsfgShaders;
+
+constexpr size_t LSFG_BETA_STAGES = 5;
+constexpr size_t LSFG_BETA_OUTPUTS = 6;
+
+class LsfgBeta {
+public:
+    LsfgBeta() = default;
+    LsfgBeta(const Device& device, MemoryAllocator& memory_allocator, const LsfgShaders& shaders,
+             LsfgResources& resources, vk::DescriptorPool& descriptor_pool,
+             LsfgImageHistory& inputs);
+
+    void Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count);
+
+    [[nodiscard]] LsfgImage& Output(size_t level) {
+        return out_images[level];
+    }
+
+private:
+    LsfgImageHistory* inputs{};
+
+    std::array<LsfgPass, LSFG_BETA_STAGES> passes;
+    std::array<VkDescriptorSet, LSFG_HISTORY_SLOTS> first_descriptor_sets{};
+    std::array<VkDescriptorSet, LSFG_BETA_STAGES - 1> descriptor_sets{};
+    vk::DescriptorSets owned_sets;
+
+    LsfgImagePair temp1;
+    LsfgImagePair temp2;
+    std::array<LsfgImage, LSFG_BETA_OUTPUTS> out_images;
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_chain.cpp

@@ -0,0 +1,103 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <algorithm>
+
+#include "video_core/renderer_vulkan/present/lsfg_chain.h"
+#include "video_core/renderer_vulkan/present/lsfg_shaders.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+
+namespace Vulkan {
+
+namespace {
+
+constexpr u32 FIXED_DESCRIPTOR_SETS = 64;
+constexpr u32 DESCRIPTOR_SETS_PER_SLOT = 112;
+constexpr size_t FIRST_DELTA_LEVEL = 4;
+
+} // Anonymous namespace
+
+LsfgChain::LsfgChain(const Device& device, MemoryAllocator& memory_allocator,
+                     const LsfgShaders& shaders, VkExtent2D extent, VkFormat format,
+                     f32 flow_scale)
+    : resources{device, memory_allocator, flow_scale},
+      descriptor_pool{CreateLsfgDescriptorPool(
+          device, FIXED_DESCRIPTOR_SETS +
+                      DESCRIPTOR_SETS_PER_SLOT * static_cast<u32>(LSFG_GENERATION_SLOTS))} {
+    for (auto& image : frames) {
+        image = LsfgImage(device, memory_allocator, extent, format);
+    }
+
+    mipmaps = LsfgMipmaps(device, memory_allocator, shaders, resources, descriptor_pool, frames,
+                          flow_scale);
+
+    alpha_passes = LsfgAlphaPasses(device, shaders);
+    for (size_t i = 0; i < LSFG_MIP_LEVELS; ++i) {
+        alpha[i] = LsfgAlpha(device, memory_allocator, alpha_passes, resources, descriptor_pool,
+                             mipmaps.Output(i));
+    }
+
+    beta = LsfgBeta(device, memory_allocator, shaders, resources, descriptor_pool,
+                    alpha[0].Outputs());
+
+    for (size_t i = 0; i < LSFG_MIP_LEVELS; ++i) {
+        const size_t level = LSFG_MIP_LEVELS - 1 - i;
+        gamma[i] = LsfgGamma(device, memory_allocator, shaders, resources, descriptor_pool,
+                             alpha[level].Outputs(),
+                             beta.Output(std::min(level, LSFG_BETA_OUTPUTS - 1)),
+                             i == 0 ? nullptr : &gamma[i - 1].Output());
+
+        if (i < FIRST_DELTA_LEVEL) {
+            continue;
+        }
+
+        const size_t index = i - FIRST_DELTA_LEVEL;
+        delta[index] = LsfgDelta(
+            device, memory_allocator, shaders, resources, descriptor_pool, alpha[level].Outputs(),
+            beta.Output(level), i == FIRST_DELTA_LEVEL ? nullptr : &gamma[i - 1].Output(),
+            i == FIRST_DELTA_LEVEL ? nullptr : &delta[index - 1].Output1(),
+            i == FIRST_DELTA_LEVEL ? nullptr : &delta[index - 1].Output2());
+    }
+
+    generate = LsfgGenerate(device, shaders, resources, descriptor_pool, frames,
+                            gamma[LSFG_MIP_LEVELS - 1].Output(),
+                            delta[LSFG_DELTA_INSTANCES - 1].Output1(),
+                            delta[LSFG_DELTA_INSTANCES - 1].Output2());
+}
+
+void LsfgChain::DispatchShared(vk::CommandBuffer cmdbuf, u64 frame_count) {
+    mipmaps.Dispatch(cmdbuf, frame_count);
+
+    for (size_t stage = 0; stage < LSFG_ALPHA_STAGES; ++stage) {
+        LsfgBarriers barriers(cmdbuf);
+        for (auto& level : alpha) {
+            level.PushBarriers(barriers, frame_count, stage);
+        }
+        barriers.Build();
+
+        alpha_passes.Get(stage).BindPipeline(cmdbuf);
+        for (auto& level : alpha) {
+            level.DispatchStage(cmdbuf, frame_count, stage);
+        }
+    }
+
+    beta.Dispatch(cmdbuf, frame_count);
+}
+
+void LsfgChain::DispatchGeneration(vk::CommandBuffer cmdbuf, u64 frame_count,
+                                   size_t generation_count, size_t generation, u32 target,
+                                   VkImage image, VkExtent2D extent) {
+    const size_t slot = LsfgGenerationSlot(generation_count, generation);
+    for (size_t i = 0; i < LSFG_MIP_LEVELS; ++i) {
+        gamma[i].Dispatch(cmdbuf, frame_count, slot);
+        if (i >= FIRST_DELTA_LEVEL) {
+            delta[i - FIRST_DELTA_LEVEL].Dispatch(cmdbuf, frame_count, slot);
+        }
+    }
+    generate.Dispatch(cmdbuf, frame_count, slot, target, image, extent);
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_chain.h

@@ -0,0 +1,87 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+#include "video_core/renderer_vulkan/present/lsfg_alpha.h"
+#include "video_core/renderer_vulkan/present/lsfg_beta.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
+#include "video_core/renderer_vulkan/present/lsfg_delta.h"
+#include "video_core/renderer_vulkan/present/lsfg_gamma.h"
+#include "video_core/renderer_vulkan/present/lsfg_generate.h"
+#include "video_core/renderer_vulkan/present/lsfg_mipmaps.h"
+
+namespace Vulkan {
+
+class Device;
+class LsfgShaders;
+
+constexpr size_t LSFG_DELTA_INSTANCES = 3;
+
+class LsfgChain {
+public:
+    LsfgChain(const Device& device, MemoryAllocator& memory_allocator, const LsfgShaders& shaders,
+              VkExtent2D extent, VkFormat format, f32 flow_scale);
+
+    LsfgChain(const LsfgChain&) = delete;
+    LsfgChain& operator=(const LsfgChain&) = delete;
+
+    void DispatchShared(vk::CommandBuffer cmdbuf, u64 frame_count);
+
+    void DispatchGeneration(vk::CommandBuffer cmdbuf, u64 frame_count, size_t generation_count,
+                            size_t generation, u32 target, VkImage image, VkExtent2D extent);
+
+    void SetTarget(const Device& device, size_t generation_count, size_t generation, u32 target,
+                   VkImageView view) {
+        generate.SetTarget(device, LsfgGenerationSlot(generation_count, generation), target, view);
+    }
+
+    [[nodiscard]] LsfgImage& Input(u64 frame_count) {
+        return frames[frame_count % frames.size()];
+    }
+
+    [[nodiscard]] LsfgImage& FlowLevel(size_t level) {
+        return mipmaps.Output(level);
+    }
+
+    [[nodiscard]] LsfgImage& AlphaOutput(size_t level, u64 frame_count, size_t index) {
+        return alpha[level].Outputs()[frame_count % LSFG_HISTORY_SLOTS][index];
+    }
+
+    [[nodiscard]] LsfgImage& BetaOutput(size_t level) {
+        return beta.Output(level);
+    }
+
+    [[nodiscard]] LsfgImage& GammaOutput(size_t index) {
+        return gamma[index].Output();
+    }
+
+    [[nodiscard]] LsfgImage& DeltaOutput1(size_t index) {
+        return delta[index].Output1();
+    }
+
+    [[nodiscard]] LsfgImage& DeltaOutput2(size_t index) {
+        return delta[index].Output2();
+    }
+
+private:
+    LsfgResources resources;
+    vk::DescriptorPool descriptor_pool;
+
+    LsfgImagePair frames;
+    LsfgMipmaps mipmaps;
+    LsfgAlphaPasses alpha_passes;
+    std::array<LsfgAlpha, LSFG_MIP_LEVELS> alpha;
+    LsfgBeta beta;
+    std::array<LsfgGamma, LSFG_MIP_LEVELS> gamma;
+    std::array<LsfgDelta, LSFG_DELTA_INSTANCES> delta;
+    LsfgGenerate generate;
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_common.cpp

@@ -0,0 +1,339 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <algorithm>
+#include <cstring>
+
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
+#include "video_core/renderer_vulkan/present/lsfg_shaders.h"
+#include "video_core/renderer_vulkan/present/util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+
+namespace Vulkan {
+
+namespace {
+
+constexpr u32 DESCRIPTORS_PER_TYPE = 4096;
+
+struct LsfgConstants {
+    std::array<u32, 2> input_offset;
+    u32 first_iter;
+    u32 first_iter_s;
+    u32 advanced_color_kind;
+    u32 hdr_support;
+    f32 resolution_inv_scale;
+    f32 timestamp;
+    f32 ui_threshold;
+    std::array<u32, 3> padding;
+};
+static_assert(sizeof(LsfgConstants) == 48);
+
+vk::Image CreateChainImage(MemoryAllocator& memory_allocator, VkExtent2D extent, VkFormat format) {
+    const VkImageCreateInfo image_ci{
+        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .imageType = VK_IMAGE_TYPE_2D,
+        .format = format,
+        .extent = {.width = extent.width, .height = extent.height, .depth = 1},
+        .mipLevels = 1,
+        .arrayLayers = 1,
+        .samples = VK_SAMPLE_COUNT_1_BIT,
+        .tiling = VK_IMAGE_TILING_OPTIMAL,
+        .usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                 VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = nullptr,
+        .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+    };
+    return memory_allocator.CreateImage(image_ci);
+}
+
+vk::Buffer CreateUniformBuffer(MemoryAllocator& memory_allocator, VkDeviceSize size) {
+    const VkBufferCreateInfo buffer_ci{
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .size = size,
+        .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = nullptr,
+    };
+    return memory_allocator.CreateBuffer(buffer_ci, MemoryUsage::Upload);
+}
+
+VkImageMemoryBarrier MakeBarrier(const LsfgImage& image, VkAccessFlags src_access,
+                                 VkAccessFlags dst_access) {
+    return VkImageMemoryBarrier{
+        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        .pNext = nullptr,
+        .srcAccessMask = src_access,
+        .dstAccessMask = dst_access,
+        .oldLayout = image.Layout(),
+        .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = image.Handle(),
+        .subresourceRange{
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .baseMipLevel = 0,
+            .levelCount = 1,
+            .baseArrayLayer = 0,
+            .layerCount = 1,
+        },
+    };
+}
+
+} // Anonymous namespace
+
+LsfgImage::LsfgImage(const Device& device, MemoryAllocator& memory_allocator, VkExtent2D extent_,
+                     VkFormat format_)
+    : extent{std::max(1u, extent_.width), std::max(1u, extent_.height)}, format{format_} {
+    image = CreateChainImage(memory_allocator, extent, format);
+    view = CreateWrappedImageView(device, image, format);
+}
+
+LsfgBarriers& LsfgBarriers::Push(LsfgImage& image, VkAccessFlags src_access,
+                                 VkAccessFlags dst_access) {
+    barriers.push_back(MakeBarrier(image, src_access, dst_access));
+    image.SetLayout(VK_IMAGE_LAYOUT_GENERAL);
+    return *this;
+}
+
+LsfgBarriers& LsfgBarriers::WriteToRead(LsfgImage& image) {
+    return Push(image, VK_ACCESS_SHADER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT);
+}
+
+LsfgBarriers& LsfgBarriers::ReadToWrite(LsfgImage& image) {
+    return Push(image, VK_ACCESS_SHADER_READ_BIT, VK_ACCESS_SHADER_WRITE_BIT);
+}
+
+LsfgBarriers& LsfgBarriers::WriteToRead(LsfgImage* image) {
+    return image == nullptr ? *this : WriteToRead(*image);
+}
+
+LsfgBarriers& LsfgBarriers::ReadToWrite(LsfgImage* image) {
+    return image == nullptr ? *this : ReadToWrite(*image);
+}
+
+LsfgBarriers& LsfgBarriers::DiscardToWrite(VkImage image) {
+    barriers.push_back(VkImageMemoryBarrier{
+        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        .pNext = nullptr,
+        .srcAccessMask = 0,
+        .dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
+        .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
+        .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = image,
+        .subresourceRange{
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .baseMipLevel = 0,
+            .levelCount = 1,
+            .baseArrayLayer = 0,
+            .layerCount = 1,
+        },
+    });
+    return *this;
+}
+
+VkDeviceSize LsfgResources::BufferSize() {
+    return sizeof(LsfgConstants);
+}
+
+VkSampler LsfgResources::GetSampler(VkSamplerAddressMode address_mode, VkCompareOp compare_op,
+                                    bool white_border) {
+    const u64 key = static_cast<u64>(address_mode) | (static_cast<u64>(compare_op) << 8) |
+                    (static_cast<u64>(white_border) << 16);
+
+    const auto it = samplers.find(key);
+    if (it != samplers.end()) {
+        return *it->second;
+    }
+
+    const auto [entry, inserted] =
+        samplers.emplace(key, CreateLsfgSampler(*device, address_mode, compare_op, white_border));
+    return *entry->second;
+}
+
+VkBuffer LsfgResources::GetBuffer(f32 timestamp, bool first_iter, bool first_iter_s) {
+    u32 timestamp_bits{};
+    std::memcpy(&timestamp_bits, &timestamp, sizeof(timestamp_bits));
+    const u64 key = static_cast<u64>(timestamp_bits) | (static_cast<u64>(first_iter) << 32) |
+                    (static_cast<u64>(first_iter_s) << 33);
+
+    const auto it = buffers.find(key);
+    if (it != buffers.end()) {
+        return *it->second;
+    }
+
+    vk::Buffer buffer = CreateUniformBuffer(*memory_allocator, sizeof(LsfgConstants));
+
+    const LsfgConstants constants{
+        .input_offset = {0, 0},
+        .first_iter = first_iter ? 1u : 0u,
+        .first_iter_s = first_iter_s ? 1u : 0u,
+        .advanced_color_kind = 0,
+        .hdr_support = 0,
+        .resolution_inv_scale = 1.0f / flow_scale,
+        .timestamp = timestamp,
+        .ui_threshold = 0.5f,
+        .padding = {0, 0, 0},
+    };
+
+    const std::span<u8> mapped = buffer.Mapped();
+    std::memcpy(mapped.data(), &constants, sizeof(constants));
+    buffer.Flush();
+
+    const auto [entry, inserted] = buffers.emplace(key, std::move(buffer));
+    return *entry->second;
+}
+
+void LsfgBarriers::Build() {
+    if (barriers.empty()) {
+        return;
+    }
+    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                           VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, {}, {}, barriers);
+    barriers.clear();
+}
+
+LsfgDescriptorWriter& LsfgDescriptorWriter::PushImage(VkDescriptorType type, VkSampler sampler,
+                                                      VkImageView view) {
+    image_infos.push_back(VkDescriptorImageInfo{
+        .sampler = sampler,
+        .imageView = view,
+        .imageLayout = view == VK_NULL_HANDLE ? VK_IMAGE_LAYOUT_UNDEFINED
+                                              : VK_IMAGE_LAYOUT_GENERAL,
+    });
+    writes.push_back(VkWriteDescriptorSet{
+        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+        .pNext = nullptr,
+        .dstSet = set,
+        .dstBinding = binding++,
+        .dstArrayElement = 0,
+        .descriptorCount = 1,
+        .descriptorType = type,
+        .pImageInfo = &image_infos.back(),
+        .pBufferInfo = nullptr,
+        .pTexelBufferView = nullptr,
+    });
+    return *this;
+}
+
+LsfgDescriptorWriter& LsfgDescriptorWriter::AddSampler(VkSampler sampler) {
+    return PushImage(VK_DESCRIPTOR_TYPE_SAMPLER, sampler, VK_NULL_HANDLE);
+}
+
+LsfgDescriptorWriter& LsfgDescriptorWriter::AddSampledImage(const LsfgImage& image) {
+    return PushImage(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_NULL_HANDLE, image.View());
+}
+
+LsfgDescriptorWriter& LsfgDescriptorWriter::AddSampledImage(const LsfgImage* image) {
+    return PushImage(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_NULL_HANDLE,
+                     image == nullptr ? VK_NULL_HANDLE : image->View());
+}
+
+LsfgDescriptorWriter& LsfgDescriptorWriter::AddStorageImage(const LsfgImage& image) {
+    return PushImage(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_NULL_HANDLE, image.View());
+}
+
+LsfgDescriptorWriter& LsfgDescriptorWriter::AddStorageView(VkImageView view) {
+    return PushImage(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_NULL_HANDLE, view);
+}
+
+LsfgDescriptorWriter& LsfgDescriptorWriter::AddUniformBuffer(VkBuffer buffer, VkDeviceSize size) {
+    buffer_infos.push_back(VkDescriptorBufferInfo{
+        .buffer = buffer,
+        .offset = 0,
+        .range = size,
+    });
+    writes.push_back(VkWriteDescriptorSet{
+        .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+        .pNext = nullptr,
+        .dstSet = set,
+        .dstBinding = binding++,
+        .dstArrayElement = 0,
+        .descriptorCount = 1,
+        .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+        .pImageInfo = nullptr,
+        .pBufferInfo = &buffer_infos.back(),
+        .pTexelBufferView = nullptr,
+    });
+    return *this;
+}
+
+void LsfgDescriptorWriter::Build(const Device& device) {
+    if (writes.empty()) {
+        return;
+    }
+    device.GetLogical().UpdateDescriptorSets(writes, {});
+    writes.clear();
+}
+
+LsfgPass::LsfgPass(const Device& device, const LsfgShaders& shaders, u32 shader_id,
+                   LsfgBindings bindings) {
+    std::vector<VkDescriptorType> types;
+    for (const auto& [count, type] : bindings) {
+        types.insert(types.end(), count, type);
+    }
+    descriptor_count = static_cast<u32>(types.size());
+
+    descriptor_set_layout = CreateWrappedDescriptorSetLayout(
+        device, std::span<const VkDescriptorType>{types}, VK_SHADER_STAGE_COMPUTE_BIT);
+    pipeline_layout = CreateWrappedPipelineLayout(device, descriptor_set_layout);
+    pipeline = CreateWrappedComputePipeline(device, pipeline_layout, shaders.Get(shader_id));
+}
+
+void LsfgPass::Bind(vk::CommandBuffer cmdbuf, VkDescriptorSet set) const {
+    BindPipeline(cmdbuf);
+    BindSet(cmdbuf, set);
+}
+
+void LsfgPass::BindPipeline(vk::CommandBuffer cmdbuf) const {
+    cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
+}
+
+void LsfgPass::BindSet(vk::CommandBuffer cmdbuf, VkDescriptorSet set) const {
+    cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline_layout, 0, set, {});
+}
+
+vk::DescriptorPool CreateLsfgDescriptorPool(const Device& device, u32 max_sets) {
+    return CreateWrappedDescriptorPool(
+        device, DESCRIPTORS_PER_TYPE, max_sets,
+        {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_SAMPLER,
+         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE});
+}
+
+vk::Sampler CreateLsfgSampler(const Device& device, VkSamplerAddressMode address_mode,
+                              VkCompareOp compare_op, bool white_border) {
+    return device.GetLogical().CreateSampler(VkSamplerCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .magFilter = VK_FILTER_LINEAR,
+        .minFilter = VK_FILTER_LINEAR,
+        .mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
+        .addressModeU = address_mode,
+        .addressModeV = address_mode,
+        .addressModeW = address_mode,
+        .mipLodBias = 0.0f,
+        .anisotropyEnable = VK_FALSE,
+        .maxAnisotropy = 0.0f,
+        .compareEnable = VK_FALSE,
+        .compareOp = compare_op,
+        .minLod = 0.0f,
+        .maxLod = VK_LOD_CLAMP_NONE,
+        .borderColor = white_border ? VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE
+                                    : VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
+        .unnormalizedCoordinates = VK_FALSE,
+    });
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_common.h

@@ -0,0 +1,227 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+#include <deque>
+#include <initializer_list>
+#include <map>
+#include <utility>
+#include <vector>
+
+#include "common/common_types.h"
+#include "video_core/vulkan_common/vulkan_memory_allocator.h"
+#include "video_core/vulkan_common/vulkan_wrapper.h"
+
+namespace Vulkan {
+
+class Device;
+class LsfgShaders;
+
+constexpr VkFormat LSFG_DEFAULT_FORMAT = VK_FORMAT_R8G8B8A8_UNORM;
+constexpr VkFormat LSFG_FLOW_FORMAT = VK_FORMAT_R8_UNORM;
+constexpr VkFormat LSFG_MOTION_FORMAT = VK_FORMAT_R16G16B16A16_SFLOAT;
+
+constexpr size_t LSFG_HISTORY_SLOTS = 3;
+constexpr size_t LSFG_MAX_TARGETS = 7;
+constexpr size_t LSFG_MAX_GENERATIONS = 3;
+
+constexpr size_t LSFG_GENERATION_SLOTS = LSFG_MAX_GENERATIONS * (LSFG_MAX_GENERATIONS + 1) / 2;
+
+[[nodiscard]] constexpr size_t LsfgGenerationSlot(size_t generation_count, size_t generation) {
+    return (generation_count - 1) * generation_count / 2 + generation;
+}
+
+[[nodiscard]] constexpr f32 LsfgTimestamp(size_t generation, size_t generation_count) {
+    return static_cast<f32>(generation + 1) / static_cast<f32>(generation_count + 1);
+}
+
+[[nodiscard]] constexpr size_t LsfgSlotCount(size_t slot) {
+    size_t count = 1;
+    while (LsfgGenerationSlot(count + 1, 0) <= slot) {
+        ++count;
+    }
+    return count;
+}
+
+[[nodiscard]] constexpr f32 LsfgSlotTimestamp(size_t slot) {
+    const size_t count = LsfgSlotCount(slot);
+    return LsfgTimestamp(slot - LsfgGenerationSlot(count, 0), count);
+}
+
+class LsfgImage {
+public:
+    LsfgImage() = default;
+    LsfgImage(const Device& device, MemoryAllocator& memory_allocator, VkExtent2D extent_,
+              VkFormat format = LSFG_DEFAULT_FORMAT);
+
+    [[nodiscard]] VkImage Handle() const {
+        return *image;
+    }
+
+    [[nodiscard]] VkImageView View() const {
+        return *view;
+    }
+
+    [[nodiscard]] VkExtent2D Extent() const {
+        return extent;
+    }
+
+    [[nodiscard]] VkFormat Format() const {
+        return format;
+    }
+
+    [[nodiscard]] VkImageLayout Layout() const {
+        return layout;
+    }
+
+    void SetLayout(VkImageLayout new_layout) {
+        layout = new_layout;
+    }
+
+private:
+    vk::Image image;
+    vk::ImageView view;
+    VkExtent2D extent{};
+    VkFormat format{VK_FORMAT_UNDEFINED};
+    VkImageLayout layout{VK_IMAGE_LAYOUT_UNDEFINED};
+};
+
+using LsfgImagePair = std::array<LsfgImage, 2>;
+using LsfgImageHistory = std::array<LsfgImagePair, LSFG_HISTORY_SLOTS>;
+
+class LsfgResources {
+public:
+    LsfgResources() = default;
+    LsfgResources(const Device& device_, MemoryAllocator& memory_allocator_, f32 flow_scale_)
+        : device{&device_}, memory_allocator{&memory_allocator_}, flow_scale{flow_scale_} {}
+
+    [[nodiscard]] VkSampler GetSampler(
+        VkSamplerAddressMode address_mode = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
+        VkCompareOp compare_op = VK_COMPARE_OP_NEVER, bool white_border = false);
+
+    [[nodiscard]] VkBuffer GetBuffer(f32 timestamp = 0.0f, bool first_iter = false,
+                                     bool first_iter_s = false);
+
+    [[nodiscard]] static VkDeviceSize BufferSize();
+
+private:
+    const Device* device{};
+    MemoryAllocator* memory_allocator{};
+    f32 flow_scale{1.0f};
+
+    std::map<u64, vk::Sampler> samplers;
+    std::map<u64, vk::Buffer> buffers;
+};
+
+class LsfgBarriers {
+public:
+    explicit LsfgBarriers(vk::CommandBuffer cmdbuf_) : cmdbuf{cmdbuf_} {}
+
+    LsfgBarriers& WriteToRead(LsfgImage& image);
+    LsfgBarriers& ReadToWrite(LsfgImage& image);
+    LsfgBarriers& WriteToRead(LsfgImage* image);
+    LsfgBarriers& ReadToWrite(LsfgImage* image);
+    LsfgBarriers& DiscardToWrite(VkImage image);
+
+    template <typename Range>
+    LsfgBarriers& WriteToReadAll(Range& images) {
+        for (auto& image : images) {
+            WriteToRead(image);
+        }
+        return *this;
+    }
+
+    template <typename Range>
+    LsfgBarriers& ReadToWriteAll(Range& images) {
+        for (auto& image : images) {
+            ReadToWrite(image);
+        }
+        return *this;
+    }
+
+    void Build();
+
+private:
+    LsfgBarriers& Push(LsfgImage& image, VkAccessFlags src_access, VkAccessFlags dst_access);
+
+    vk::CommandBuffer cmdbuf;
+    std::vector<VkImageMemoryBarrier> barriers;
+};
+
+class LsfgDescriptorWriter {
+public:
+    explicit LsfgDescriptorWriter(VkDescriptorSet set_) : set{set_} {}
+
+    LsfgDescriptorWriter& AddSampler(VkSampler sampler);
+    LsfgDescriptorWriter& AddSampledImage(const LsfgImage& image);
+    LsfgDescriptorWriter& AddSampledImage(const LsfgImage* image);
+    LsfgDescriptorWriter& AddStorageImage(const LsfgImage& image);
+    LsfgDescriptorWriter& AddStorageView(VkImageView view);
+    LsfgDescriptorWriter& AddUniformBuffer(VkBuffer buffer, VkDeviceSize size);
+
+    template <typename Range>
+    LsfgDescriptorWriter& AddSampledImages(const Range& images) {
+        for (const auto& image : images) {
+            AddSampledImage(image);
+        }
+        return *this;
+    }
+
+    template <typename Range>
+    LsfgDescriptorWriter& AddStorageImages(const Range& images) {
+        for (const auto& image : images) {
+            AddStorageImage(image);
+        }
+        return *this;
+    }
+
+    void Build(const Device& device);
+
+private:
+    LsfgDescriptorWriter& PushImage(VkDescriptorType type, VkSampler sampler, VkImageView view);
+
+    VkDescriptorSet set;
+    u32 binding{};
+    std::deque<VkDescriptorImageInfo> image_infos;
+    std::deque<VkDescriptorBufferInfo> buffer_infos;
+    std::vector<VkWriteDescriptorSet> writes;
+};
+
+using LsfgBindings = std::initializer_list<std::pair<u32, VkDescriptorType>>;
+
+class LsfgPass {
+public:
+    LsfgPass() = default;
+    LsfgPass(const Device& device, const LsfgShaders& shaders, u32 shader_id,
+             LsfgBindings bindings);
+
+    [[nodiscard]] VkDescriptorSetLayout SetLayout() const {
+        return *descriptor_set_layout;
+    }
+
+    [[nodiscard]] u32 DescriptorCount() const {
+        return descriptor_count;
+    }
+
+    void Bind(vk::CommandBuffer cmdbuf, VkDescriptorSet set) const;
+    void BindPipeline(vk::CommandBuffer cmdbuf) const;
+    void BindSet(vk::CommandBuffer cmdbuf, VkDescriptorSet set) const;
+
+private:
+    vk::DescriptorSetLayout descriptor_set_layout;
+    vk::PipelineLayout pipeline_layout;
+    vk::Pipeline pipeline;
+    u32 descriptor_count{};
+};
+
+[[nodiscard]] vk::DescriptorPool CreateLsfgDescriptorPool(const Device& device, u32 max_sets);
+
+[[nodiscard]] vk::Sampler CreateLsfgSampler(const Device& device, VkSamplerAddressMode address_mode,
+                                            VkCompareOp compare_op, bool white_border);
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_delta.cpp

@@ -0,0 +1,283 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <vector>
+
+#include "video_core/frame_gen/lossless_dll.h"
+#include "video_core/renderer_vulkan/present/lsfg_delta.h"
+#include "video_core/renderer_vulkan/present/lsfg_shaders.h"
+#include "video_core/renderer_vulkan/present/util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+
+namespace Vulkan {
+
+namespace {
+
+constexpr u32 DISPATCH_TILE_SHIFT = 3;
+
+[[nodiscard]] u32 GroupCount(u32 size) {
+    return (size + (1u << DISPATCH_TILE_SHIFT) - 1) >> DISPATCH_TILE_SHIFT;
+}
+
+} // Anonymous namespace
+
+LsfgDelta::LsfgDelta(const Device& device, MemoryAllocator& memory_allocator,
+                     const LsfgShaders& shaders, LsfgResources& resources,
+                     vk::DescriptorPool& descriptor_pool, LsfgImageHistory& inputs_,
+                     LsfgImage& flow_input_, LsfgImage* previous_gamma_, LsfgImage* previous1_,
+                     LsfgImage* previous2_)
+    : inputs{&inputs_}, flow_input{&flow_input_}, previous_gamma{previous_gamma_},
+      previous1{previous1_}, previous2{previous2_} {
+    using namespace VideoCore::FrameGen::PerformanceShader;
+
+    passes[0] = LsfgPass(device, shaders, DELTA[0],
+                         {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {5, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[1] = LsfgPass(device, shaders, DELTA[1],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {3, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[2] = LsfgPass(device, shaders, DELTA[2],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[3] = LsfgPass(device, shaders, DELTA[3],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[4] = LsfgPass(device, shaders, DELTA[4],
+                         {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {4, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[5] = LsfgPass(device, shaders, DELTA[5],
+                         {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {6, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    for (size_t i = 6; i < LSFG_DELTA_STAGES - 1; ++i) {
+        passes[i] = LsfgPass(device, shaders, DELTA[i],
+                             {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                              {1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                              {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    }
+    passes[9] = LsfgPass(device, shaders, DELTA[9],
+                         {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+
+    const VkExtent2D extent = (*inputs)[0][0].Extent();
+    for (auto& image : temp1) {
+        image = LsfgImage(device, memory_allocator, extent);
+    }
+    for (auto& image : temp2) {
+        image = LsfgImage(device, memory_allocator, extent);
+    }
+    out_image1 = LsfgImage(device, memory_allocator, extent, LSFG_MOTION_FORMAT);
+    out_image2 = LsfgImage(device, memory_allocator, extent, LSFG_MOTION_FORMAT);
+
+    std::vector<VkDescriptorSetLayout> layouts;
+    for (size_t slot = 0; slot < LSFG_GENERATION_SLOTS; ++slot) {
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            layouts.push_back(passes[0].SetLayout());
+        }
+        for (size_t i = 1; i <= 4; ++i) {
+            layouts.push_back(passes[i].SetLayout());
+        }
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            layouts.push_back(passes[5].SetLayout());
+        }
+        for (size_t i = 6; i < LSFG_DELTA_STAGES; ++i) {
+            layouts.push_back(passes[i].SetLayout());
+        }
+    }
+    owned_sets = CreateWrappedDescriptorSets(descriptor_pool, layouts);
+
+    const VkSampler sampler = resources.GetSampler();
+    const VkSampler border_sampler = resources.GetSampler(
+        VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_COMPARE_OP_NEVER, true);
+    const VkSampler edge_sampler =
+        resources.GetSampler(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_COMPARE_OP_ALWAYS, false);
+    size_t next = 0;
+    for (size_t slot = 0; slot < LSFG_GENERATION_SLOTS; ++slot) {
+        Generation& pass = generations[slot];
+        const VkBuffer buffer =
+            resources.GetBuffer(LsfgSlotTimestamp(slot), false, previous_gamma == nullptr);
+
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            pass.first_descriptor_sets[i] = owned_sets[next++];
+        }
+        for (size_t i = 0; i < 4; ++i) {
+            pass.descriptor_sets[i] = owned_sets[next++];
+        }
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            pass.sixth_descriptor_sets[i] = owned_sets[next++];
+        }
+        for (size_t i = 4; i < LSFG_DELTA_STAGES - 2; ++i) {
+            pass.descriptor_sets[i] = owned_sets[next++];
+        }
+
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            LsfgDescriptorWriter(pass.first_descriptor_sets[i])
+                .AddUniformBuffer(buffer, LsfgResources::BufferSize())
+                .AddSampler(border_sampler)
+                .AddSampler(edge_sampler)
+                .AddSampledImages((*inputs)[(i + 2) % LSFG_HISTORY_SLOTS])
+                .AddSampledImages((*inputs)[i % LSFG_HISTORY_SLOTS])
+                .AddSampledImage(previous_gamma)
+                .AddStorageImages(temp1)
+                .Build(device);
+            LsfgDescriptorWriter(pass.sixth_descriptor_sets[i])
+                .AddUniformBuffer(buffer, LsfgResources::BufferSize())
+                .AddSampler(border_sampler)
+                .AddSampler(edge_sampler)
+                .AddSampledImages((*inputs)[(i + 2) % LSFG_HISTORY_SLOTS])
+                .AddSampledImages((*inputs)[i % LSFG_HISTORY_SLOTS])
+                .AddSampledImage(previous_gamma)
+                .AddSampledImage(previous1)
+                .AddStorageImage(temp2[0])
+                .Build(device);
+        }
+        LsfgDescriptorWriter(pass.descriptor_sets[0])
+            .AddSampler(sampler)
+            .AddSampledImages(temp1)
+            .AddStorageImages(temp2)
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[1])
+            .AddSampler(sampler)
+            .AddSampledImages(temp2)
+            .AddStorageImage(temp1[0])
+            .AddStorageImage(temp1[1])
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[2])
+            .AddSampler(sampler)
+            .AddSampledImage(temp1[0])
+            .AddSampledImage(temp1[1])
+            .AddStorageImages(temp2)
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[3])
+            .AddUniformBuffer(buffer, LsfgResources::BufferSize())
+            .AddSampler(sampler)
+            .AddSampler(edge_sampler)
+            .AddSampledImages(temp2)
+            .AddSampledImage(previous_gamma)
+            .AddSampledImage(*flow_input)
+            .AddStorageImage(out_image1)
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[4])
+            .AddSampler(sampler)
+            .AddSampledImage(temp2[0])
+            .AddStorageImage(temp1[0])
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[5])
+            .AddSampler(sampler)
+            .AddSampledImage(temp1[0])
+            .AddStorageImage(temp2[0])
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[6])
+            .AddSampler(sampler)
+            .AddSampledImage(temp2[0])
+            .AddStorageImage(temp1[0])
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[7])
+            .AddUniformBuffer(buffer, LsfgResources::BufferSize())
+            .AddSampler(sampler)
+            .AddSampler(edge_sampler)
+            .AddSampledImage(temp1[0])
+            .AddSampledImage(previous2)
+            .AddStorageImage(out_image2)
+            .Build(device);
+    }
+}
+
+void LsfgDelta::Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count, size_t slot) {
+    const Generation& pass = generations[slot];
+
+    const VkExtent2D extent = temp1[0].Extent();
+    const u32 groups_x = GroupCount(extent.width);
+    const u32 groups_y = GroupCount(extent.height);
+
+    const size_t history = frame_count % LSFG_HISTORY_SLOTS;
+    const size_t previous_history = (frame_count + 2) % LSFG_HISTORY_SLOTS;
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll((*inputs)[previous_history])
+        .WriteToReadAll((*inputs)[history])
+        .WriteToRead(previous_gamma)
+        .ReadToWriteAll(temp1)
+        .Build();
+    passes[0].Bind(cmdbuf, pass.first_descriptor_sets[history]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp1).ReadToWriteAll(temp2).Build();
+    passes[1].Bind(cmdbuf, pass.descriptor_sets[0]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp2).ReadToWriteAll(temp1).Build();
+    passes[2].Bind(cmdbuf, pass.descriptor_sets[1]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp1).ReadToWriteAll(temp2).Build();
+    passes[3].Bind(cmdbuf, pass.descriptor_sets[2]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll(temp2)
+        .WriteToRead(previous_gamma)
+        .WriteToRead(*flow_input)
+        .ReadToWrite(out_image1)
+        .Build();
+    passes[4].Bind(cmdbuf, pass.descriptor_sets[3]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll((*inputs)[previous_history])
+        .WriteToReadAll((*inputs)[history])
+        .WriteToRead(previous_gamma)
+        .WriteToRead(previous1)
+        .ReadToWriteAll(temp2)
+        .Build();
+    passes[5].Bind(cmdbuf, pass.sixth_descriptor_sets[history]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll(temp2)
+        .ReadToWrite(temp1[0])
+        .ReadToWrite(temp1[1])
+        .Build();
+    passes[6].Bind(cmdbuf, pass.descriptor_sets[4]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToRead(temp1[0])
+        .WriteToRead(temp1[1])
+        .ReadToWriteAll(temp2)
+        .Build();
+    passes[7].Bind(cmdbuf, pass.descriptor_sets[5]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll(temp2)
+        .ReadToWrite(temp1[0])
+        .ReadToWrite(temp1[1])
+        .Build();
+    passes[8].Bind(cmdbuf, pass.descriptor_sets[6]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToRead(temp1[0])
+        .WriteToRead(temp1[1])
+        .WriteToRead(previous2)
+        .ReadToWrite(out_image2)
+        .Build();
+    passes[9].Bind(cmdbuf, pass.descriptor_sets[7]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_delta.h

@@ -0,0 +1,63 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
+
+namespace Vulkan {
+
+class Device;
+class LsfgShaders;
+
+constexpr size_t LSFG_DELTA_STAGES = 10;
+constexpr size_t LSFG_DELTA_TEMPS = 3;
+
+class LsfgDelta {
+public:
+    LsfgDelta() = default;
+    LsfgDelta(const Device& device, MemoryAllocator& memory_allocator, const LsfgShaders& shaders,
+              LsfgResources& resources, vk::DescriptorPool& descriptor_pool,
+              LsfgImageHistory& inputs, LsfgImage& flow_input, LsfgImage* previous_gamma,
+              LsfgImage* previous1, LsfgImage* previous2);
+
+    void Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count, size_t slot);
+
+    [[nodiscard]] LsfgImage& Output1() {
+        return out_image1;
+    }
+
+    [[nodiscard]] LsfgImage& Output2() {
+        return out_image2;
+    }
+
+private:
+    struct Generation {
+        std::array<VkDescriptorSet, LSFG_HISTORY_SLOTS> first_descriptor_sets{};
+        std::array<VkDescriptorSet, LSFG_HISTORY_SLOTS> sixth_descriptor_sets{};
+        std::array<VkDescriptorSet, LSFG_DELTA_STAGES - 2> descriptor_sets{};
+    };
+
+    LsfgImageHistory* inputs{};
+    LsfgImage* flow_input{};
+    LsfgImage* previous_gamma{};
+    LsfgImage* previous1{};
+    LsfgImage* previous2{};
+
+    std::array<LsfgPass, LSFG_DELTA_STAGES> passes;
+    std::array<Generation, LSFG_GENERATION_SLOTS> generations{};
+    vk::DescriptorSets owned_sets;
+
+    std::array<LsfgImage, LSFG_DELTA_TEMPS> temp1;
+    LsfgImagePair temp2;
+    LsfgImage out_image1;
+    LsfgImage out_image2;
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_gamma.cpp

@@ -0,0 +1,185 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <vector>
+
+#include "video_core/frame_gen/lossless_dll.h"
+#include "video_core/renderer_vulkan/present/lsfg_gamma.h"
+#include "video_core/renderer_vulkan/present/lsfg_shaders.h"
+#include "video_core/renderer_vulkan/present/util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+
+namespace Vulkan {
+
+namespace {
+
+constexpr u32 DISPATCH_TILE_SHIFT = 3;
+
+[[nodiscard]] u32 GroupCount(u32 size) {
+    return (size + (1u << DISPATCH_TILE_SHIFT) - 1) >> DISPATCH_TILE_SHIFT;
+}
+
+} // Anonymous namespace
+
+LsfgGamma::LsfgGamma(const Device& device, MemoryAllocator& memory_allocator,
+                     const LsfgShaders& shaders, LsfgResources& resources,
+                     vk::DescriptorPool& descriptor_pool, LsfgImageHistory& inputs_,
+                     LsfgImage& flow_input_, LsfgImage* previous_)
+    : inputs{&inputs_}, flow_input{&flow_input_}, previous{previous_} {
+    using namespace VideoCore::FrameGen::PerformanceShader;
+
+    passes[0] = LsfgPass(device, shaders, GAMMA[0],
+                         {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {5, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {3, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[1] = LsfgPass(device, shaders, GAMMA[1],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {3, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[2] = LsfgPass(device, shaders, GAMMA[2],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[3] = LsfgPass(device, shaders, GAMMA[3],
+                         {{1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+    passes[4] = LsfgPass(device, shaders, GAMMA[4],
+                         {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                          {2, VK_DESCRIPTOR_TYPE_SAMPLER},
+                          {4, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                          {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+
+    const VkExtent2D extent = (*inputs)[0][0].Extent();
+    for (auto& image : temp1) {
+        image = LsfgImage(device, memory_allocator, extent);
+    }
+    for (auto& image : temp2) {
+        image = LsfgImage(device, memory_allocator, extent);
+    }
+    out_image = LsfgImage(device, memory_allocator, extent, LSFG_MOTION_FORMAT);
+
+    std::vector<VkDescriptorSetLayout> layouts;
+    for (size_t slot = 0; slot < LSFG_GENERATION_SLOTS; ++slot) {
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            layouts.push_back(passes[0].SetLayout());
+        }
+        for (size_t i = 1; i < LSFG_GAMMA_STAGES; ++i) {
+            layouts.push_back(passes[i].SetLayout());
+        }
+    }
+    owned_sets = CreateWrappedDescriptorSets(descriptor_pool, layouts);
+
+    const VkSampler sampler = resources.GetSampler();
+    const VkSampler border_sampler = resources.GetSampler(
+        VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_COMPARE_OP_NEVER, true);
+    const VkSampler edge_sampler =
+        resources.GetSampler(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_COMPARE_OP_ALWAYS, false);
+
+    size_t next = 0;
+    for (size_t slot = 0; slot < LSFG_GENERATION_SLOTS; ++slot) {
+        Generation& pass = generations[slot];
+        const VkBuffer buffer =
+            resources.GetBuffer(LsfgSlotTimestamp(slot), previous == nullptr);
+
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            pass.first_descriptor_sets[i] = owned_sets[next++];
+        }
+        for (size_t i = 0; i < LSFG_GAMMA_STAGES - 1; ++i) {
+            pass.descriptor_sets[i] = owned_sets[next++];
+        }
+
+        for (size_t i = 0; i < LSFG_HISTORY_SLOTS; ++i) {
+            LsfgDescriptorWriter(pass.first_descriptor_sets[i])
+                .AddUniformBuffer(buffer, LsfgResources::BufferSize())
+                .AddSampler(border_sampler)
+                .AddSampler(edge_sampler)
+                .AddSampledImages((*inputs)[(i + 2) % LSFG_HISTORY_SLOTS])
+                .AddSampledImages((*inputs)[i % LSFG_HISTORY_SLOTS])
+                .AddSampledImage(previous)
+                .AddStorageImages(temp1)
+                .Build(device);
+        }
+        LsfgDescriptorWriter(pass.descriptor_sets[0])
+            .AddSampler(sampler)
+            .AddSampledImages(temp1)
+            .AddStorageImages(temp2)
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[1])
+            .AddSampler(sampler)
+            .AddSampledImages(temp2)
+            .AddStorageImage(temp1[0])
+            .AddStorageImage(temp1[1])
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[2])
+            .AddSampler(sampler)
+            .AddSampledImage(temp1[0])
+            .AddSampledImage(temp1[1])
+            .AddStorageImages(temp2)
+            .Build(device);
+        LsfgDescriptorWriter(pass.descriptor_sets[3])
+            .AddUniformBuffer(buffer, LsfgResources::BufferSize())
+            .AddSampler(sampler)
+            .AddSampler(edge_sampler)
+            .AddSampledImages(temp2)
+            .AddSampledImage(previous)
+            .AddSampledImage(*flow_input)
+            .AddStorageImage(out_image)
+            .Build(device);
+    }
+}
+
+void LsfgGamma::Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count, size_t slot) {
+    const Generation& pass = generations[slot];
+
+    const VkExtent2D extent = temp1[0].Extent();
+    const u32 groups_x = GroupCount(extent.width);
+    const u32 groups_y = GroupCount(extent.height);
+
+    const size_t history = frame_count % LSFG_HISTORY_SLOTS;
+    const size_t previous_history = (frame_count + 2) % LSFG_HISTORY_SLOTS;
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll((*inputs)[previous_history])
+        .WriteToReadAll((*inputs)[history])
+        .WriteToRead(previous)
+        .ReadToWriteAll(temp1)
+        .Build();
+    passes[0].Bind(cmdbuf, pass.first_descriptor_sets[history]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf).WriteToReadAll(temp1).ReadToWriteAll(temp2).Build();
+    passes[1].Bind(cmdbuf, pass.descriptor_sets[0]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll(temp2)
+        .ReadToWrite(temp1[0])
+        .ReadToWrite(temp1[1])
+        .Build();
+    passes[2].Bind(cmdbuf, pass.descriptor_sets[1]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToRead(temp1[0])
+        .WriteToRead(temp1[1])
+        .ReadToWriteAll(temp2)
+        .Build();
+    passes[3].Bind(cmdbuf, pass.descriptor_sets[2]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll(temp2)
+        .WriteToRead(previous)
+        .WriteToRead(*flow_input)
+        .ReadToWrite(out_image)
+        .Build();
+    passes[4].Bind(cmdbuf, pass.descriptor_sets[3]);
+    cmdbuf.Dispatch(groups_x, groups_y, 1);
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_gamma.h

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
+
+namespace Vulkan {
+
+class Device;
+class LsfgShaders;
+
+constexpr size_t LSFG_GAMMA_STAGES = 5;
+constexpr size_t LSFG_GAMMA_TEMPS = 3;
+
+class LsfgGamma {
+public:
+    LsfgGamma() = default;
+    LsfgGamma(const Device& device, MemoryAllocator& memory_allocator, const LsfgShaders& shaders,
+              LsfgResources& resources, vk::DescriptorPool& descriptor_pool,
+              LsfgImageHistory& inputs, LsfgImage& flow_input, LsfgImage* previous);
+
+    void Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count, size_t slot);
+
+    [[nodiscard]] LsfgImage& Output() {
+        return out_image;
+    }
+
+private:
+    struct Generation {
+        std::array<VkDescriptorSet, LSFG_HISTORY_SLOTS> first_descriptor_sets{};
+        std::array<VkDescriptorSet, LSFG_GAMMA_STAGES - 1> descriptor_sets{};
+    };
+
+    LsfgImageHistory* inputs{};
+    LsfgImage* flow_input{};
+    LsfgImage* previous{};
+
+    std::array<LsfgPass, LSFG_GAMMA_STAGES> passes;
+    std::array<Generation, LSFG_GENERATION_SLOTS> generations{};
+    vk::DescriptorSets owned_sets;
+
+    std::array<LsfgImage, LSFG_GAMMA_TEMPS> temp1;
+    LsfgImagePair temp2;
+    LsfgImage out_image;
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_generate.cpp

@@ -0,0 +1,130 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <vector>
+
+#include "video_core/frame_gen/lossless_dll.h"
+#include "video_core/renderer_vulkan/present/lsfg_generate.h"
+#include "video_core/renderer_vulkan/present/lsfg_shaders.h"
+#include "video_core/renderer_vulkan/present/util.h"
+#include "video_core/vulkan_common/vulkan_device.h"
+
+namespace Vulkan {
+
+namespace {
+
+constexpr u32 DISPATCH_TILE_SHIFT = 4;
+
+[[nodiscard]] u32 GroupCount(u32 size) {
+    return (size + (1u << DISPATCH_TILE_SHIFT) - 1) >> DISPATCH_TILE_SHIFT;
+}
+
+VkImageMemoryBarrier MakeTargetBarrier(VkImage image, VkAccessFlags src_access,
+                                       VkAccessFlags dst_access, VkImageLayout old_layout) {
+    return VkImageMemoryBarrier{
+        .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        .pNext = nullptr,
+        .srcAccessMask = src_access,
+        .dstAccessMask = dst_access,
+        .oldLayout = old_layout,
+        .newLayout = VK_IMAGE_LAYOUT_GENERAL,
+        .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
+        .image = image,
+        .subresourceRange{
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .baseMipLevel = 0,
+            .levelCount = 1,
+            .baseArrayLayer = 0,
+            .layerCount = 1,
+        },
+    };
+}
+
+} // Anonymous namespace
+
+LsfgGenerate::LsfgGenerate(const Device& device, const LsfgShaders& shaders,
+                           LsfgResources& resources, vk::DescriptorPool& descriptor_pool,
+                           LsfgImagePair& frames_, LsfgImage& motion_, LsfgImage& detail1_,
+                           LsfgImage& detail2_)
+    : frames{&frames_}, motion{&motion_}, detail1{&detail1_}, detail2{&detail2_} {
+    using namespace VideoCore::FrameGen::PerformanceShader;
+
+    pass = LsfgPass(device, shaders, GENERATE,
+                    {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                     {2, VK_DESCRIPTOR_TYPE_SAMPLER},
+                     {5, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                     {1, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+
+    sampler = resources.GetSampler();
+    edge_sampler =
+        resources.GetSampler(VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_COMPARE_OP_ALWAYS, false);
+
+    const std::vector<VkDescriptorSetLayout> layouts(
+        LSFG_GENERATION_SLOTS * LSFG_MAX_TARGETS * 2, pass.SetLayout());
+    owned_sets = CreateWrappedDescriptorSets(descriptor_pool, layouts);
+
+    size_t next = 0;
+    for (size_t slot = 0; slot < LSFG_GENERATION_SLOTS; ++slot) {
+        Generation& target = generations[slot];
+        target.buffer = resources.GetBuffer(LsfgSlotTimestamp(slot));
+
+        for (auto& entry : target.targets) {
+            for (auto& set : entry.descriptor_sets) {
+                set = owned_sets[next++];
+            }
+        }
+    }
+}
+
+void LsfgGenerate::SetTarget(const Device& device, size_t slot, u32 target, VkImageView view) {
+    Target& entry = generations[slot].targets[target];
+    if (entry.view == view) {
+        return;
+    }
+    entry.view = view;
+
+    for (size_t i = 0; i < entry.descriptor_sets.size(); ++i) {
+        LsfgDescriptorWriter(entry.descriptor_sets[i])
+            .AddUniformBuffer(generations[slot].buffer, LsfgResources::BufferSize())
+            .AddSampler(sampler)
+            .AddSampler(edge_sampler)
+            .AddSampledImage((*frames)[1 - i])
+            .AddSampledImage((*frames)[i])
+            .AddSampledImage(*motion)
+            .AddSampledImage(*detail1)
+            .AddSampledImage(*detail2)
+            .AddStorageView(view)
+            .Build(device);
+    }
+}
+
+void LsfgGenerate::Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count, size_t slot, u32 target,
+                            VkImage image, VkExtent2D extent) {
+    const Target& entry = generations[slot].targets[target];
+
+    LsfgBarriers(cmdbuf)
+        .WriteToReadAll(*frames)
+        .WriteToRead(*motion)
+        .WriteToRead(*detail1)
+        .WriteToRead(*detail2)
+        .DiscardToWrite(image)
+        .Build();
+
+    pass.Bind(cmdbuf, entry.descriptor_sets[frame_count % entry.descriptor_sets.size()]);
+    cmdbuf.Dispatch(GroupCount(extent.width), GroupCount(extent.height), 1);
+
+    const std::array after{MakeTargetBarrier(
+        image, VK_ACCESS_SHADER_WRITE_BIT,
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_READ_BIT,
+        VK_IMAGE_LAYOUT_GENERAL)};
+    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+                           VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
+                               VK_PIPELINE_STAGE_TRANSFER_BIT,
+                           0, {}, {}, after);
+}
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_generate.h

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "common/common_types.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
+
+namespace Vulkan {
+
+class Device;
+class LsfgShaders;
+
+class LsfgGenerate {
+public:
+    LsfgGenerate() = default;
+    LsfgGenerate(const Device& device, const LsfgShaders& shaders, LsfgResources& resources,
+                 vk::DescriptorPool& descriptor_pool, LsfgImagePair& frames, LsfgImage& motion,
+                 LsfgImage& detail1, LsfgImage& detail2);
+
+    void SetTarget(const Device& device, size_t slot, u32 target, VkImageView view);
+
+    void Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count, size_t slot, u32 target,
+                  VkImage image, VkExtent2D extent);
+
+private:
+    struct Target {
+        std::array<VkDescriptorSet, 2> descriptor_sets{};
+        VkImageView view{};
+    };
+
+    struct Generation {
+        std::array<Target, LSFG_MAX_TARGETS> targets{};
+        VkBuffer buffer{};
+    };
+
+    LsfgImagePair* frames{};
+    LsfgImage* motion{};
+    LsfgImage* detail1{};
+    LsfgImage* detail2{};
+    VkSampler sampler{};
+    VkSampler edge_sampler{};
+
+    LsfgPass pass;
+    std::array<Generation, LSFG_GENERATION_SLOTS> generations{};
+    vk::DescriptorSets owned_sets;
+};
+
+} // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_mipmaps.cpp

@@ -1,212 +1,81 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 #include <algorithm>
-#include <cstring>
+#include <vector>
 
 #include "video_core/frame_gen/lossless_dll.h"
 #include "video_core/renderer_vulkan/present/lsfg_mipmaps.h"
 #include "video_core/renderer_vulkan/present/lsfg_shaders.h"
 #include "video_core/renderer_vulkan/present/util.h"
-#include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 
 namespace Vulkan {
 
 namespace {
 
-constexpr VkFormat FLOW_FORMAT = VK_FORMAT_R8_UNORM;
 constexpr u32 DISPATCH_TILE_SHIFT = 6;
-constexpr size_t DESCRIPTOR_SET_COUNT = 2;
 
-struct LsfgConstants {
-    std::array<u32, 2> input_offset;
-    u32 first_iter;
-    u32 first_iter_s;
-    u32 advanced_color_kind;
-    u32 hdr_support;
-    f32 resolution_inv_scale;
-    f32 timestamp;
-    f32 ui_threshold;
-    std::array<u32, 3> padding;
-};
-static_assert(sizeof(LsfgConstants) == 48);
-
-constexpr std::array<VkDescriptorType, 3 + LSFG_MIP_LEVELS> MIPMAPS_BINDINGS{
-    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_SAMPLER,
-    VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,  VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,  VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,  VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-    VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,  VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
-};
-
-vk::Sampler CreateFlowSampler(const Device& device) {
-    return device.GetLogical().CreateSampler(VkSamplerCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .magFilter = VK_FILTER_LINEAR,
-        .minFilter = VK_FILTER_LINEAR,
-        .mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
-        .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-        .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-        .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
-        .mipLodBias = 0.0f,
-        .anisotropyEnable = VK_FALSE,
-        .maxAnisotropy = 0.0f,
-        .compareEnable = VK_FALSE,
-        .compareOp = VK_COMPARE_OP_NEVER,
-        .minLod = 0.0f,
-        .maxLod = VK_LOD_CLAMP_NONE,
-        .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
-        .unnormalizedCoordinates = VK_FALSE,
-    });
+[[nodiscard]] u32 GroupCount(u32 size) {
+    return (size + (1u << DISPATCH_TILE_SHIFT) - 1) >> DISPATCH_TILE_SHIFT;
 }
 
 } // Anonymous namespace
 
-LsfgMipmaps::LsfgMipmaps(const Device& device, MemoryAllocator& memory_allocator_,
-                         const LsfgShaders& shaders, VkExtent2D input_extent, f32 flow_scale)
-    : memory_allocator{memory_allocator_} {
+LsfgMipmaps::LsfgMipmaps(const Device& device, MemoryAllocator& memory_allocator,
+                         const LsfgShaders& shaders, LsfgResources& resources,
+                         vk::DescriptorPool& descriptor_pool, LsfgImagePair& frames_,
+                         f32 flow_scale)
+    : frames{&frames_} {
+    using namespace VideoCore::FrameGen::PerformanceShader;
+
+    pass = LsfgPass(device, shaders, MIPMAPS,
+                    {{1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER},
+                     {1, VK_DESCRIPTOR_TYPE_SAMPLER},
+                     {1, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE},
+                     {LSFG_MIP_LEVELS, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE}});
+
+    const VkExtent2D input_extent = (*frames)[0].Extent();
     flow_extent = VkExtent2D{
         .width = std::max(1u, static_cast<u32>(static_cast<f32>(input_extent.width) * flow_scale)),
         .height = std::max(1u, static_cast<u32>(static_cast<f32>(input_extent.height) * flow_scale)),
     };
 
-    CreateImages(device);
-    CreateUniformBuffer(flow_scale);
-
-    sampler = CreateFlowSampler(device);
-    descriptor_pool = CreateWrappedDescriptorPool(
-        device, DESCRIPTOR_SET_COUNT * MIPMAPS_BINDINGS.size(), DESCRIPTOR_SET_COUNT,
-        {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_SAMPLER,
-         VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE});
-    descriptor_set_layout = CreateWrappedDescriptorSetLayout(
-        device, std::span<const VkDescriptorType>{MIPMAPS_BINDINGS}, VK_SHADER_STAGE_COMPUTE_BIT);
-
-    const std::vector<VkDescriptorSetLayout> layouts(DESCRIPTOR_SET_COUNT,
-                                                     *descriptor_set_layout);
-    descriptor_sets = CreateWrappedDescriptorSets(descriptor_pool, layouts);
-
-    pipeline_layout = CreateWrappedPipelineLayout(device, descriptor_set_layout);
-    pipeline = CreateWrappedComputePipeline(
-        device, pipeline_layout, shaders.Get(VideoCore::FrameGen::PerformanceShader::MIPMAPS));
-}
-
-VkExtent2D LsfgMipmaps::GetLevelExtent(size_t level) const {
-    return VkExtent2D{
-        .width = std::max(1u, flow_extent.width >> level),
-        .height = std::max(1u, flow_extent.height >> level),
-    };
-}
-
-void LsfgMipmaps::CreateImages(const Device& device) {
     for (size_t i = 0; i < LSFG_MIP_LEVELS; ++i) {
-        images[i] = CreateWrappedImage(memory_allocator, GetLevelExtent(i), FLOW_FORMAT);
-        image_views[i] = CreateWrappedImageView(device, images[i], FLOW_FORMAT);
-    }
-}
-
-void LsfgMipmaps::CreateUniformBuffer(f32 flow_scale) {
-    uniform_buffer = CreateWrappedBuffer(memory_allocator, sizeof(LsfgConstants),
-                                         MemoryUsage::Upload);
-
-    const LsfgConstants constants{
-        .input_offset = {0, 0},
-        .first_iter = 0,
-        .first_iter_s = 0,
-        .advanced_color_kind = 0,
-        .hdr_support = 0,
-        .resolution_inv_scale = 1.0f / flow_scale,
-        .timestamp = 0.0f,
-        .ui_threshold = 0.5f,
-        .padding = {0, 0, 0},
-    };
-
-    const std::span<u8> mapped = uniform_buffer.Mapped();
-    std::memcpy(mapped.data(), &constants, sizeof(constants));
-    uniform_buffer.Flush();
-}
-
-void LsfgMipmaps::Dispatch(const Device& device, Scheduler& scheduler, VkImageView current_view,
-                           u64 frame_count) {
-    const size_t set_index = frame_count % DESCRIPTOR_SET_COUNT;
-    const VkDescriptorSet set = descriptor_sets[set_index];
-
-    const VkDescriptorBufferInfo buffer_info{
-        .buffer = *uniform_buffer,
-        .offset = 0,
-        .range = sizeof(LsfgConstants),
-    };
-    const VkDescriptorImageInfo sampler_info{
-        .sampler = *sampler,
-        .imageView = VK_NULL_HANDLE,
-        .imageLayout = VK_IMAGE_LAYOUT_UNDEFINED,
-    };
-    const VkDescriptorImageInfo sampled_info{
-        .sampler = VK_NULL_HANDLE,
-        .imageView = current_view,
-        .imageLayout = VK_IMAGE_LAYOUT_GENERAL,
-    };
-    std::array<VkDescriptorImageInfo, LSFG_MIP_LEVELS> storage_infos{};
-    for (size_t i = 0; i < LSFG_MIP_LEVELS; ++i) {
-        storage_infos[i] = VkDescriptorImageInfo{
-            .sampler = VK_NULL_HANDLE,
-            .imageView = *image_views[i],
-            .imageLayout = VK_IMAGE_LAYOUT_GENERAL,
+        const VkExtent2D level_extent{
+            .width = flow_extent.width >> i,
+            .height = flow_extent.height >> i,
         };
+        out_images[i] = LsfgImage(device, memory_allocator, level_extent, LSFG_FLOW_FORMAT);
     }
 
-    std::vector<VkWriteDescriptorSet> writes;
-    writes.reserve(MIPMAPS_BINDINGS.size());
-    const auto push = [&](u32 binding, VkDescriptorType type,
-                          const VkDescriptorImageInfo* image_info,
-                          const VkDescriptorBufferInfo* buf_info) {
-        writes.push_back(VkWriteDescriptorSet{
-            .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
-            .pNext = nullptr,
-            .dstSet = set,
-            .dstBinding = binding,
-            .dstArrayElement = 0,
-            .descriptorCount = 1,
-            .descriptorType = type,
-            .pImageInfo = image_info,
-            .pBufferInfo = buf_info,
-            .pTexelBufferView = nullptr,
-        });
-    };
+    const std::vector<VkDescriptorSetLayout> layouts(descriptor_sets.size(), pass.SetLayout());
+    owned_sets = CreateWrappedDescriptorSets(descriptor_pool, layouts);
 
-    push(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, nullptr, &buffer_info);
-    push(1, VK_DESCRIPTOR_TYPE_SAMPLER, &sampler_info, nullptr);
-    push(2, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &sampled_info, nullptr);
-    for (u32 i = 0; i < LSFG_MIP_LEVELS; ++i) {
-        push(3 + i, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &storage_infos[i], nullptr);
+    const VkSampler sampler = resources.GetSampler();
+    const VkBuffer buffer = resources.GetBuffer();
+
+    for (size_t i = 0; i < descriptor_sets.size(); ++i) {
+        descriptor_sets[i] = owned_sets[i];
+        LsfgDescriptorWriter(descriptor_sets[i])
+            .AddUniformBuffer(buffer, LsfgResources::BufferSize())
+            .AddSampler(sampler)
+            .AddSampledImage((*frames)[i])
+            .AddStorageImages(out_images)
+            .Build(device);
     }
+}
 
-    device.GetLogical().UpdateDescriptorSets(writes, {});
+void LsfgMipmaps::Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count) {
+    const size_t slot = frame_count % descriptor_sets.size();
 
-    const u32 groups_x = (flow_extent.width + (1u << DISPATCH_TILE_SHIFT) - 1) >>
-                         DISPATCH_TILE_SHIFT;
-    const u32 groups_y = (flow_extent.height + (1u << DISPATCH_TILE_SHIFT) - 1) >>
-                         DISPATCH_TILE_SHIFT;
+    LsfgBarriers(cmdbuf).WriteToRead((*frames)[slot]).ReadToWriteAll(out_images).Build();
 
-    std::array<VkImage, LSFG_MIP_LEVELS> raw_images{};
-    for (size_t i = 0; i < LSFG_MIP_LEVELS; ++i) {
-        raw_images[i] = *images[i];
-    }
-
-    scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([raw_images, set, groups_x, groups_y, layout = *pipeline_layout,
-                      compute_pipeline = *pipeline](vk::CommandBuffer cmdbuf) {
-        for (const VkImage image : raw_images) {
-            TransitionImageLayout(cmdbuf, image, VK_IMAGE_LAYOUT_GENERAL,
-                                  VK_IMAGE_LAYOUT_UNDEFINED);
-        }
-
-        cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, compute_pipeline);
-        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, layout, 0, set, {});
-        cmdbuf.Dispatch(groups_x, groups_y, 1);
-    });
+    pass.Bind(cmdbuf, descriptor_sets[slot]);
+    cmdbuf.Dispatch(GroupCount(flow_extent.width), GroupCount(flow_extent.height), 1);
 }
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_mipmaps.h

@@ -1,57 +1,45 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+// SPDX-FileCopyrightText: Copyright 2025 lsfg-vk
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 #pragma once
 
 #include <array>
 
 #include "common/common_types.h"
-#include "video_core/vulkan_common/vulkan_memory_allocator.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
 
 namespace Vulkan {
 
 class Device;
 class LsfgShaders;
-class Scheduler;
 
 constexpr size_t LSFG_MIP_LEVELS = 7;
 
 class LsfgMipmaps {
 public:
-    explicit LsfgMipmaps(const Device& device, MemoryAllocator& memory_allocator,
-                         const LsfgShaders& shaders, VkExtent2D input_extent, f32 flow_scale);
+    LsfgMipmaps() = default;
+    LsfgMipmaps(const Device& device, MemoryAllocator& memory_allocator, const LsfgShaders& shaders,
+                LsfgResources& resources, vk::DescriptorPool& descriptor_pool,
+                LsfgImagePair& frames, f32 flow_scale);
 
-    void Dispatch(const Device& device, Scheduler& scheduler, VkImageView current_view,
-                  u64 frame_count);
+    void Dispatch(vk::CommandBuffer cmdbuf, u64 frame_count);
 
-    [[nodiscard]] VkImageView GetLevelView(size_t level) const {
-        return *image_views[level];
+    [[nodiscard]] LsfgImage& Output(size_t level) {
+        return out_images[level];
     }
 
-    [[nodiscard]] VkImage GetLevelImage(size_t level) const {
-        return *images[level];
-    }
-
-    [[nodiscard]] VkExtent2D GetLevelExtent(size_t level) const;
-
 private:
-    void CreateImages(const Device& device);
-    void CreateUniformBuffer(f32 flow_scale);
+    LsfgImagePair* frames{};
+
+    LsfgPass pass;
+    std::array<VkDescriptorSet, 2> descriptor_sets{};
+    vk::DescriptorSets owned_sets;
 
-    MemoryAllocator& memory_allocator;
     VkExtent2D flow_extent{};
-
-    vk::Buffer uniform_buffer;
-    vk::Sampler sampler;
-    vk::DescriptorPool descriptor_pool;
-    vk::DescriptorSetLayout descriptor_set_layout;
-    vk::DescriptorSets descriptor_sets;
-    vk::PipelineLayout pipeline_layout;
-    vk::Pipeline pipeline;
-
-    std::array<vk::Image, LSFG_MIP_LEVELS> images;
-    std::array<vk::ImageView, LSFG_MIP_LEVELS> image_views;
+    std::array<LsfgImage, LSFG_MIP_LEVELS> out_images;
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/present/lsfg_shaders.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include "common/settings.h"
 #include "video_core/frame_gen/lossless_dll.h"
 #include "video_core/renderer_vulkan/present/lsfg_shaders.h"
 #include "video_core/renderer_vulkan/present/util.h"
@@ -9,12 +10,16 @@
 namespace Vulkan {
 
 LsfgShaders::LsfgShaders(const Device& device) {
-    if (!device.IsVulkanMemoryModelSupported()) {
+    if (!device.IsVulkanMemoryModelSupported() || !device.HasNullDescriptor()) {
         return;
     }
 
+    const bool prefer_fp16 =
+        Settings::values.frame_gen_fp16.GetValue() && device.IsFloat16Supported();
+
     VideoCore::FrameGen::ShaderModules code;
-    if (VideoCore::FrameGen::LoadShaderModules(code) != VideoCore::FrameGen::LosslessStatus::Ok) {
+    if (VideoCore::FrameGen::LoadShaderModules(code, prefer_fp16) !=
+        VideoCore::FrameGen::LosslessStatus::Ok) {
         return;
     }
 

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -49,6 +49,21 @@ constexpr VkExtent2D CaptureImageSize{
     .height = VideoCore::Capture::LinearHeight,
 };
 
+[[nodiscard]] VkExtent2D GuestExtent(std::span<const Tegra::FramebufferConfig> framebuffers) {
+    if (framebuffers.empty()) {
+        return VkExtent2D{};
+    }
+
+    const auto& framebuffer = framebuffers.front();
+    if (framebuffer.crop_rect.IsEmpty()) {
+        return VkExtent2D{.width = framebuffer.width, .height = framebuffer.height};
+    }
+    return VkExtent2D{
+        .width = static_cast<u32>(framebuffer.crop_rect.GetWidth()),
+        .height = static_cast<u32>(framebuffer.crop_rect.GetHeight()),
+    };
+}
+
 constexpr VkExtent3D CaptureImageExtent{
     .width = VideoCore::Capture::LinearWidth,
     .height = VideoCore::Capture::LinearHeight,
@@ -193,11 +208,23 @@ void RendererVulkan::Composite(std::span<const Tegra::FramebufferConfig> framebu
                                render_window.GetFramebufferLayout(), swapchain.GetImageCount(),
                                swapchain.GetImageViewFormat());
 
-    frame_gen.Process(device, frame);
+    void(frame_gen.WantedGenerations(present_manager.MaxExtraFrames()));
+
+    frame_gen.Process(device, frame, swapchain.GetImageFormat(), GuestExtent(framebuffers));
+
+    const size_t generated_frames = frame_gen.GeneratedFrameCount();
+    for (size_t generation = 0; generation < generated_frames; ++generation) {
+        Frame* generated = present_manager.GetRenderFrame();
+        blit_swapchain.PrepareFrame(device, generated, render_window.GetFramebufferLayout());
+        frame_gen.GenerateInto(device, generated, generation);
+        scheduler.Flush(*generated->render_ready);
+        present_manager.Present(generated);
+    }
 
     scheduler.Flush(*frame->render_ready);
 
     present_manager.Present(frame);
+    scheduler.DispatchWork();
 
     gpu.RendererFrameEndNotify();
     rasterizer.TickFrame();

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -85,6 +85,17 @@ void BlitScreen::SetWindowAdaptPass(const Device& device) {
     }
 }
 
+void BlitScreen::PrepareFrame(const Device& device, Frame* frame,
+                              const Layout::FramebufferLayout& layout) {
+    if (!window_adapt || (frame->width == layout.width && frame->height == layout.height)) {
+        return;
+    }
+
+    WaitIdle(device);
+    present_manager.RecreateFrame(frame, layout.width, layout.height, swapchain_view_format,
+                                  window_adapt->GetRenderPass());
+}
+
 void BlitScreen::DrawToFrame(const Device& device, RasterizerVulkan& rasterizer, Frame* frame,
                              std::span<const Tegra::FramebufferConfig> framebuffers,
                              const Layout::FramebufferLayout& layout,

src/video_core/renderer_vulkan/vk_blit_screen.h

@@ -60,6 +60,8 @@ public:
                      const Layout::FramebufferLayout& layout, size_t current_swapchain_image_count,
                      VkFormat current_swapchain_view_format);
 
+    void PrepareFrame(const Device& device, Frame* frame, const Layout::FramebufferLayout& layout);
+
     [[nodiscard]] vk::Framebuffer CreateFramebuffer(const Device& device, const Layout::FramebufferLayout& layout,
                                                     VkImageView image_view,
                                                     VkFormat current_view_format);

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -7,6 +7,7 @@
 #include "common/settings.h"
 #include "common/thread.h"
 #include "core/frontend/emu_window.h"
+#include "video_core/renderer_vulkan/present/lsfg_common.h"
 #include "video_core/renderer_vulkan/vk_present_manager.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_swapchain.h"
@@ -19,6 +20,17 @@ namespace Vulkan {
 
 namespace {
 
+constexpr size_t MAX_FRAMES_IN_FLIGHT = 7;
+static_assert(MAX_FRAMES_IN_FLIGHT <= LSFG_MAX_TARGETS);
+
+bool CanStoreToFrame(const vk::PhysicalDevice& physical_device, VkFormat format) {
+    if (!Settings::values.frame_gen.GetValue()) {
+        return false;
+    }
+    const VkFormatProperties props{physical_device.GetFormatProperties(format)};
+    return (props.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) != 0;
+}
+
 bool CanBlitToSwapchain(const vk::PhysicalDevice& physical_device, VkFormat format) {
     const VkFormatProperties props{physical_device.GetFormatProperties(format)};
     return (props.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT);
@@ -110,6 +122,7 @@ PresentManager::PresentManager(const vk::Instance& instance_,
     , swapchain{swapchain_}
     , surface{surface_}
     , blit_supported{CanBlitToSwapchain(device.GetPhysical(), swapchain.GetImageViewFormat())}
+    , storage_supported{CanStoreToFrame(device.GetPhysical(), swapchain.GetImageFormat())}
     , use_present_thread{Settings::values.async_presentation.GetValue()}
 {
     SetImageCount();
@@ -127,6 +140,7 @@ PresentManager::PresentManager(const vk::Instance& instance_,
     frames.resize(image_count);
     for (u32 i = 0; i < frames.size(); i++) {
         Frame& frame = frames[i];
+        frame.index = i;
         frame.cmdbuf = vk::CommandBuffer{cmdbuffers[i], device.GetDispatchLoader()};
         frame.render_ready = dld.CreateSemaphore({
             .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
@@ -179,6 +193,10 @@ void PresentManager::Present(Frame* frame) {
     }
 }
 
+size_t PresentManager::MaxExtraFrames() const {
+    return image_count - 1;
+}
+
 void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat image_view_format,
                                    VkRenderPass rd) {
     auto& dld = device.GetLogical();
@@ -186,6 +204,9 @@ void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat
     frame->width = width;
     frame->height = height;
 
+    const VkImageUsageFlags storage_usage =
+        storage_supported ? static_cast<VkImageUsageFlags>(VK_IMAGE_USAGE_STORAGE_BIT) : 0;
+
     frame->image = memory_allocator.CreateImage({
         .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
         .pNext = nullptr,
@@ -202,8 +223,8 @@ void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat
         .arrayLayers = 1,
         .samples = VK_SAMPLE_COUNT_1_BIT,
         .tiling = VK_IMAGE_TILING_OPTIMAL,
-        .usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-                 VK_IMAGE_USAGE_SAMPLED_BIT,
+        .usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | storage_usage,
         .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
         .queueFamilyIndexCount = 0,
         .pQueueFamilyIndices = nullptr,
@@ -234,6 +255,33 @@ void PresentManager::RecreateFrame(Frame* frame, u32 width, u32 height, VkFormat
             },
     });
 
+    frame->storage_view = vk::ImageView{};
+    if (storage_supported) {
+        frame->storage_view = dld.CreateImageView({
+            .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+            .pNext = nullptr,
+            .flags = 0,
+            .image = *frame->image,
+            .viewType = VK_IMAGE_VIEW_TYPE_2D,
+            .format = swapchain.GetImageFormat(),
+            .components =
+                {
+                    .r = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .g = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .b = VK_COMPONENT_SWIZZLE_IDENTITY,
+                    .a = VK_COMPONENT_SWIZZLE_IDENTITY,
+                },
+            .subresourceRange =
+                {
+                    .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+                    .baseMipLevel = 0,
+                    .levelCount = 1,
+                    .baseArrayLayer = 0,
+                    .layerCount = 1,
+                },
+        });
+    }
+
     const VkImageView image_view{*frame->image_view};
     frame->framebuffer = dld.CreateFramebuffer({
         .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
@@ -302,7 +350,11 @@ void PresentManager::SetImageCount() {
     // We cannot have more than 7 images in flight at any given time.
     // FRAMES_IN_FLIGHT is 8, and the cache TICKS_TO_DESTROY is 8.
     // Mali drivers will give us 6.
-    image_count = std::min<size_t>(swapchain.GetImageCount(), 7);
+    const size_t generations = Settings::FrameGenMaxGenerations();
+    const size_t queued_composites = Settings::values.frame_gen_queue_target.GetValue() + 1;
+    image_count =
+        std::clamp<size_t>((generations + 1) * queued_composites, swapchain.GetImageCount(),
+                           MAX_FRAMES_IN_FLIGHT);
 }
 
 void PresentManager::CopyToSwapchain(Frame* frame) {

src/video_core/renderer_vulkan/vk_present_manager.h

@@ -28,8 +28,10 @@ class Swapchain;
 struct Frame {
     u32 width;
     u32 height;
+    u32 index;
     vk::Image image;
     vk::ImageView image_view;
+    vk::ImageView storage_view;
     vk::Framebuffer framebuffer;
     vk::CommandBuffer cmdbuf;
     vk::Semaphore render_ready;
@@ -60,6 +62,9 @@ public:
     /// Waits for the present thread to finish presenting all queued frames.
     void WaitPresent();
 
+    /// How many additional frames can be queued without stalling the render thread
+    [[nodiscard]] size_t MaxExtraFrames() const;
+
 private:
     void PresentThread(std::stop_token token);
 
@@ -90,6 +95,7 @@ private:
     std::mutex free_mutex;
     std::jthread present_thread;
     bool blit_supported;
+    bool storage_supported;
     bool use_present_thread;
     std::size_t image_count{};
 };

src/video_core/renderer_vulkan/vk_scheduler.h

@@ -146,9 +146,10 @@ public:
             frame_counter++;
             auto target_time = start_time + frame_interval * frame_counter;
             if (target_time >= now) {
+                constexpr auto spin_tail = std::chrono::milliseconds(1);
                 auto sleep_time = target_time - now;
-                if (sleep_time > std::chrono::milliseconds(15)) {
-                    std::this_thread::sleep_for(sleep_time - std::chrono::milliseconds(1));
+                if (sleep_time > spin_tail * 2) {
+                    std::this_thread::sleep_for(sleep_time - spin_tail);
                 }
                 while (std::chrono::steady_clock::now() < target_time) {
                     std::this_thread::yield();

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -48,6 +48,9 @@ static VkPresentModeKHR ChooseSwapPresentMode(bool has_imm, bool has_mailbox,
     Settings::VSyncMode setting = [has_imm, has_mailbox]() {
         // Choose Mailbox or Immediate if unlocked and those modes are supported
         const auto mode = Settings::values.vsync_mode.GetValue();
+        if (Settings::values.frame_gen.GetValue()) {
+            return mode == Settings::VSyncMode::FifoRelaxed ? mode : Settings::VSyncMode::Fifo;
+        }
         if (Settings::values.use_speed_limit.GetValue() &&
             Settings::values.current_speed_mode.GetValue() != Settings::SpeedMode::Turbo) {
             return mode;

src/yuzu/configuration/shared_widget.cpp

@@ -772,10 +772,24 @@ Builder::Builder(QWidget* parent_, bool runtime_lock_)
 
 Builder::~Builder() = default;
 
+static bool IsAndroidOnly(const Settings::BasicSetting& setting) {
+    const auto id = setting.Id();
+    return id == Settings::values.frame_gen.Id() ||
+           id == Settings::values.frame_gen_multiplier.Id() ||
+           id == Settings::values.frame_gen_flow_scale.Id() ||
+           id == Settings::values.frame_gen_fp16.Id() ||
+           id == Settings::values.frame_gen_dump_flow.Id() ||
+           id == Settings::values.emulate_bgr565.Id();
+}
+
 Widget* Builder::BuildWidget(Settings::BasicSetting* setting,
                              std::vector<std::function<void(bool)>>& apply_funcs,
                              RequestType request, bool managed, float multiplier,
                              Settings::BasicSetting* other_setting, const QString& suffix) const {
+    if (IsAndroidOnly(*setting)) {
+        return nullptr;
+    }
+
     if (!Settings::IsConfiguringGlobal() && !setting->Switchable()) {
         return nullptr;
     }