diff --git a/externals/dynarmic b/externals/dynarmic
index 4f96c63025..0118ee04f9 160000
--- a/externals/dynarmic
+++ b/externals/dynarmic
@@ -1 +1 @@
-Subproject commit 4f96c63025af34c1490c59f6729497b9866ffa35
+Subproject commit 0118ee04f90faaff951989f3c2494bc6ffb70cf1
diff --git a/src/core/hle/service/nvflinger/buffer_queue.h b/src/core/hle/service/nvflinger/buffer_queue.h
index f86e1056c4..db2e17c0c6 100644
--- a/src/core/hle/service/nvflinger/buffer_queue.h
+++ b/src/core/hle/service/nvflinger/buffer_queue.h
@@ -6,6 +6,7 @@
 
 #include <vector>
 #include <boost/optional.hpp>
+#include "common/common_funcs.h"
 #include "common/math_util.h"
 #include "common/swap.h"
 #include "core/hle/kernel/event.h"
diff --git a/src/core/settings.cpp b/src/core/settings.cpp
index a4623223d1..0da159559b 100644
--- a/src/core/settings.cpp
+++ b/src/core/settings.cpp
@@ -7,22 +7,18 @@
 #include "core/hle/service/hid/hid.h"
 #include "core/settings.h"
 #include "video_core/renderer_base.h"
-#include "video_core/video_core.h"
 
 namespace Settings {
 
 Values values = {};
 
 void Apply() {
-
     GDBStub::SetServerPort(values.gdbstub_port);
     GDBStub::ToggleServer(values.use_gdbstub);
 
-    VideoCore::g_toggle_framelimit_enabled = values.toggle_framelimit;
-
     auto& system_instance = Core::System::GetInstance();
     if (system_instance.IsPoweredOn()) {
-        system_instance.Renderer().UpdateCurrentFramebufferLayout();
+        system_instance.Renderer().RefreshBaseSettings();
     }
 
     Service::HID::ReloadInputDevices();
diff --git a/src/video_core/command_processor.h b/src/video_core/command_processor.h
index f7214ffec9..a01153e0b3 100644
--- a/src/video_core/command_processor.h
+++ b/src/video_core/command_processor.h
@@ -30,8 +30,7 @@ union CommandHeader {
 
     BitField<29, 3, SubmissionMode> mode;
 };
-static_assert(std::is_standard_layout<CommandHeader>::value == true,
-              "CommandHeader does not use standard layout");
+static_assert(std::is_standard_layout_v<CommandHeader>, "CommandHeader is not standard layout");
 static_assert(sizeof(CommandHeader) == sizeof(u32), "CommandHeader has incorrect size!");
 
 } // namespace Tegra
diff --git a/src/video_core/engines/shader_bytecode.h b/src/video_core/engines/shader_bytecode.h
index 3d4557b7e8..3e409c2e1e 100644
--- a/src/video_core/engines/shader_bytecode.h
+++ b/src/video_core/engines/shader_bytecode.h
@@ -477,8 +477,7 @@ union Instruction {
     u64 value;
 };
 static_assert(sizeof(Instruction) == 0x8, "Incorrect structure size");
-static_assert(std::is_standard_layout<Instruction>::value,
-              "Structure does not have standard layout");
+static_assert(std::is_standard_layout_v<Instruction>, "Instruction is not standard layout");
 
 class OpCode {
 public:
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index d69f06d8dc..9a455468a4 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/assert.h"
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/maxwell_compute.h"
@@ -11,6 +12,15 @@
 
 namespace Tegra {
 
+u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
+    switch (format) {
+    case PixelFormat::ABGR8:
+        return 4;
+    }
+
+    UNREACHABLE();
+}
+
 GPU::GPU(VideoCore::RasterizerInterface& rasterizer) {
     memory_manager = std::make_unique<MemoryManager>();
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(rasterizer, *memory_manager);
@@ -34,16 +44,29 @@ u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
 
     switch (format) {
     case RenderTargetFormat::RGBA32_FLOAT:
+    case RenderTargetFormat::RGBA32_UINT:
         return 16;
     case RenderTargetFormat::RGBA16_FLOAT:
     case RenderTargetFormat::RG32_FLOAT:
         return 8;
     case RenderTargetFormat::RGBA8_UNORM:
+    case RenderTargetFormat::RGBA8_SRGB:
     case RenderTargetFormat::RGB10_A2_UNORM:
     case RenderTargetFormat::BGRA8_UNORM:
+    case RenderTargetFormat::RG16_UNORM:
+    case RenderTargetFormat::RG16_SNORM:
+    case RenderTargetFormat::RG16_UINT:
+    case RenderTargetFormat::RG16_SINT:
+    case RenderTargetFormat::RG16_FLOAT:
     case RenderTargetFormat::R32_FLOAT:
     case RenderTargetFormat::R11G11B10_FLOAT:
         return 4;
+    case RenderTargetFormat::R16_UNORM:
+    case RenderTargetFormat::R16_SNORM:
+    case RenderTargetFormat::R16_UINT:
+    case RenderTargetFormat::R16_SINT:
+    case RenderTargetFormat::R16_FLOAT:
+        return 2;
     case RenderTargetFormat::R8_UNORM:
     case RenderTargetFormat::R8_UINT:
         return 1;
@@ -52,4 +75,21 @@ u32 RenderTargetBytesPerPixel(RenderTargetFormat format) {
     }
 }
 
+u32 DepthFormatBytesPerPixel(DepthFormat format) {
+    switch (format) {
+    case DepthFormat::Z32_S8_X24_FLOAT:
+        return 8;
+    case DepthFormat::Z32_FLOAT:
+    case DepthFormat::S8_Z24_UNORM:
+    case DepthFormat::Z24_X8_UNORM:
+    case DepthFormat::Z24_S8_UNORM:
+    case DepthFormat::Z24_C8_UNORM:
+        return 4;
+    case DepthFormat::Z16_UNORM:
+        return 2;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented Depth format {}", static_cast<u32>(format));
+    }
+}
+
 } // namespace Tegra
diff --git a/src/video_core/gpu.h b/src/video_core/gpu.h
index 3c20f07bbc..33a4755e08 100644
--- a/src/video_core/gpu.h
+++ b/src/video_core/gpu.h
@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <unordered_map>
-#include <vector>
 #include "common/common_types.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 #include "video_core/memory_manager.h"
@@ -35,6 +34,10 @@ enum class RenderTargetFormat : u32 {
     R11G11B10_FLOAT = 0xE0,
     R32_FLOAT = 0xE5,
     B5G6R5_UNORM = 0xE8,
+    R16_UNORM = 0xEE,
+    R16_SNORM = 0xEF,
+    R16_SINT = 0xF0,
+    R16_UINT = 0xF1,
     R16_FLOAT = 0xF2,
     R8_UNORM = 0xF3,
     R8_UINT = 0xF6,
@@ -53,6 +56,9 @@ enum class DepthFormat : u32 {
 /// Returns the number of bytes per pixel of each rendertarget format.
 u32 RenderTargetBytesPerPixel(RenderTargetFormat format);
 
+/// Returns the number of bytes per pixel of each depth format.
+u32 DepthFormatBytesPerPixel(DepthFormat format);
+
 class DebugContext;
 
 /**
@@ -66,14 +72,7 @@ struct FramebufferConfig {
     /**
      * Returns the number of bytes per pixel.
      */
-    static u32 BytesPerPixel(PixelFormat format) {
-        switch (format) {
-        case PixelFormat::ABGR8:
-            return 4;
-        }
-
-        UNREACHABLE();
-    }
+    static u32 BytesPerPixel(PixelFormat format);
 
     VAddr address;
     u32 offset;
diff --git a/src/video_core/renderer_base.cpp b/src/video_core/renderer_base.cpp
index 3ca3502433..e87016429d 100644
--- a/src/video_core/renderer_base.cpp
+++ b/src/video_core/renderer_base.cpp
@@ -4,18 +4,23 @@
 
 #include <memory>
 #include "core/frontend/emu_window.h"
+#include "core/settings.h"
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 
 namespace VideoCore {
 
-RendererBase::RendererBase(EmuWindow& window) : render_window{window} {}
+RendererBase::RendererBase(EmuWindow& window) : render_window{window} {
+    RefreshBaseSettings();
+}
+
 RendererBase::~RendererBase() = default;
 
-void RendererBase::UpdateCurrentFramebufferLayout() {
-    const Layout::FramebufferLayout& layout = render_window.GetFramebufferLayout();
+void RendererBase::RefreshBaseSettings() {
+    RefreshRasterizerSetting();
+    UpdateCurrentFramebufferLayout();
 
-    render_window.UpdateCurrentFramebufferLayout(layout.width, layout.height);
+    renderer_settings.use_framelimiter = Settings::values.toggle_framelimit;
 }
 
 void RendererBase::RefreshRasterizerSetting() {
@@ -24,4 +29,10 @@ void RendererBase::RefreshRasterizerSetting() {
     }
 }
 
+void RendererBase::UpdateCurrentFramebufferLayout() {
+    const Layout::FramebufferLayout& layout = render_window.GetFramebufferLayout();
+
+    render_window.UpdateCurrentFramebufferLayout(layout.width, layout.height);
+}
+
 } // namespace VideoCore
diff --git a/src/video_core/renderer_base.h b/src/video_core/renderer_base.h
index 235de23a1b..fd8c475920 100644
--- a/src/video_core/renderer_base.h
+++ b/src/video_core/renderer_base.h
@@ -4,9 +4,9 @@
 
 #pragma once
 
+#include <atomic>
 #include <memory>
 #include <boost/optional.hpp>
-#include "common/assert.h"
 #include "common/common_types.h"
 #include "video_core/gpu.h"
 #include "video_core/rasterizer_interface.h"
@@ -15,11 +15,12 @@ class EmuWindow;
 
 namespace VideoCore {
 
+struct RendererSettings {
+    std::atomic_bool use_framelimiter{false};
+};
+
 class RendererBase : NonCopyable {
 public:
-    /// Used to reference a framebuffer
-    enum kFramebuffer { kFramebuffer_VirtualXFB = 0, kFramebuffer_EFB, kFramebuffer_Texture };
-
     explicit RendererBase(EmuWindow& window);
     virtual ~RendererBase();
 
@@ -32,9 +33,6 @@ public:
     /// Shutdown the renderer
     virtual void ShutDown() = 0;
 
-    /// Updates the framebuffer layout of the contained render window handle.
-    void UpdateCurrentFramebufferLayout();
-
     // Getter/setter functions:
     // ------------------------
 
@@ -54,13 +52,23 @@ public:
         return *rasterizer;
     }
 
-    void RefreshRasterizerSetting();
+    /// Refreshes the settings common to all renderers
+    void RefreshBaseSettings();
 
 protected:
+    /// Refreshes settings specific to the rasterizer.
+    void RefreshRasterizerSetting();
+
     EmuWindow& render_window; ///< Reference to the render window handle.
     std::unique_ptr<RasterizerInterface> rasterizer;
     f32 m_current_fps = 0.0f; ///< Current framerate, should be set by the renderer
     int m_current_frame = 0;  ///< Current frame, should be set by the renderer
+
+    RendererSettings renderer_settings;
+
+private:
+    /// Updates the framebuffer layout of the contained render window handle.
+    void UpdateCurrentFramebufferLayout();
 };
 
 } // namespace VideoCore
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index e8e0d1dd06..259ac019c0 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -123,6 +123,9 @@ static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_form
     {GL_R32F, GL_RED, GL_FLOAT, ComponentType::Float, false},                  // R32F
     {GL_R16F, GL_RED, GL_HALF_FLOAT, ComponentType::Float, false},             // R16F
     {GL_R16, GL_RED, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // R16UNORM
+    {GL_R16_SNORM, GL_RED, GL_SHORT, ComponentType::SNorm, false},             // R16S
+    {GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // R16UI
+    {GL_R16I, GL_RED_INTEGER, GL_SHORT, ComponentType::SInt, false},           // R16I
     {GL_RG16, GL_RG, GL_UNSIGNED_SHORT, ComponentType::UNorm, false},          // RG16
     {GL_RG16F, GL_RG, GL_HALF_FLOAT, ComponentType::Float, false},             // RG16F
     {GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // RG16UI
@@ -241,12 +244,14 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<true, PixelFormat::BGRA8>,       MortonCopy<true, PixelFormat::RGBA32F>,
         MortonCopy<true, PixelFormat::RG32F>,       MortonCopy<true, PixelFormat::R32F>,
         MortonCopy<true, PixelFormat::R16F>,        MortonCopy<true, PixelFormat::R16UNORM>,
-        MortonCopy<true, PixelFormat::RG16>,        MortonCopy<true, PixelFormat::RG16F>,
-        MortonCopy<true, PixelFormat::RG16UI>,      MortonCopy<true, PixelFormat::RG16I>,
-        MortonCopy<true, PixelFormat::RG16S>,       MortonCopy<true, PixelFormat::RGB32F>,
-        MortonCopy<true, PixelFormat::SRGBA8>,      MortonCopy<true, PixelFormat::Z24S8>,
-        MortonCopy<true, PixelFormat::S8Z24>,       MortonCopy<true, PixelFormat::Z32F>,
-        MortonCopy<true, PixelFormat::Z16>,         MortonCopy<true, PixelFormat::Z32FS8>,
+        MortonCopy<true, PixelFormat::R16S>,        MortonCopy<true, PixelFormat::R16UI>,
+        MortonCopy<true, PixelFormat::R16I>,        MortonCopy<true, PixelFormat::RG16>,
+        MortonCopy<true, PixelFormat::RG16F>,       MortonCopy<true, PixelFormat::RG16UI>,
+        MortonCopy<true, PixelFormat::RG16I>,       MortonCopy<true, PixelFormat::RG16S>,
+        MortonCopy<true, PixelFormat::RGB32F>,      MortonCopy<true, PixelFormat::SRGBA8>,
+        MortonCopy<true, PixelFormat::Z24S8>,       MortonCopy<true, PixelFormat::S8Z24>,
+        MortonCopy<true, PixelFormat::Z32F>,        MortonCopy<true, PixelFormat::Z16>,
+        MortonCopy<true, PixelFormat::Z32FS8>,
 };
 
 static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPUVAddr),
@@ -278,6 +283,9 @@ static constexpr std::array<void (*)(u32, u32, u32, std::vector<u8>&, Tegra::GPU
         MortonCopy<false, PixelFormat::R32F>,
         MortonCopy<false, PixelFormat::R16F>,
         MortonCopy<false, PixelFormat::R16UNORM>,
+        MortonCopy<false, PixelFormat::R16S>,
+        MortonCopy<false, PixelFormat::R16UI>,
+        MortonCopy<false, PixelFormat::R16I>,
         MortonCopy<false, PixelFormat::RG16>,
         MortonCopy<false, PixelFormat::RG16F>,
         MortonCopy<false, PixelFormat::RG16UI>,
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index 2291b38779..38cbbbc0f3 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -47,22 +47,25 @@ struct SurfaceParams {
         R32F = 21,
         R16F = 22,
         R16UNORM = 23,
-        RG16 = 24,
-        RG16F = 25,
-        RG16UI = 26,
-        RG16I = 27,
-        RG16S = 28,
-        RGB32F = 29,
-        SRGBA8 = 30,
+        R16S = 24,
+        R16UI = 25,
+        R16I = 26,
+        RG16 = 27,
+        RG16F = 28,
+        RG16UI = 29,
+        RG16I = 30,
+        RG16S = 31,
+        RGB32F = 32,
+        SRGBA8 = 33,
 
         MaxColorFormat,
 
         // DepthStencil formats
-        Z24S8 = 31,
-        S8Z24 = 32,
-        Z32F = 33,
-        Z16 = 34,
-        Z32FS8 = 35,
+        Z24S8 = 34,
+        S8Z24 = 35,
+        Z32F = 36,
+        Z16 = 37,
+        Z32FS8 = 38,
 
         MaxDepthStencilFormat,
 
@@ -124,6 +127,9 @@ struct SurfaceParams {
             1, // R32F
             1, // R16F
             1, // R16UNORM
+            1, // R16S
+            1, // R16UI
+            1, // R16I
             1, // RG16
             1, // RG16F
             1, // RG16UI
@@ -171,6 +177,9 @@ struct SurfaceParams {
             32,  // R32F
             16,  // R16F
             16,  // R16UNORM
+            16,  // R16S
+            16,  // R16UI
+            16,  // R16I
             32,  // RG16
             32,  // RG16F
             32,  // RG16UI
@@ -250,6 +259,14 @@ struct SurfaceParams {
             return PixelFormat::RG16S;
         case Tegra::RenderTargetFormat::R16_FLOAT:
             return PixelFormat::R16F;
+        case Tegra::RenderTargetFormat::R16_UNORM:
+            return PixelFormat::R16UNORM;
+        case Tegra::RenderTargetFormat::R16_SNORM:
+            return PixelFormat::R16S;
+        case Tegra::RenderTargetFormat::R16_UINT:
+            return PixelFormat::R16UI;
+        case Tegra::RenderTargetFormat::R16_SINT:
+            return PixelFormat::R16I;
         case Tegra::RenderTargetFormat::R32_FLOAT:
             return PixelFormat::R32F;
         default:
@@ -306,6 +323,12 @@ struct SurfaceParams {
                 return PixelFormat::R16F;
             case Tegra::Texture::ComponentType::UNORM:
                 return PixelFormat::R16UNORM;
+            case Tegra::Texture::ComponentType::SNORM:
+                return PixelFormat::R16S;
+            case Tegra::Texture::ComponentType::UINT:
+                return PixelFormat::R16UI;
+            case Tegra::Texture::ComponentType::SINT:
+                return PixelFormat::R16I;
             }
             LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}",
                          static_cast<u32>(component_type));
@@ -389,9 +412,11 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RGB10_A2_UNORM:
         case Tegra::RenderTargetFormat::R8_UNORM:
         case Tegra::RenderTargetFormat::RG16_UNORM:
+        case Tegra::RenderTargetFormat::R16_UNORM:
         case Tegra::RenderTargetFormat::B5G6R5_UNORM:
             return ComponentType::UNorm;
         case Tegra::RenderTargetFormat::RG16_SNORM:
+        case Tegra::RenderTargetFormat::R16_SNORM:
             return ComponentType::SNorm;
         case Tegra::RenderTargetFormat::RGBA16_FLOAT:
         case Tegra::RenderTargetFormat::R11G11B10_FLOAT:
@@ -404,8 +429,10 @@ struct SurfaceParams {
         case Tegra::RenderTargetFormat::RGBA32_UINT:
         case Tegra::RenderTargetFormat::RG16_UINT:
         case Tegra::RenderTargetFormat::R8_UINT:
+        case Tegra::RenderTargetFormat::R16_UINT:
             return ComponentType::UInt;
         case Tegra::RenderTargetFormat::RG16_SINT:
+        case Tegra::RenderTargetFormat::R16_SINT:
             return ComponentType::SInt;
         default:
             LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format));
diff --git a/src/video_core/renderer_opengl/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index 43be69dd1c..c439446b13 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -45,6 +45,9 @@ inline GLenum VertexType(Maxwell::VertexAttribute attrib) {
     case Maxwell::VertexAttribute::Type::SignedNorm: {
 
         switch (attrib.size) {
+        case Maxwell::VertexAttribute::Size::Size_32_32_32:
+            return GL_INT;
+        case Maxwell::VertexAttribute::Size::Size_8_8:
         case Maxwell::VertexAttribute::Size::Size_8_8_8_8:
             return GL_BYTE;
         case Maxwell::VertexAttribute::Size::Size_16_16:
diff --git a/src/video_core/video_core.cpp b/src/video_core/video_core.cpp
index 5085ef96bd..1e686b89e7 100644
--- a/src/video_core/video_core.cpp
+++ b/src/video_core/video_core.cpp
@@ -9,8 +9,6 @@
 
 namespace VideoCore {
 
-std::atomic<bool> g_toggle_framelimit_enabled;
-
 std::unique_ptr<RendererBase> CreateRenderer(EmuWindow& emu_window) {
     return std::make_unique<RendererOpenGL>(emu_window);
 }
diff --git a/src/video_core/video_core.h b/src/video_core/video_core.h
index 7c01c0b8da..2dc07540f6 100644
--- a/src/video_core/video_core.h
+++ b/src/video_core/video_core.h
@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <atomic>
 #include <memory>
 
 class EmuWindow;
@@ -13,12 +12,6 @@ namespace VideoCore {
 
 class RendererBase;
 
-enum class Renderer { Software, OpenGL };
-
-// TODO: Wrap these in a user settings struct along with any other graphics settings (often set from
-// qt ui)
-extern std::atomic<bool> g_toggle_framelimit_enabled;
-
 /**
  * Creates a renderer instance.
  *
diff --git a/src/yuzu/game_list_p.h b/src/yuzu/game_list_p.h
index 114a0fc7f0..8fe5e8b802 100644
--- a/src/yuzu/game_list_p.h
+++ b/src/yuzu/game_list_p.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <array>
 #include <atomic>
 #include <utility>
 #include <QImage>
@@ -39,7 +40,6 @@ public:
  * If this class receives valid SMDH data, it will also display game icons and titles.
  */
 class GameListItemPath : public GameListItem {
-
 public:
     static const int FullPathRole = Qt::UserRole + 1;
     static const int TitleRole = Qt::UserRole + 2;
@@ -48,18 +48,18 @@ public:
 
     GameListItemPath() = default;
     GameListItemPath(const QString& game_path, const std::vector<u8>& picture_data,
-                     const QString& game_name, const QString& game_type, u64 program_id)
-        : GameListItem() {
+                     const QString& game_name, const QString& game_type, u64 program_id) {
         setData(game_path, FullPathRole);
         setData(game_name, TitleRole);
         setData(qulonglong(program_id), ProgramIdRole);
         setData(game_type, FileTypeRole);
 
-        QPixmap picture;
-        u32 size = UISettings::values.icon_size;
-        if (!picture.loadFromData(picture_data.data(), picture_data.size()))
-            picture = GetDefaultIcon(size);
+        const u32 size = UISettings::values.icon_size;
 
+        QPixmap picture;
+        if (!picture.loadFromData(picture_data.data(), static_cast<u32>(picture_data.size()))) {
+            picture = GetDefaultIcon(size);
+        }
         picture = picture.scaled(size, size);
 
         setData(picture, Qt::DecorationRole);
@@ -70,17 +70,16 @@ public:
             std::string filename;
             Common::SplitPath(data(FullPathRole).toString().toStdString(), nullptr, &filename,
                               nullptr);
-            QString title = data(TitleRole).toString();
 
-            std::vector<QString> row_data{
+            const std::array<QString, 4> row_data{{
                 QString::fromStdString(filename),
                 data(FileTypeRole).toString(),
                 QString::fromStdString(fmt::format("0x{:016X}", data(ProgramIdRole).toULongLong())),
                 data(TitleRole).toString(),
-            };
+            }};
 
-            auto row1 = row_data.at(UISettings::values.row_1_text_id);
-            auto row2 = row_data.at(UISettings::values.row_2_text_id);
+            const auto& row1 = row_data.at(UISettings::values.row_1_text_id);
+            const auto& row2 = row_data.at(UISettings::values.row_2_text_id);
 
             if (row1.isEmpty() || row1 == row2)
                 return row2;
@@ -88,9 +87,9 @@ public:
                 return row1;
 
             return row1 + "\n    " + row2;
-        } else {
-            return GameListItem::data(role);
         }
+
+        return GameListItem::data(role);
     }
 };