From 0542855d924a5a3163d667f0d3895e74a1d7a0b6 Mon Sep 17 00:00:00 2001
From: weihuoya <zwdreams@gmail.com>
Date: Wed, 16 Oct 2019 11:09:03 +0800
Subject: [PATCH] update

---
 CMakeLists.txt                                |   6 +-
 .../java/org/citra/emu/NativeLibrary.java     |  10 +-
 .../java/org/citra/emu/model/GameFile.java    |  24 +
 .../org/citra/emu/ui/EmulationActivity.java   |   5 +-
 .../citra/emu/ui/GameFilePickerActivity.java  |   4 +-
 .../java/org/citra/emu/ui/MainActivity.java   |  13 +-
 .../org/citra/emu/ui/MiiSelectorDialog.java   | 136 ++++++
 .../citra/emu/ui/RunningSettingDialog.java    |   1 -
 .../citra/emu/utils/PermissionsHandler.java   |  25 +
 .../main/res/layout/dialog_mii_selector.xml   |  31 ++
 .../app/src/main/res/values-zh/strings.xml    |   1 +
 .../app/src/main/res/values/strings.xml       |   1 +
 .../app/src/main/res/values/styles.xml        |  30 --
 src/android/jni/main_android.cpp              |  10 +
 src/citra/citra.cpp                           |   4 +-
 src/citra/default_ini.h                       |  13 -
 src/citra/emu_window/emu_window_sdl2.cpp      |  11 +
 src/citra/emu_window/emu_window_sdl2.h        |   3 +
 src/citra_qt/CMakeLists.txt                   |   6 +
 src/citra_qt/configuration/config.cpp         |  23 +-
 .../configuration/configure_general.cpp       |   2 +
 .../configuration/configure_general.ui        |   7 +
 .../configuration/configure_graphics.cpp      |  24 +-
 .../configuration/configure_graphics.h        |   2 +
 src/citra_qt/configuration/configure_ui.ui    |  14 +-
 src/citra_qt/debugger/ipc/record_dialog.cpp   |  65 +++
 src/citra_qt/debugger/ipc/record_dialog.h     |  36 ++
 src/citra_qt/debugger/ipc/record_dialog.ui    | 245 ++++++++++
 src/citra_qt/debugger/ipc/recorder.cpp        | 183 ++++++++
 src/citra_qt/debugger/ipc/recorder.h          |  52 +++
 src/citra_qt/debugger/ipc/recorder.ui         |  93 ++++
 src/citra_qt/game_list.cpp                    |  97 ++--
 src/citra_qt/game_list.h                      |  10 +-
 src/citra_qt/game_list_p.h                    |  45 +-
 src/citra_qt/game_list_worker.cpp             |   8 +-
 src/citra_qt/game_list_worker.h               |   5 +-
 src/citra_qt/main.cpp                         |  56 ++-
 src/citra_qt/main.h                           |   8 +-
 src/citra_qt/uisettings.h                     |  16 +-
 src/common/CMakeLists.txt                     |   2 +-
 src/common/hash.cpp                           |  51 ++
 src/common/hash.h                             |  56 +--
 src/core/CMakeLists.txt                       |   2 +
 src/core/core.cpp                             |  16 +-
 src/core/core_timing.cpp                      |   4 +-
 src/core/hle/kernel/hle_ipc.cpp               |  33 ++
 src/core/hle/kernel/hle_ipc.h                 |   3 +
 src/core/hle/kernel/ipc.cpp                   |  22 +-
 src/core/hle/kernel/ipc.h                     |   5 +-
 src/core/hle/kernel/ipc_debugger/recorder.cpp | 169 +++++++
 src/core/hle/kernel/ipc_debugger/recorder.h   | 129 ++++++
 src/core/hle/kernel/kernel.cpp                |  10 +
 src/core/hle/kernel/kernel.h                  |   9 +
 src/core/hle/kernel/memory.cpp                |   4 +-
 src/core/hle/kernel/svc.cpp                   |  33 +-
 src/core/hle/service/dsp/dsp_dsp.cpp          |   3 +-
 src/core/hle/service/fs/fs_user.cpp           |  21 +-
 src/core/hle/service/fs/fs_user.h             |   2 +
 src/core/hle/service/gsp/gsp_gpu.cpp          |  13 +-
 src/core/hle/service/service.cpp              |   9 +
 src/core/hle/service/service.h                |   3 +
 src/core/hle/service/sm/sm.cpp                |   9 +
 src/core/hle/service/sm/sm.h                  |   6 +
 src/core/hw/gpu.cpp                           |   7 +-
 src/core/hw/hw.cpp                            |  48 +-
 src/core/hw/lcd.cpp                           |   3 +-
 src/core/memory.cpp                           |  56 +--
 src/core/perf_stats.h                         |   1 +
 src/video_core/CMakeLists.txt                 |   2 +
 src/video_core/command_processor.cpp          |  24 +-
 .../renderer_opengl/gl_rasterizer.cpp         | 147 +++---
 .../renderer_opengl/gl_rasterizer.h           |   8 +-
 .../renderer_opengl/gl_rasterizer_cache.cpp   | 320 ++++---------
 .../renderer_opengl/gl_rasterizer_cache.h     |   4 +
 .../renderer_opengl/gl_resource_manager.cpp   |  14 +-
 .../renderer_opengl/gl_shader_gen.cpp         | 237 ++++++----
 .../renderer_opengl/gl_shader_gen.h           |  43 +-
 .../renderer_opengl/gl_shader_manager.cpp     | 245 +++++-----
 .../renderer_opengl/gl_shader_manager.h       |   7 +-
 .../renderer_opengl/gl_shader_util.cpp        |  12 +
 src/video_core/renderer_opengl/gl_state.cpp   | 268 +++++++----
 src/video_core/renderer_opengl/gl_state.h     |  24 +-
 src/video_core/renderer_opengl/gl_vars.cpp    | 233 ++++++++++
 src/video_core/renderer_opengl/gl_vars.h      |  19 +-
 .../renderer_opengl/on_screen_display.cpp     | 436 ++++++++++++++++++
 .../renderer_opengl/on_screen_display.h       |  44 ++
 .../renderer_opengl/renderer_opengl.cpp       | 221 +++++----
 .../renderer_opengl/renderer_opengl.h         |  10 +-
 88 files changed, 3256 insertions(+), 1116 deletions(-)
 create mode 100644 src/android/app/src/main/java/org/citra/emu/ui/MiiSelectorDialog.java
 create mode 100644 src/android/app/src/main/res/layout/dialog_mii_selector.xml
 create mode 100644 src/citra_qt/debugger/ipc/record_dialog.cpp
 create mode 100644 src/citra_qt/debugger/ipc/record_dialog.h
 create mode 100644 src/citra_qt/debugger/ipc/record_dialog.ui
 create mode 100644 src/citra_qt/debugger/ipc/recorder.cpp
 create mode 100644 src/citra_qt/debugger/ipc/recorder.h
 create mode 100644 src/citra_qt/debugger/ipc/recorder.ui
 create mode 100644 src/common/hash.cpp
 create mode 100644 src/core/hle/kernel/ipc_debugger/recorder.cpp
 create mode 100644 src/core/hle/kernel/ipc_debugger/recorder.h
 create mode 100644 src/video_core/renderer_opengl/on_screen_display.cpp
 create mode 100644 src/video_core/renderer_opengl/on_screen_display.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b1afb4b821a..9368d3fb57a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -327,10 +327,12 @@ git_describe(GIT_DESC --always --long --dirty)
 git_branch_name(GIT_BRANCH)
 get_timestamp(BUILD_DATE)
 
-enable_testing()
+if(NOT ANDROID)
+    enable_testing()
+    add_subdirectory(dist/installer)
+endif()
 add_subdirectory(externals)
 add_subdirectory(src)
-add_subdirectory(dist/installer)
 
 
 # Set citra-qt project or citra project as default StartUp Project in Visual Studio depending on whether QT is enabled or not
diff --git a/src/android/app/src/main/java/org/citra/emu/NativeLibrary.java b/src/android/app/src/main/java/org/citra/emu/NativeLibrary.java
index c305d1ed7d6..00e3f20fc6a 100644
--- a/src/android/app/src/main/java/org/citra/emu/NativeLibrary.java
+++ b/src/android/app/src/main/java/org/citra/emu/NativeLibrary.java
@@ -58,7 +58,7 @@ public static void showInputBoxDialog(int maxLength, String hint, String button0
     public static void showMiiSelectorDialog(boolean cancel, String title, String[] miis) {
         EmulationActivity activity = EmulationActivity.get();
         if (activity != null) {
-            activity.showMiiSelectorDialog(cancel, title, miis);
+            activity.runOnUiThread(() -> activity.showMiiSelectorDialog(cancel, title, miis));
         }
     }
 
@@ -84,6 +84,12 @@ public static void updateProgress(String name, int written, int total) {
         }
     }
 
+    public static boolean isValidFile(String filename) {
+        String name = filename.toLowerCase();
+        return (name.endsWith(".cia") || name.endsWith(".cci") || name.endsWith(".3ds") ||
+                name.endsWith(".cxi"));
+    }
+
     public static native String GetAppId(String path);
 
     public static native String GetAppTitle(String path);
@@ -92,6 +98,8 @@ public static void updateProgress(String name, int written, int total) {
 
     public static native int GetAppRegion(String path);
 
+    public static native boolean IsAppExecutable(String path);
+
     public static native void SaveScreenShot();
 
     public static native void InstallCIA(String[] path);
diff --git a/src/android/app/src/main/java/org/citra/emu/model/GameFile.java b/src/android/app/src/main/java/org/citra/emu/model/GameFile.java
index b5f086b7f4a..8dbd4b0016c 100644
--- a/src/android/app/src/main/java/org/citra/emu/model/GameFile.java
+++ b/src/android/app/src/main/java/org/citra/emu/model/GameFile.java
@@ -3,6 +3,15 @@
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.BitmapShader;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffXfermode;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.Shader;
+
 import java.nio.IntBuffer;
 import org.citra.emu.NativeLibrary;
 import org.citra.emu.R;
@@ -53,6 +62,21 @@ public Bitmap getIcon(Context context) {
                 mIcon = Bitmap.createBitmap(48, 48, Bitmap.Config.RGB_565);
                 mIcon.copyPixelsFromBuffer(IntBuffer.wrap(pixels));
             }
+
+            // rounded corners
+            float radius = 5.0f;
+            Rect rect = new Rect(0, 0, mIcon.getWidth(), mIcon.getHeight());
+            Bitmap output = Bitmap.createBitmap(mIcon.getWidth(), mIcon.getHeight(), Bitmap.Config.ARGB_8888);
+            Canvas canvas = new Canvas(output);
+            BitmapShader shader = new BitmapShader(mIcon, Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
+            Paint paint = new Paint();
+            paint.setAntiAlias(true);
+            paint.setShader(shader);
+            // rect contains the bounds of the shape
+            // radius is the radius in pixels of the rounded corners
+            // paint contains the shader that will texture the shape
+            canvas.drawRoundRect(new RectF(rect), radius, radius, paint);
+            mIcon = output;
         }
         return mIcon;
     }
diff --git a/src/android/app/src/main/java/org/citra/emu/ui/EmulationActivity.java b/src/android/app/src/main/java/org/citra/emu/ui/EmulationActivity.java
index 384a350a6b1..4b1b0e7439c 100644
--- a/src/android/app/src/main/java/org/citra/emu/ui/EmulationActivity.java
+++ b/src/android/app/src/main/java/org/citra/emu/ui/EmulationActivity.java
@@ -56,7 +56,7 @@ protected void onCreate(Bundle savedInstanceState) {
             if ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0) {
                 // Go back to immersive fullscreen mode in 3s
                 Handler handler = new Handler(getMainLooper());
-                handler.postDelayed(this ::enableFullscreenImmersive, 3000 /* 3s */);
+                handler.postDelayed(this::enableFullscreenImmersive, 3000 /* 3s */);
             }
         });
         mStopEmulation = false;
@@ -213,7 +213,8 @@ public void showInputBoxDialog(int maxLength, String hint, String button0, Strin
     }
 
     public void showMiiSelectorDialog(boolean cancel, String title, String[] miis) {
-        // todo
+        MiiSelectorDialog.newInstance(cancel, title, miis)
+            .show(getSupportFragmentManager(), "MiiSelectorDialog");
     }
 
     public void refreshControls() {
diff --git a/src/android/app/src/main/java/org/citra/emu/ui/GameFilePickerActivity.java b/src/android/app/src/main/java/org/citra/emu/ui/GameFilePickerActivity.java
index 1a5430226c0..920277c7c5f 100644
--- a/src/android/app/src/main/java/org/citra/emu/ui/GameFilePickerActivity.java
+++ b/src/android/app/src/main/java/org/citra/emu/ui/GameFilePickerActivity.java
@@ -9,6 +9,7 @@
 import com.nononsenseapps.filepicker.FilePickerActivity;
 import com.nononsenseapps.filepicker.FilePickerFragment;
 import java.io.File;
+import org.citra.emu.NativeLibrary;
 
 public final class GameFilePickerActivity extends FilePickerActivity {
     @Override
@@ -41,8 +42,7 @@ protected boolean isItemVisible(final File file) {
                 return false;
             if (file.isDirectory())
                 return true;
-            String filename = file.getName().toLowerCase();
-            return filename.endsWith(".cci") || filename.endsWith(".cia");
+            return NativeLibrary.isValidFile(file.getName());
         }
     }
 }
diff --git a/src/android/app/src/main/java/org/citra/emu/ui/MainActivity.java b/src/android/app/src/main/java/org/citra/emu/ui/MainActivity.java
index b8b4ca398db..775553d555b 100644
--- a/src/android/app/src/main/java/org/citra/emu/ui/MainActivity.java
+++ b/src/android/app/src/main/java/org/citra/emu/ui/MainActivity.java
@@ -11,8 +11,6 @@
 import android.content.pm.PackageManager;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
-import android.os.Handler;
-import android.os.Message;
 import android.support.v4.content.LocalBroadcastManager;
 import android.support.v7.app.AppCompatActivity;
 import android.support.v7.widget.LinearLayoutManager;
@@ -223,7 +221,7 @@ public void refreshLibrary() {
 
     public void addGamesInDirectory(String directory) {
         File[] files = new File(directory).listFiles((File dir, String name) -> {
-            if (name.toLowerCase().endsWith(".cci")) {
+            if (NativeLibrary.isValidFile(name)) {
                 String path = dir.getPath() + File.separator + name;
                 for (GameFile game : mGames) {
                     if (path.equals(game.getPath())) {
@@ -240,7 +238,9 @@ public void addGamesInDirectory(String directory) {
         }
 
         for (File f : files) {
-            mGames.add(new GameFile(f.getPath()));
+            String path = f.getPath();
+            if (NativeLibrary.IsAppExecutable(path))
+                mGames.add(new GameFile(path));
         }
     }
 
@@ -252,7 +252,7 @@ public void saveGameList() {
         }
 
         File cache = getGameListCache();
-        FileWriter writer = null;
+        FileWriter writer;
         try {
             writer = new FileWriter(cache);
             writer.write(sb.toString());
@@ -277,7 +277,8 @@ public void loadGameList() {
 
         mGames.clear();
         for (String path : content.split(";")) {
-            if (!path.isEmpty() && path.endsWith(".cci") && new File(path).exists()) {
+            if (NativeLibrary.isValidFile(path) && new File(path).exists() &&
+                NativeLibrary.IsAppExecutable(path)) {
                 mGames.add(new GameFile(path));
             }
         }
diff --git a/src/android/app/src/main/java/org/citra/emu/ui/MiiSelectorDialog.java b/src/android/app/src/main/java/org/citra/emu/ui/MiiSelectorDialog.java
new file mode 100644
index 00000000000..2134f574c6a
--- /dev/null
+++ b/src/android/app/src/main/java/org/citra/emu/ui/MiiSelectorDialog.java
@@ -0,0 +1,136 @@
+package org.citra.emu.ui;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.TextView;
+import com.nononsenseapps.filepicker.DividerItemDecoration;
+import java.util.ArrayList;
+import org.citra.emu.R;
+
+public class MiiSelectorDialog extends DialogFragment {
+    private static final String ARG_CANCEL = "cancel";
+    private static final String ARG_TITLE = "title";
+    private static final String ARG_MIIS = "miis";
+
+    public static MiiSelectorDialog newInstance(boolean cancel, String title, String[] miis) {
+        MiiSelectorDialog fragment = new MiiSelectorDialog();
+        Bundle arguments = new Bundle();
+        arguments.putBoolean(ARG_CANCEL, cancel);
+        arguments.putString(ARG_TITLE, title);
+        arguments.putStringArray(ARG_MIIS, miis);
+        fragment.setArguments(arguments);
+        return fragment;
+    }
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        ViewGroup contents = (ViewGroup)getActivity().getLayoutInflater().inflate(
+            R.layout.dialog_mii_selector, null);
+
+        Drawable lineDivider = getContext().getDrawable(R.drawable.line_divider);
+        RecyclerView recyclerView = contents.findViewById(R.id.list_settings);
+        RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(getContext());
+        recyclerView.setLayoutManager(layoutManager);
+        MiisAdapter adapter = new MiisAdapter();
+        recyclerView.setAdapter(adapter);
+        recyclerView.addItemDecoration(new DividerItemDecoration(lineDivider));
+        builder.setView(contents);
+        return builder.create();
+    }
+
+    @Override
+    public void onDismiss(DialogInterface dialog) {
+        super.onDismiss(dialog);
+    }
+
+    public class SettingsItem {}
+
+    public abstract class SettingViewHolder
+        extends RecyclerView.ViewHolder implements View.OnClickListener {
+        public SettingViewHolder(View itemView) {
+            super(itemView);
+            itemView.setOnClickListener(this);
+            findViews(itemView);
+        }
+
+        protected abstract void findViews(View root);
+
+        public abstract void bind(SettingsItem item);
+
+        public abstract void onClick(View clicked);
+    }
+
+    public final class CheckBoxSettingViewHolder
+        extends SettingViewHolder implements CompoundButton.OnCheckedChangeListener {
+        SettingsItem mItem;
+        private TextView mTextSettingName;
+        private CheckBox mCheckbox;
+
+        public CheckBoxSettingViewHolder(View itemView) {
+            super(itemView);
+        }
+
+        @Override
+        protected void findViews(View root) {
+            mTextSettingName = root.findViewById(R.id.text_setting_name);
+            mCheckbox = root.findViewById(R.id.checkbox);
+            mCheckbox.setOnCheckedChangeListener(this);
+        }
+
+        @Override
+        public void bind(SettingsItem item) {
+            mItem = item;
+            // mTextSettingName.setText(item.getName());
+            // mCheckbox.setChecked(mItem.getValue() > 0);
+        }
+
+        @Override
+        public void onClick(View clicked) {
+            mCheckbox.toggle();
+            // mItem.setValue(mCheckbox.isChecked() ? 1 : 0);
+        }
+
+        @Override
+        public void onCheckedChanged(CompoundButton view, boolean isChecked) {
+            // mItem.setValue(isChecked ? 1 : 0);
+        }
+    }
+
+    public class MiisAdapter extends RecyclerView.Adapter<SettingViewHolder> {
+        private ArrayList<SettingsItem> mSettings;
+
+        public MiisAdapter() {}
+
+        @NonNull
+        @Override
+        public SettingViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+            LayoutInflater inflater = LayoutInflater.from(parent.getContext());
+            View itemView = inflater.inflate(R.layout.list_item_running_checkbox, parent, false);
+            return new CheckBoxSettingViewHolder(itemView);
+        }
+
+        @Override
+        public int getItemCount() {
+            return mSettings.size();
+        }
+
+        @Override
+        public void onBindViewHolder(@NonNull SettingViewHolder holder, int position) {
+            holder.bind(mSettings.get(position));
+        }
+    }
+}
diff --git a/src/android/app/src/main/java/org/citra/emu/ui/RunningSettingDialog.java b/src/android/app/src/main/java/org/citra/emu/ui/RunningSettingDialog.java
index 56cfb62d5c2..2b4580cb984 100644
--- a/src/android/app/src/main/java/org/citra/emu/ui/RunningSettingDialog.java
+++ b/src/android/app/src/main/java/org/citra/emu/ui/RunningSettingDialog.java
@@ -38,7 +38,6 @@ public Dialog onCreateDialog(Bundle savedInstanceState) {
         ViewGroup contents = (ViewGroup)getActivity().getLayoutInflater().inflate(
             R.layout.dialog_running_settings, null);
 
-        int columns = 1;
         Drawable lineDivider = getContext().getDrawable(R.drawable.line_divider);
         RecyclerView recyclerView = contents.findViewById(R.id.list_settings);
         RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(getContext());
diff --git a/src/android/app/src/main/java/org/citra/emu/utils/PermissionsHandler.java b/src/android/app/src/main/java/org/citra/emu/utils/PermissionsHandler.java
index 3fd76ebbddf..4784a608845 100644
--- a/src/android/app/src/main/java/org/citra/emu/utils/PermissionsHandler.java
+++ b/src/android/app/src/main/java/org/citra/emu/utils/PermissionsHandler.java
@@ -1,5 +1,6 @@
 package org.citra.emu.utils;
 
+import static android.Manifest.permission.CAMERA;
 import static android.Manifest.permission.WRITE_EXTERNAL_STORAGE;
 
 import android.annotation.TargetApi;
@@ -15,6 +16,7 @@
 
 public final class PermissionsHandler {
     public static final int REQUEST_CODE_WRITE_PERMISSION = 500;
+    public static final int REQUEST_CODE_CAMERA_PERMISSION = 501;
 
     @TargetApi(Build.VERSION_CODES.M)
     public static boolean checkWritePermission(final Activity activity) {
@@ -43,6 +45,29 @@ public static boolean checkWritePermission(final Activity activity) {
         return true;
     }
 
+    @TargetApi(Build.VERSION_CODES.M)
+    public static boolean checkCameraPermission(final Activity activity) {
+        if (android.os.Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            return true;
+        }
+
+        int permission = ContextCompat.checkSelfPermission(activity, CAMERA);
+        if (permission != PackageManager.PERMISSION_GRANTED) {
+            if (activity.shouldShowRequestPermissionRationale(CAMERA)) {
+                showMessageOKCancel(activity, activity.getString(R.string.camera_permission_needed),
+                                    (dialog, which)
+                                        -> activity.requestPermissions(
+                                            new String[] {CAMERA}, REQUEST_CODE_CAMERA_PERMISSION));
+                return false;
+            }
+
+            activity.requestPermissions(new String[] {CAMERA}, REQUEST_CODE_CAMERA_PERMISSION);
+            return false;
+        }
+
+        return true;
+    }
+
     public static boolean hasWriteAccess(Context context) {
         if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             int hasWritePermission =
diff --git a/src/android/app/src/main/res/layout/dialog_mii_selector.xml b/src/android/app/src/main/res/layout/dialog_mii_selector.xml
new file mode 100644
index 00000000000..2c414552d3e
--- /dev/null
+++ b/src/android/app/src/main/res/layout/dialog_mii_selector.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <TextView
+        android:id="@+id/text_title"
+        android:text="@string/preferences_settings"
+        android:textAlignment="center"
+        android:textColor="@android:color/white"
+        android:background="@color/citra_orange"
+        android:layout_alignParentTop="true"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <Button
+        android:id="@+id/button_cancel"
+        android:layout_alignParentBottom="true"
+        style="?android:attr/buttonBarButtonStyle"
+        android:layout_width="wrap_content"
+        android:layout_height="match_parent"/>
+
+    <android.support.v7.widget.RecyclerView
+        android:id="@+id/list_settings"
+        android:background="@android:color/white"
+        android:layout_below="@id/text_title"
+        android:layout_above="@id/button_cancel"
+        android:layout_width="match_parent"
+        android:layout_height="300dp"/>
+
+</RelativeLayout>
diff --git a/src/android/app/src/main/res/values-zh/strings.xml b/src/android/app/src/main/res/values-zh/strings.xml
index 86be85d7628..88008da5180 100644
--- a/src/android/app/src/main/res/values-zh/strings.xml
+++ b/src/android/app/src/main/res/values-zh/strings.xml
@@ -56,6 +56,7 @@
     <string name="save">保存</string>
     <string name="cheat_code">金手指</string>
     <string name="write_permission_needed">You need to allow write access to external storage for the emulator to work.</string>
+    <string name="camera_permission_needed">You need to allow take photos for the emulator to work.</string>
 
     <string name="region_invalid">未知</string>
     <string name="region_japan">日本</string>
diff --git a/src/android/app/src/main/res/values/strings.xml b/src/android/app/src/main/res/values/strings.xml
index 69e590041d6..97a88f6881f 100644
--- a/src/android/app/src/main/res/values/strings.xml
+++ b/src/android/app/src/main/res/values/strings.xml
@@ -56,6 +56,7 @@
     <string name="save">Save</string>
     <string name="cheat_code">Cheat Code</string>
     <string name="write_permission_needed">You need to allow write access to external storage for the emulator to work.</string>
+    <string name="camera_permission_needed">You need to allow take photos for the emulator to work.</string>
 
     <string name="region_invalid">Unknown</string>
     <string name="region_japan">Japan</string>
diff --git a/src/android/app/src/main/res/values/styles.xml b/src/android/app/src/main/res/values/styles.xml
index 37941c53998..922c5737a81 100644
--- a/src/android/app/src/main/res/values/styles.xml
+++ b/src/android/app/src/main/res/values/styles.xml
@@ -45,10 +45,6 @@
         <item name="colorPrimaryDark">@color/citra_orange_dark</item>
     </style>
 
-    <!-- Themes for Dialogs -->
-
-    <!-- Inherit from the Base Citra Dialog Theme -->
-
     <style name="CitraEmulationBase" parent="Theme.AppCompat.Light.DarkActionBar">
         <item name="colorPrimary">@color/citra_orange</item>
         <item name="colorPrimaryDark">@color/citra_orange_dark</item>
@@ -62,37 +58,11 @@
         <item name="android:windowAllowReturnTransitionOverlap">true</item>
     </style>
 
-    <style name="CitraEmulationTvBase" parent="Theme.AppCompat.Light.NoActionBar">
-        <item name="colorPrimary">@color/citra_orange</item>
-        <item name="colorPrimaryDark">@color/citra_orange_dark</item>
-        <item name="android:windowTranslucentNavigation">true</item>
-
-        <item name="android:windowBackground">@android:color/black</item>
-
-        <!-- Enable window content transitions -->
-        <item name="android:windowContentTransitions">true</item>
-        <item name="android:windowAllowEnterTransitionOverlap">true</item>
-        <item name="android:windowAllowReturnTransitionOverlap">true</item>
-    </style>
-
     <!-- Hax to make Tablayout render icons -->
     <style name="MyCustomTextAppearance" parent="TextAppearance.Design.Tab">
         <item name="textAllCaps">false</item>
     </style>
 
-    <style name="InGameMenuOption" parent="Widget.AppCompat.Button.Borderless">
-        <item name="android:textSize">16sp</item>
-        <item name="android:fontFamily">sans-serif-condensed</item>
-        <item name="android:textColor">@android:color/white</item>
-        <item name="android:textAllCaps">false</item>
-        <item name="android:layout_width">match_parent</item>
-        <item name="android:layout_height">48dp</item>
-        <item name="android:gravity">center_vertical|left</item>
-        <item name="android:paddingLeft">32dp</item>
-        <item name="android:paddingRight">32dp</item>
-        <item name="android:layout_margin">0dp</item>
-    </style>
-
     <!-- You can also inherit from NNF_BaseTheme.Light -->
     <style name="FilePickerTheme" parent="NNF_BaseTheme.Light">
         <item name="colorPrimary">@color/citra_orange</item>
diff --git a/src/android/jni/main_android.cpp b/src/android/jni/main_android.cpp
index b38aef6d7d1..9148a9e7d65 100644
--- a/src/android/jni/main_android.cpp
+++ b/src/android/jni/main_android.cpp
@@ -424,6 +424,16 @@ JNIEXPORT jint JNICALL Java_org_citra_emu_NativeLibrary_GetAppRegion(JNIEnv* env
     return static_cast<jint>(regions[0]);
 }
 
+JNIEXPORT jboolean JNICALL Java_org_citra_emu_NativeLibrary_IsAppExecutable(JNIEnv* env, jclass obj,
+                                                                            jstring jPath) {
+    bool executable = false;
+    Loader::AppLoader* app_loader = GetAppLoader(GetJString(jPath));
+    if (app_loader) {
+        app_loader->IsExecutable(executable);
+    }
+    return executable;
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/citra/citra.cpp b/src/citra/citra.cpp
index 2e0c4c69775..845d115835b 100644
--- a/src/citra/citra.cpp
+++ b/src/citra/citra.cpp
@@ -338,8 +338,6 @@ int main(int argc, char** argv) {
 
     Core::System& system{Core::System::GetInstance()};
 
-    SCOPE_EXIT({ system.Shutdown(); });
-
     const Core::System::ResultStatus load_result{system.Load(*emu_window, filepath)};
 
     switch (load_result) {
@@ -402,6 +400,8 @@ int main(int argc, char** argv) {
 
     Core::Movie::GetInstance().Shutdown();
 
+    system.Shutdown();
+
     detached_tasks.WaitForAllTasks();
     return 0;
 }
diff --git a/src/citra/default_ini.h b/src/citra/default_ini.h
index 29c2f723adf..0b8e2d5a30d 100644
--- a/src/citra/default_ini.h
+++ b/src/citra/default_ini.h
@@ -135,24 +135,13 @@ bg_red =
 bg_blue =
 bg_green =
 
-# Whether and how Stereoscopic 3D should be rendered
-# 0 (default): Off, 1: Side by Side, 2: Anaglyph
-render_3d =
-
 # Change 3D Intensity
 # 0 - 100: Intensity. 0 (default)
 factor_3d =
 
 # The name of the post processing shader to apply.
-# Loaded from shaders if render_3d is off or side by side.
-# Loaded from shaders/anaglyph if render_3d is anaglyph
 pp_shader_name =
 
-# Whether to enable linear filtering or not
-# This is required for some shaders to work correctly
-# 0: Nearest, 1 (default): Linear
-filter_mode =
-
 [Layout]
 # Layout for the screen inside the render window.
 # 0 (default): Default Top Bottom Screen, 1: Single Screen Only, 2: Large Screen Small Screen, 3: Side by Side
@@ -257,8 +246,6 @@ camera_inner_flip =
 log_filter = *:Info
 
 [Debugging]
-# Record frame time data, can be found in the log directory. Boolean value
-record_frame_times =
 # Port for listening to GDB connections.
 use_gdbstub=false
 gdbstub_port=24689
diff --git a/src/citra/emu_window/emu_window_sdl2.cpp b/src/citra/emu_window/emu_window_sdl2.cpp
index ecd9ee20dd8..34d3d2fdb98 100644
--- a/src/citra/emu_window/emu_window_sdl2.cpp
+++ b/src/citra/emu_window/emu_window_sdl2.cpp
@@ -13,6 +13,7 @@
 #include "common/logging/log.h"
 #include "common/scm_rev.h"
 #include "core/3ds.h"
+#include "core/core.h"
 #include "core/settings.h"
 #include "input_common/keyboard.h"
 #include "input_common/main.h"
@@ -242,6 +243,16 @@ void EmuWindow_SDL2::PollEvents() {
             break;
         }
     }
+
+    const u32 current_time = SDL_GetTicks();
+    if (current_time > last_time + 2000) {
+        const auto results = Core::System::GetInstance().GetAndResetPerfStats();
+        const auto title = fmt::format(
+            "Citra {} | {}-{} | FPS: {:.0f} ({:.0%})", Common::g_build_fullname,
+            Common::g_scm_branch, Common::g_scm_desc, results.game_fps, results.emulation_speed);
+        SDL_SetWindowTitle(render_window, title.c_str());
+        last_time = current_time;
+    }
 }
 
 void EmuWindow_SDL2::MakeCurrent() {
diff --git a/src/citra/emu_window/emu_window_sdl2.h b/src/citra/emu_window/emu_window_sdl2.h
index 12af0e5247a..3462c5bd944 100644
--- a/src/citra/emu_window/emu_window_sdl2.h
+++ b/src/citra/emu_window/emu_window_sdl2.h
@@ -70,4 +70,7 @@ class EmuWindow_SDL2 : public Frontend::EmuWindow {
     using SDL_GLContext = void*;
     /// The OpenGL context associated with the window
     SDL_GLContext gl_context;
+
+    /// Keeps track of how often to update the title bar during gameplay
+    u32 last_time = 0;
 };
diff --git a/src/citra_qt/CMakeLists.txt b/src/citra_qt/CMakeLists.txt
index 6ac1eb2dbf9..0198ada766e 100644
--- a/src/citra_qt/CMakeLists.txt
+++ b/src/citra_qt/CMakeLists.txt
@@ -90,6 +90,12 @@ add_executable(citra-qt
     debugger/graphics/graphics_tracing.h
     debugger/graphics/graphics_vertex_shader.cpp
     debugger/graphics/graphics_vertex_shader.h
+    debugger/ipc/record_dialog.cpp
+    debugger/ipc/record_dialog.h
+    debugger/ipc/record_dialog.ui
+    debugger/ipc/recorder.cpp
+    debugger/ipc/recorder.h
+    debugger/ipc/recorder.ui
     debugger/lle_service_modules.cpp
     debugger/lle_service_modules.h
     debugger/profiler.cpp
diff --git a/src/citra_qt/configuration/config.cpp b/src/citra_qt/configuration/config.cpp
index 42c2b5ea8f0..d61c36252ed 100644
--- a/src/citra_qt/configuration/config.cpp
+++ b/src/citra_qt/configuration/config.cpp
@@ -298,17 +298,19 @@ void Config::ReadValues() {
     }
     UISettings::values.game_list_icon_size = icon_size;
 
-    int row_1 = ReadSetting("row1", 2).toInt();
-    if (row_1 < 0 || row_1 > 3) {
-        row_1 = 2;
+    UISettings::GameListText row_1 = UISettings::GameListText{
+        ReadSetting("row1", static_cast<int>(UISettings::GameListText::TitleName)).toInt()};
+    if (row_1 <= UISettings::GameListText::NoText || row_1 >= UISettings::GameListText::ListEnd) {
+        row_1 = UISettings::GameListText::TitleName;
     }
-    UISettings::values.game_list_row_1 = UISettings::GameListText{row_1};
+    UISettings::values.game_list_row_1 = row_1;
 
-    int row_2 = ReadSetting("row2", 0).toInt();
-    if (row_2 < -1 || row_2 > 3) {
-        row_2 = 0;
+    UISettings::GameListText row_2 = UISettings::GameListText{
+        ReadSetting("row2", static_cast<int>(UISettings::GameListText::FileName)).toInt()};
+    if (row_2 < UISettings::GameListText::NoText || row_2 >= UISettings::GameListText::ListEnd) {
+        row_2 = UISettings::GameListText::FileName;
     }
-    UISettings::values.game_list_row_2 = UISettings::GameListText{row_2};
+    UISettings::values.game_list_row_2 = row_2;
 
     UISettings::values.game_list_hide_no_icon = ReadSetting("hideNoIcon", false).toBool();
     UISettings::values.game_list_single_line_mode = ReadSetting("singleLineMode", false).toBool();
@@ -375,6 +377,8 @@ void Config::ReadValues() {
     UISettings::values.first_start = ReadSetting("firstStart", true).toBool();
     UISettings::values.callout_flags = ReadSetting("calloutFlags", 0).toUInt();
     UISettings::values.show_console = ReadSetting("showConsole", false).toBool();
+    UISettings::values.pause_when_in_background =
+        ReadSetting("pauseWhenInBackground", false).toBool();
 
     qt_config->beginGroup("Multiplayer");
     UISettings::values.nickname = ReadSetting("nickname", "").toString();
@@ -591,7 +595,7 @@ void Config::SaveValues() {
     qt_config->beginWriteArray("gamedirs");
     for (int i = 0; i < UISettings::values.game_dirs.size(); ++i) {
         qt_config->setArrayIndex(i);
-        const auto& game_dir = UISettings::values.game_dirs.at(i);
+        const auto& game_dir = UISettings::values.game_dirs[i];
         WriteSetting("path", game_dir.path);
         WriteSetting("deep_scan", game_dir.deep_scan, false);
         WriteSetting("expanded", game_dir.expanded, true);
@@ -624,6 +628,7 @@ void Config::SaveValues() {
     WriteSetting("firstStart", UISettings::values.first_start, true);
     WriteSetting("calloutFlags", UISettings::values.callout_flags, 0);
     WriteSetting("showConsole", UISettings::values.show_console, false);
+    WriteSetting("pauseWhenInBackground", UISettings::values.pause_when_in_background, false);
 
     qt_config->beginGroup("Multiplayer");
     WriteSetting("nickname", UISettings::values.nickname, "");
diff --git a/src/citra_qt/configuration/configure_general.cpp b/src/citra_qt/configuration/configure_general.cpp
index 7332d959aed..47d559e3dd9 100644
--- a/src/citra_qt/configuration/configure_general.cpp
+++ b/src/citra_qt/configuration/configure_general.cpp
@@ -26,6 +26,7 @@ ConfigureGeneral::~ConfigureGeneral() = default;
 
 void ConfigureGeneral::SetConfiguration() {
     ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
+    ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background);
 
     ui->toggle_update_check->setChecked(UISettings::values.check_for_update_on_start);
     ui->toggle_auto_update->setChecked(UISettings::values.update_on_close);
@@ -53,6 +54,7 @@ void ConfigureGeneral::ResetDefaults() {
 
 void ConfigureGeneral::ApplyConfiguration() {
     UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
+    UISettings::values.pause_when_in_background = ui->toggle_background_pause->isChecked();
 
     UISettings::values.check_for_update_on_start = ui->toggle_update_check->isChecked();
     UISettings::values.update_on_close = ui->toggle_auto_update->isChecked();
diff --git a/src/citra_qt/configuration/configure_general.ui b/src/citra_qt/configuration/configure_general.ui
index 0e79336255c..2a461a05dba 100644
--- a/src/citra_qt/configuration/configure_general.ui
+++ b/src/citra_qt/configuration/configure_general.ui
@@ -29,6 +29,13 @@
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QCheckBox" name="toggle_background_pause">
+          <property name="text">
+           <string>Pause emulation when in background</string>
+          </property>
+         </widget>
+        </item>
        </layout>
       </widget>
      </item>
diff --git a/src/citra_qt/configuration/configure_graphics.cpp b/src/citra_qt/configuration/configure_graphics.cpp
index ff8af9fe879..8edcdb49154 100644
--- a/src/citra_qt/configuration/configure_graphics.cpp
+++ b/src/citra_qt/configuration/configure_graphics.cpp
@@ -49,11 +49,7 @@ ConfigureGraphics::ConfigureGraphics(QWidget* parent)
         if (!new_bg_color.isValid()) {
             return;
         }
-        bg_color = new_bg_color;
-        QPixmap pixmap(ui->bg_button->size());
-        pixmap.fill(bg_color);
-        const QIcon color_icon(pixmap);
-        ui->bg_button->setIcon(color_icon);
+        UpdateBackgroundColorButton(new_bg_color);
     });
 }
 
@@ -71,12 +67,8 @@ void ConfigureGraphics::SetConfiguration() {
     ui->toggle_linear_filter->setChecked(Settings::values.filter_mode);
     ui->layout_combobox->setCurrentIndex(static_cast<int>(Settings::values.layout_option));
     ui->swap_screen->setChecked(Settings::values.swap_screen);
-    bg_color = QColor::fromRgbF(Settings::values.bg_red, Settings::values.bg_green,
-                                Settings::values.bg_blue);
-    QPixmap pixmap(ui->bg_button->size());
-    pixmap.fill(bg_color);
-    const QIcon color_icon(pixmap);
-    ui->bg_button->setIcon(color_icon);
+    UpdateBackgroundColorButton(QColor::fromRgbF(Settings::values.bg_red, Settings::values.bg_green,
+                                                 Settings::values.bg_blue));
 }
 
 void ConfigureGraphics::ApplyConfiguration() {
@@ -117,6 +109,16 @@ void ConfigureGraphics::updateShaders(bool anaglyph) {
     }
 }
 
+void ConfigureGraphics::UpdateBackgroundColorButton(const QColor& color) {
+    bg_color = color;
+
+    QPixmap pixmap(ui->bg_button->size());
+    pixmap.fill(bg_color);
+
+    const QIcon color_icon(pixmap);
+    ui->bg_button->setIcon(color_icon);
+}
+
 void ConfigureGraphics::RetranslateUI() {
     ui->retranslateUi(this);
 }
diff --git a/src/citra_qt/configuration/configure_graphics.h b/src/citra_qt/configuration/configure_graphics.h
index f2fb3b0b08a..e3e6c6a18a0 100644
--- a/src/citra_qt/configuration/configure_graphics.h
+++ b/src/citra_qt/configuration/configure_graphics.h
@@ -22,6 +22,8 @@ class ConfigureGraphics : public QWidget {
     void RetranslateUI();
     void SetConfiguration();
 
+    void UpdateBackgroundColorButton(const QColor& color);
+
     std::unique_ptr<Ui::ConfigureGraphics> ui;
     QColor bg_color;
 
diff --git a/src/citra_qt/configuration/configure_ui.ui b/src/citra_qt/configuration/configure_ui.ui
index 4af177f3e37..c9a0a659ec4 100644
--- a/src/citra_qt/configuration/configure_ui.ui
+++ b/src/citra_qt/configuration/configure_ui.ui
@@ -126,7 +126,7 @@
             </item>
             <item>
              <property name="text">
-              <string>Title Name</string>
+              <string>Title Name (short)</string>
              </property>
             </item>
             <item>
@@ -134,6 +134,11 @@
               <string>Title ID</string>
              </property>
             </item>
+            <item>
+             <property name="text">
+              <string>Title Name (long)</string>
+             </property>
+            </item>
            </widget>
           </item>
          </layout>
@@ -166,7 +171,7 @@
             </item>
             <item>
              <property name="text">
-              <string>Title Name</string>
+              <string>Title Name (short)</string>
              </property>
             </item>
             <item>
@@ -174,6 +179,11 @@
               <string>Title ID</string>
              </property>
             </item>
+            <item>
+             <property name="text">
+              <string>Title Name (long)</string>
+             </property>
+            </item>
            </widget>
           </item>
          </layout>
diff --git a/src/citra_qt/debugger/ipc/record_dialog.cpp b/src/citra_qt/debugger/ipc/record_dialog.cpp
new file mode 100644
index 00000000000..e528d2180cc
--- /dev/null
+++ b/src/citra_qt/debugger/ipc/record_dialog.cpp
@@ -0,0 +1,65 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <fmt/format.h>
+#include "citra_qt/debugger/ipc/record_dialog.h"
+#include "common/assert.h"
+#include "core/hle/kernel/ipc_debugger/recorder.h"
+#include "ui_record_dialog.h"
+
+QString RecordDialog::FormatObject(const IPCDebugger::ObjectInfo& object) const {
+    if (object.id == -1) {
+        return tr("null");
+    }
+
+    return QStringLiteral("%1 (0x%2)")
+        .arg(QString::fromStdString(object.name))
+        .arg(object.id, 8, 16, QLatin1Char('0'));
+}
+
+QString RecordDialog::FormatCmdbuf(const std::vector<u32>& cmdbuf) const {
+    QString result;
+    for (std::size_t i = 0; i < cmdbuf.size(); ++i) {
+        result.append(
+            QStringLiteral("[%1]: 0x%2\n").arg(i).arg(cmdbuf[i], 8, 16, QLatin1Char('0')));
+    }
+    return result;
+}
+
+RecordDialog::RecordDialog(QWidget* parent, const IPCDebugger::RequestRecord& record,
+                           const QString& service, const QString& function)
+    : QDialog(parent), ui(std::make_unique<Ui::RecordDialog>()) {
+
+    ui->setupUi(this);
+
+    ui->clientProcess->setText(FormatObject(record.client_process));
+    ui->clientThread->setText(FormatObject(record.client_thread));
+    ui->clientSession->setText(FormatObject(record.client_session));
+
+    ui->serverProcess->setText(FormatObject(record.server_process));
+    ui->serverThread->setText(FormatObject(record.server_thread));
+    ui->serverSession->setText(FormatObject(record.server_session));
+
+    ui->clientPort->setText(FormatObject(record.client_port));
+    ui->service->setText(std::move(service));
+    ui->function->setText(std::move(function));
+
+    cmdbufs = {record.untranslated_request_cmdbuf, record.translated_request_cmdbuf,
+               record.untranslated_reply_cmdbuf, record.translated_reply_cmdbuf};
+
+    UpdateCmdbufDisplay();
+
+    connect(ui->cmdbufSelection, qOverload<int>(&QComboBox::currentIndexChanged), this,
+            &RecordDialog::UpdateCmdbufDisplay);
+    connect(ui->okButton, &QPushButton::clicked, this, &QDialog::close);
+}
+
+RecordDialog::~RecordDialog() = default;
+
+void RecordDialog::UpdateCmdbufDisplay() {
+    int index = ui->cmdbufSelection->currentIndex();
+
+    ASSERT_MSG(0 <= index && index <= 3, "Index out of bound");
+    ui->cmdbuf->setPlainText(FormatCmdbuf(cmdbufs[index]));
+}
diff --git a/src/citra_qt/debugger/ipc/record_dialog.h b/src/citra_qt/debugger/ipc/record_dialog.h
new file mode 100644
index 00000000000..40618b92582
--- /dev/null
+++ b/src/citra_qt/debugger/ipc/record_dialog.h
@@ -0,0 +1,36 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <array>
+#include <memory>
+#include <string>
+#include <vector>
+#include <QDialog>
+#include "common/common_types.h"
+
+namespace IPCDebugger {
+struct ObjectInfo;
+struct RequestRecord;
+} // namespace IPCDebugger
+
+namespace Ui {
+class RecordDialog;
+}
+
+class RecordDialog : public QDialog {
+    Q_OBJECT
+
+public:
+    explicit RecordDialog(QWidget* parent, const IPCDebugger::RequestRecord& record,
+                          const QString& service, const QString& function);
+    ~RecordDialog() override;
+
+private:
+    QString FormatObject(const IPCDebugger::ObjectInfo& object) const;
+    QString FormatCmdbuf(const std::vector<u32>& cmdbuf) const;
+    void UpdateCmdbufDisplay();
+
+    std::unique_ptr<Ui::RecordDialog> ui;
+    std::array<std::vector<u32>, 4> cmdbufs;
+};
diff --git a/src/citra_qt/debugger/ipc/record_dialog.ui b/src/citra_qt/debugger/ipc/record_dialog.ui
new file mode 100644
index 00000000000..0f5c7a43573
--- /dev/null
+++ b/src/citra_qt/debugger/ipc/record_dialog.ui
@@ -0,0 +1,245 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RecordDialog</class>
+ <widget class="QDialog" name="RecordDialog">
+  <property name="windowTitle">
+   <string>View Record</string>
+  </property>
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>500</height>
+   </rect>
+  </property>
+  <layout class="QVBoxLayout">
+   <item>
+    <layout class="QHBoxLayout">
+     <item>
+      <widget class="QGroupBox">
+       <property name="title">
+        <string>Client</string>
+       </property>
+       <layout class="QFormLayout">
+        <item row="0" column="0">
+         <widget class="QLabel">
+          <property name="text">
+           <string>Process:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="QLineEdit" name="clientProcess">
+          <property name="readOnly">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel">
+          <property name="text">
+           <string>Thread:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="QLineEdit" name="clientThread">
+          <property name="readOnly">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <widget class="QLabel">
+          <property name="text">
+           <string>Session:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="1">
+         <widget class="QLineEdit" name="clientSession">
+          <property name="readOnly">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox">
+       <property name="title">
+        <string>Server</string>
+       </property>
+       <layout class="QFormLayout">
+        <item row="0" column="0">
+         <widget class="QLabel">
+          <property name="text">
+           <string>Process:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="0" column="1">
+         <widget class="QLineEdit" name="serverProcess">
+          <property name="readOnly">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="0">
+         <widget class="QLabel">
+          <property name="text">
+           <string>Thread:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="1" column="1">
+         <widget class="QLineEdit" name="serverThread">
+          <property name="readOnly">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="0">
+         <widget class="QLabel">
+          <property name="text">
+           <string>Session:</string>
+          </property>
+         </widget>
+        </item>
+        <item row="2" column="1">
+         <widget class="QLineEdit" name="serverSession">
+          <property name="readOnly">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QGroupBox">
+     <property name="title">
+      <string>General</string>
+     </property>
+     <layout class="QFormLayout">
+      <item row="0" column="0">
+       <widget class="QLabel">
+        <property name="text">
+         <string>Client Port:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QLineEdit" name="clientPort">
+        <property name="readOnly">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel">
+        <property name="text">
+         <string>Service:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QLineEdit" name="service">
+        <property name="readOnly">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel">
+        <property name="text">
+         <string>Function:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLineEdit" name="function">
+        <property name="readOnly">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox">
+     <property name="title">
+      <string>Command Buffer</string>
+     </property>
+     <layout class="QVBoxLayout">
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel">
+          <property name="text">
+           <string>Select:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="cmdbufSelection">
+          <item>
+           <property name="text">
+            <string>Request Untranslated</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Request Translated</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Reply Untranslated</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Reply Translated</string>
+           </property>
+          </item>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <widget class="QPlainTextEdit" name="cmdbuf">
+        <property name="readOnly">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout">
+     <item>
+      <spacer>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QPushButton" name="okButton">
+       <property name="text">
+        <string>OK</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+</ui>
diff --git a/src/citra_qt/debugger/ipc/recorder.cpp b/src/citra_qt/debugger/ipc/recorder.cpp
new file mode 100644
index 00000000000..24128e38a18
--- /dev/null
+++ b/src/citra_qt/debugger/ipc/recorder.cpp
@@ -0,0 +1,183 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <QString>
+#include <QTreeWidgetItem>
+#include <fmt/format.h>
+#include "citra_qt/debugger/ipc/record_dialog.h"
+#include "citra_qt/debugger/ipc/recorder.h"
+#include "common/assert.h"
+#include "common/string_util.h"
+#include "core/core.h"
+#include "core/hle/kernel/ipc_debugger/recorder.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/service/sm/sm.h"
+#include "ui_recorder.h"
+
+IPCRecorderWidget::IPCRecorderWidget(QWidget* parent)
+    : QDockWidget(parent), ui(std::make_unique<Ui::IPCRecorder>()) {
+
+    ui->setupUi(this);
+    qRegisterMetaType<IPCDebugger::RequestRecord>();
+
+    connect(ui->enabled, &QCheckBox::stateChanged,
+            [this](int new_state) { SetEnabled(new_state == Qt::Checked); });
+    connect(ui->clearButton, &QPushButton::clicked, this, &IPCRecorderWidget::Clear);
+    connect(ui->filter, &QLineEdit::textChanged, this, &IPCRecorderWidget::ApplyFilterToAll);
+    connect(ui->main, &QTreeWidget::itemDoubleClicked, this, &IPCRecorderWidget::OpenRecordDialog);
+    connect(this, &IPCRecorderWidget::EntryUpdated, this, &IPCRecorderWidget::OnEntryUpdated);
+}
+
+IPCRecorderWidget::~IPCRecorderWidget() = default;
+
+void IPCRecorderWidget::OnEmulationStarting() {
+    Clear();
+    id_offset = 1;
+
+    // Update the enabled status when the system is powered on.
+    SetEnabled(ui->enabled->isChecked());
+}
+
+QString IPCRecorderWidget::GetStatusStr(const IPCDebugger::RequestRecord& record) const {
+    switch (record.status) {
+    case IPCDebugger::RequestStatus::Invalid:
+        return tr("Invalid");
+    case IPCDebugger::RequestStatus::Sent:
+        return tr("Sent");
+    case IPCDebugger::RequestStatus::Handling:
+        return tr("Handling");
+    case IPCDebugger::RequestStatus::Handled:
+        if (record.translated_reply_cmdbuf[1] == RESULT_SUCCESS.raw) {
+            return tr("Success");
+        }
+        return tr("Error");
+    case IPCDebugger::RequestStatus::HLEUnimplemented:
+        return tr("HLE Unimplemented");
+    default:
+        UNREACHABLE();
+    }
+}
+
+void IPCRecorderWidget::OnEntryUpdated(IPCDebugger::RequestRecord record) {
+    if (record.id < id_offset) { // The record has already been deleted by 'Clear'
+        return;
+    }
+
+    QString service = GetServiceName(record);
+    if (record.status == IPCDebugger::RequestStatus::Handling ||
+        record.status == IPCDebugger::RequestStatus::Handled ||
+        record.status == IPCDebugger::RequestStatus::HLEUnimplemented) {
+
+        service = QStringLiteral("%1 (%2)").arg(service, record.is_hle ? tr("HLE") : tr("LLE"));
+    }
+
+    QTreeWidgetItem item{
+        {QString::number(record.id), GetStatusStr(record), service, GetFunctionName(record)}};
+
+    const int row_id = record.id - id_offset;
+    if (ui->main->invisibleRootItem()->childCount() > row_id) {
+        records[row_id] = record;
+        (*ui->main->invisibleRootItem()->child(row_id)) = item;
+    } else {
+        records.emplace_back(record);
+        ui->main->invisibleRootItem()->addChild(new QTreeWidgetItem(item));
+    }
+
+    if (record.status == IPCDebugger::RequestStatus::HLEUnimplemented ||
+        (record.status == IPCDebugger::RequestStatus::Handled &&
+         record.translated_reply_cmdbuf[1] != RESULT_SUCCESS.raw)) { // Unimplemented / Error
+
+        auto* item = ui->main->invisibleRootItem()->child(row_id);
+        for (int column = 0; column < item->columnCount(); ++column) {
+            item->setBackgroundColor(column, QColor::fromRgb(255, 0, 0));
+        }
+    }
+
+    ApplyFilter(row_id);
+}
+
+void IPCRecorderWidget::SetEnabled(bool enabled) {
+    if (!Core::System::GetInstance().IsPoweredOn()) {
+        return;
+    }
+
+    auto& ipc_recorder = Core::System::GetInstance().Kernel().GetIPCRecorder();
+    ipc_recorder.SetEnabled(enabled);
+
+    if (enabled) {
+        handle = ipc_recorder.BindCallback(
+            [this](const IPCDebugger::RequestRecord& record) { emit EntryUpdated(record); });
+    } else if (handle) {
+        ipc_recorder.UnbindCallback(handle);
+    }
+}
+
+void IPCRecorderWidget::Clear() {
+    id_offset = records.size() + 1;
+
+    records.clear();
+    ui->main->invisibleRootItem()->takeChildren();
+}
+
+QString IPCRecorderWidget::GetServiceName(const IPCDebugger::RequestRecord& record) const {
+    if (Core::System::GetInstance().IsPoweredOn() && record.client_port.id != -1) {
+        const auto service_name =
+            Core::System::GetInstance().ServiceManager().GetServiceNameByPortId(
+                static_cast<u32>(record.client_port.id));
+
+        if (!service_name.empty()) {
+            return QString::fromStdString(service_name);
+        }
+    }
+
+    // Get a similar result from the server session name
+    std::string session_name = record.server_session.name;
+    session_name = Common::ReplaceAll(session_name, "_Server", "");
+    session_name = Common::ReplaceAll(session_name, "_Client", "");
+    return QString::fromStdString(session_name);
+}
+
+QString IPCRecorderWidget::GetFunctionName(const IPCDebugger::RequestRecord& record) const {
+    if (record.untranslated_request_cmdbuf.empty()) { // Cmdbuf is not yet available
+        return tr("Unknown");
+    }
+    const QString header_code =
+        QStringLiteral("0x%1").arg(record.untranslated_request_cmdbuf[0], 8, 16, QLatin1Char('0'));
+    if (record.function_name.empty()) {
+        return header_code;
+    }
+    return QStringLiteral("%1 (%2)").arg(QString::fromStdString(record.function_name), header_code);
+}
+
+void IPCRecorderWidget::ApplyFilter(int index) {
+    auto* item = ui->main->invisibleRootItem()->child(index);
+    const QString filter = ui->filter->text();
+    if (filter.isEmpty()) {
+        item->setHidden(false);
+        return;
+    }
+
+    for (int i = 0; i < item->columnCount(); ++i) {
+        if (item->text(i).contains(filter)) {
+            item->setHidden(false);
+            return;
+        }
+    }
+
+    item->setHidden(true);
+}
+
+void IPCRecorderWidget::ApplyFilterToAll() {
+    for (int i = 0; i < ui->main->invisibleRootItem()->childCount(); ++i) {
+        ApplyFilter(i);
+    }
+}
+
+void IPCRecorderWidget::OpenRecordDialog(QTreeWidgetItem* item, [[maybe_unused]] int column) {
+    int index = ui->main->invisibleRootItem()->indexOfChild(item);
+
+    RecordDialog dialog(this, records[static_cast<std::size_t>(index)], item->text(2),
+                        item->text(3));
+    dialog.exec();
+}
diff --git a/src/citra_qt/debugger/ipc/recorder.h b/src/citra_qt/debugger/ipc/recorder.h
new file mode 100644
index 00000000000..63b19079011
--- /dev/null
+++ b/src/citra_qt/debugger/ipc/recorder.h
@@ -0,0 +1,52 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <QDockWidget>
+#include "core/hle/kernel/ipc_debugger/recorder.h"
+
+class QTreeWidgetItem;
+
+namespace Ui {
+class IPCRecorder;
+}
+
+class IPCRecorderWidget : public QDockWidget {
+    Q_OBJECT
+
+public:
+    explicit IPCRecorderWidget(QWidget* parent = nullptr);
+    ~IPCRecorderWidget();
+
+    void OnEmulationStarting();
+
+signals:
+    void EntryUpdated(IPCDebugger::RequestRecord record);
+
+private:
+    QString GetStatusStr(const IPCDebugger::RequestRecord& record) const;
+    void OnEntryUpdated(IPCDebugger::RequestRecord record);
+    void SetEnabled(bool enabled);
+    void Clear();
+    void ApplyFilter(int index);
+    void ApplyFilterToAll();
+    QString GetServiceName(const IPCDebugger::RequestRecord& record) const;
+    QString GetFunctionName(const IPCDebugger::RequestRecord& record) const;
+    void OpenRecordDialog(QTreeWidgetItem* item, int column);
+
+    std::unique_ptr<Ui::IPCRecorder> ui;
+    IPCDebugger::CallbackHandle handle;
+
+    // The offset between record id and row id, assuming record ids are assigned
+    // continuously and only the 'Clear' action can be performed, this is enough.
+    // The initial value is 1, which means record 1 = row 0.
+    int id_offset = 1;
+    std::vector<IPCDebugger::RequestRecord> records;
+};
+
+Q_DECLARE_METATYPE(IPCDebugger::RequestRecord);
diff --git a/src/citra_qt/debugger/ipc/recorder.ui b/src/citra_qt/debugger/ipc/recorder.ui
new file mode 100644
index 00000000000..78b988fdca3
--- /dev/null
+++ b/src/citra_qt/debugger/ipc/recorder.ui
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>IPCRecorder</class>
+ <widget class="QDockWidget" name="IPCRecorder">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>600</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>IPC Recorder</string>
+  </property>
+  <widget class="QWidget">
+   <layout class="QVBoxLayout">
+    <item>
+     <widget class="QCheckBox" name="enabled">
+      <property name="text">
+       <string>Enable Recording</string>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout">
+      <item>
+       <widget class="QLabel">
+        <property name="text">
+         <string>Filter:</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLineEdit" name="filter">
+        <property name="placeholderText">
+         <string>Leave empty to disable filtering</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+    <item>
+     <widget class="QTreeWidget" name="main">
+      <property name="alternatingRowColors">
+       <bool>true</bool>
+      </property>
+      <column>
+       <property name="text">
+        <string>#</string>
+       </property>
+      </column>
+      <column>
+       <property name="text">
+        <string>Status</string>
+       </property>
+      </column>
+      <column>
+       <property name="text">
+        <string>Service</string>
+       </property>
+      </column>
+      <column>
+       <property name="text">
+        <string>Function</string>
+       </property>
+      </column>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout">
+      <item>
+       <spacer>
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QPushButton" name="clearButton">
+        <property name="text">
+         <string>Clear</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/src/citra_qt/game_list.cpp b/src/citra_qt/game_list.cpp
index 0f0325ca263..933077a7e9f 100644
--- a/src/citra_qt/game_list.cpp
+++ b/src/citra_qt/game_list.cpp
@@ -99,16 +99,16 @@ void GameListSearchField::setFilterResult(int visible, int total) {
         QString("%1 %2 %3 %4").arg(visible).arg(result_of_text).arg(total).arg(result_text));
 }
 
-QString GameList::getLastFilterResultItem() {
+QString GameList::getLastFilterResultItem() const {
     QStandardItem* folder;
     QStandardItem* child;
     QString file_path;
-    int folderCount = item_model->rowCount();
+    const int folderCount = item_model->rowCount();
     for (int i = 0; i < folderCount; ++i) {
         folder = item_model->item(i, 0);
-        QModelIndex folder_index = folder->index();
-        int childrenCount = folder->rowCount();
-        for (int j = 0; j < childrenCount; ++j) {
+        const QModelIndex folder_index = folder->index();
+        const int children_count = folder->rowCount();
+        for (int j = 0; j < children_count; ++j) {
             if (!tree_view->isRowHidden(j, folder_index)) {
                 child = folder->child(j, 0);
                 file_path = child->data(GameListItemPath::FullPathRole).toString();
@@ -175,7 +175,7 @@ static bool ContainsAllWords(const QString& haystack, const QString& userinput)
 
 // Syncs the expanded state of Game Directories with settings to persist across sessions
 void GameList::onItemExpanded(const QModelIndex& item) {
-    GameListItemType type = item.data(GameListItem::TypeRole).value<GameListItemType>();
+    const auto type = item.data(GameListItem::TypeRole).value<GameListItemType>();
     if (type == GameListItemType::CustomDir || type == GameListItemType::InstalledDir ||
         type == GameListItemType::SystemDir)
         item.data(GameListDir::GameDirRole).value<UISettings::GameDir*>()->expanded =
@@ -184,38 +184,38 @@ void GameList::onItemExpanded(const QModelIndex& item) {
 
 // Event in order to filter the gamelist after editing the searchfield
 void GameList::onTextChanged(const QString& newText) {
-    int folderCount = tree_view->model()->rowCount();
+    const int folderCount = tree_view->model()->rowCount();
     QString edit_filter_text = newText.toLower();
     QStandardItem* folder;
-    int childrenTotal = 0;
+    int children_total = 0;
 
     // If the searchfield is empty every item is visible
     // Otherwise the filter gets applied
     if (edit_filter_text.isEmpty()) {
         for (int i = 0; i < folderCount; ++i) {
             folder = item_model->item(i, 0);
-            QModelIndex folder_index = folder->index();
-            int childrenCount = folder->rowCount();
-            for (int j = 0; j < childrenCount; ++j) {
-                ++childrenTotal;
+            const QModelIndex folder_index = folder->index();
+            const int children_count = folder->rowCount();
+            for (int j = 0; j < children_count; ++j) {
+                ++children_total;
                 tree_view->setRowHidden(j, folder_index, false);
             }
         }
-        search_field->setFilterResult(childrenTotal, childrenTotal);
+        search_field->setFilterResult(children_total, children_total);
     } else {
         int result_count = 0;
         for (int i = 0; i < folderCount; ++i) {
             folder = item_model->item(i, 0);
-            QModelIndex folder_index = folder->index();
-            int childrenCount = folder->rowCount();
-            for (int j = 0; j < childrenCount; ++j) {
-                ++childrenTotal;
+            const QModelIndex folder_index = folder->index();
+            const int children_count = folder->rowCount();
+            for (int j = 0; j < children_count; ++j) {
+                ++children_total;
                 const QStandardItem* child = folder->child(j, 0);
                 const QString file_path =
                     child->data(GameListItemPath::FullPathRole).toString().toLower();
                 QString file_name = file_path.mid(file_path.lastIndexOf("/") + 1);
                 const QString file_title =
-                    child->data(GameListItemPath::TitleRole).toString().toLower();
+                    child->data(GameListItemPath::LongTitleRole).toString().toLower();
                 const QString file_programmid =
                     child->data(GameListItemPath::ProgramIdRole).toString().toLower();
 
@@ -231,7 +231,7 @@ void GameList::onTextChanged(const QString& newText) {
                 } else {
                     tree_view->setRowHidden(j, folder_index, true);
                 }
-                search_field->setFilterResult(result_count, childrenTotal);
+                search_field->setFilterResult(result_count, children_total);
             }
         }
     }
@@ -251,7 +251,7 @@ void GameList::onUpdateThemedIcons() {
         case GameListItemType::CustomDir: {
             const UISettings::GameDir* game_dir =
                 child->data(GameListDir::GameDirRole).value<UISettings::GameDir*>();
-            QString icon_name = QFileInfo::exists(game_dir->path) ? "folder" : "bad_folder";
+            const QString icon_name = QFileInfo::exists(game_dir->path) ? "folder" : "bad_folder";
             child->setData(QIcon::fromTheme(icon_name).pixmap(48), Qt::DecorationRole);
             break;
         }
@@ -353,14 +353,14 @@ void GameList::AddEntry(const QList<QStandardItem*>& entry_items, GameListDir* p
 }
 
 void GameList::ValidateEntry(const QModelIndex& item) {
-    auto selected = item.sibling(item.row(), 0);
+    const auto selected = item.sibling(item.row(), 0);
 
     switch (selected.data(GameListItem::TypeRole).value<GameListItemType>()) {
     case GameListItemType::Game: {
-        QString file_path = selected.data(GameListItemPath::FullPathRole).toString();
+        const QString file_path = selected.data(GameListItemPath::FullPathRole).toString();
         if (file_path.isEmpty())
             return;
-        QFileInfo file_info(file_path);
+        const QFileInfo file_info(file_path);
         if (!file_info.exists() || file_info.isDir())
             return;
         // Users usually want to run a different game after closing one
@@ -374,10 +374,10 @@ void GameList::ValidateEntry(const QModelIndex& item) {
     }
 }
 
-bool GameList::isEmpty() {
+bool GameList::isEmpty() const {
     for (int i = 0; i < item_model->rowCount(); i++) {
         const QStandardItem* child = item_model->invisibleRootItem()->child(i);
-        GameListItemType type = static_cast<GameListItemType>(child->type());
+        const auto type = static_cast<GameListItemType>(child->type());
         if (!child->hasChildren() &&
             (type == GameListItemType::InstalledDir || type == GameListItemType::SystemDir)) {
             item_model->invisibleRootItem()->removeRow(child->row());
@@ -408,16 +408,13 @@ void GameList::DonePopulating(QStringList watch_list) {
         QCoreApplication::processEvents();
     }
     tree_view->setEnabled(true);
-    int folderCount = tree_view->model()->rowCount();
-    int childrenTotal = 0;
+    const int folderCount = tree_view->model()->rowCount();
+    int children_total = 0;
     for (int i = 0; i < folderCount; ++i) {
-        int childrenCount = item_model->item(i, 0)->rowCount();
-        for (int j = 0; j < childrenCount; ++j) {
-            ++childrenTotal;
-        }
+        children_total += item_model->item(i, 0)->rowCount();
     }
-    search_field->setFilterResult(childrenTotal, childrenTotal);
-    if (childrenTotal > 0) {
+    search_field->setFilterResult(children_total, children_total);
+    if (children_total > 0) {
         search_field->setFocus();
     }
 
@@ -429,7 +426,7 @@ void GameList::PopupContextMenu(const QPoint& menu_location) {
     if (!item.isValid())
         return;
 
-    auto selected = item.sibling(item.row(), 0);
+    const auto selected = item.sibling(item.row(), 0);
     QMenu context_menu;
     switch (selected.data(GameListItem::TypeRole).value<GameListItemType>()) {
     case GameListItemType::Game:
@@ -528,18 +525,18 @@ void GameList::AddPermDirPopup(QMenu& context_menu, QModelIndex selected) {
     QAction* move_down = context_menu.addAction(tr(u8"\U000025bc Move Down "));
     QAction* open_directory_location = context_menu.addAction(tr("Open Directory Location"));
 
-    int row = selected.row();
+    const int row = selected.row();
 
     move_up->setEnabled(row > 0);
     move_down->setEnabled(row < item_model->rowCount() - 2);
 
     connect(move_up, &QAction::triggered, [this, selected, row, &game_dir] {
         // find the indices of the items in settings and swap them
-        UISettings::values.game_dirs.swap(
-            UISettings::values.game_dirs.indexOf(game_dir),
-            UISettings::values.game_dirs.indexOf(*selected.sibling(selected.row() - 1, 0)
-                                                      .data(GameListDir::GameDirRole)
-                                                      .value<UISettings::GameDir*>()));
+        std::swap(UISettings::values.game_dirs[UISettings::values.game_dirs.indexOf(game_dir)],
+                  UISettings::values.game_dirs[UISettings::values.game_dirs.indexOf(
+                      *selected.sibling(row - 1, 0)
+                           .data(GameListDir::GameDirRole)
+                           .value<UISettings::GameDir*>())]);
         // move the treeview items
         QList<QStandardItem*> item = item_model->takeRow(row);
         item_model->invisibleRootItem()->insertRow(row - 1, item);
@@ -548,13 +545,13 @@ void GameList::AddPermDirPopup(QMenu& context_menu, QModelIndex selected) {
 
     connect(move_down, &QAction::triggered, [this, selected, row, &game_dir] {
         // find the indices of the items in settings and swap them
-        UISettings::values.game_dirs.swap(
-            UISettings::values.game_dirs.indexOf(game_dir),
-            UISettings::values.game_dirs.indexOf(*selected.sibling(selected.row() + 1, 0)
-                                                      .data(GameListDir::GameDirRole)
-                                                      .value<UISettings::GameDir*>()));
+        std::swap(UISettings::values.game_dirs[UISettings::values.game_dirs.indexOf(game_dir)],
+                  UISettings::values.game_dirs[UISettings::values.game_dirs.indexOf(
+                      *selected.sibling(row + 1, 0)
+                           .data(GameListDir::GameDirRole)
+                           .value<UISettings::GameDir*>())]);
         // move the treeview items
-        QList<QStandardItem*> item = item_model->takeRow(row);
+        const QList<QStandardItem*> item = item_model->takeRow(row);
         item_model->invisibleRootItem()->insertRow(row + 1, item);
         tree_view->setExpanded(selected, game_dir.expanded);
     });
@@ -609,7 +606,7 @@ QStandardItemModel* GameList::GetModel() const {
     return item_model;
 }
 
-void GameList::PopulateAsync(QList<UISettings::GameDir>& game_dirs) {
+void GameList::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
     tree_view->setEnabled(false);
     // Delete any rows that might already exist if we're repopulating
     item_model->removeRows(0, item_model->rowCount());
@@ -677,9 +674,7 @@ QString GameList::FindGameByProgramID(QStandardItem* current_item, u64 program_i
 }
 
 GameListPlaceholder::GameListPlaceholder(GMainWindow* parent) : QWidget{parent} {
-    this->main_window = parent;
-
-    connect(main_window, &GMainWindow::UpdateThemedIcons, this,
+    connect(parent, &GMainWindow::UpdateThemedIcons, this,
             &GameListPlaceholder::onUpdateThemedIcons);
 
     layout = new QVBoxLayout;
@@ -688,7 +683,7 @@ GameListPlaceholder::GameListPlaceholder(GMainWindow* parent) : QWidget{parent}
     layout->setAlignment(Qt::AlignCenter);
     image->setPixmap(QIcon::fromTheme("plus_folder").pixmap(200));
 
-    text->setText(tr("Double-click to add a new folder to the game list "));
+    text->setText(tr("Double-click to add a new folder to the game list"));
     QFont font = text->font();
     font.setPointSize(20);
     text->setFont(font);
diff --git a/src/citra_qt/game_list.h b/src/citra_qt/game_list.h
index 2797dd09db4..bef23f31be8 100644
--- a/src/citra_qt/game_list.h
+++ b/src/citra_qt/game_list.h
@@ -6,6 +6,7 @@
 
 #include <QMenu>
 #include <QString>
+#include <QVector>
 #include <QWidget>
 #include "citra_qt/compatibility_list.h"
 #include "common/common_types.h"
@@ -46,15 +47,15 @@ class GameList : public QWidget {
     explicit GameList(GMainWindow* parent = nullptr);
     ~GameList() override;
 
-    QString getLastFilterResultItem();
+    QString getLastFilterResultItem() const;
     void clearFilter();
     void setFilterFocus();
     void setFilterVisible(bool visibility);
     void setDirectoryWatcherEnabled(bool enabled);
-    bool isEmpty();
+    bool isEmpty() const;
 
     void LoadCompatibilityList();
-    void PopulateAsync(QList<UISettings::GameDir>& game_dirs);
+    void PopulateAsync(QVector<UISettings::GameDir>& game_dirs);
 
     void SaveInterfaceLayout();
     void LoadInterfaceLayout();
@@ -73,7 +74,7 @@ class GameList : public QWidget {
     void OpenFolderRequested(u64 program_id, GameListOpenTarget target);
     void NavigateToGamedbEntryRequested(u64 program_id,
                                         const CompatibilityList& compatibility_list);
-    void OpenDirectory(QString directory);
+    void OpenDirectory(const QString& directory);
     void AddDirectory();
     void ShowList(bool show);
     void PopulatingCompleted();
@@ -127,7 +128,6 @@ private slots:
     void mouseDoubleClickEvent(QMouseEvent* event) override;
 
 private:
-    GMainWindow* main_window = nullptr;
     QVBoxLayout* layout = nullptr;
     QLabel* image = nullptr;
     QLabel* text = nullptr;
diff --git a/src/citra_qt/game_list_p.h b/src/citra_qt/game_list_p.h
index c03c073b33b..fb64c34c0cd 100644
--- a/src/citra_qt/game_list_p.h
+++ b/src/citra_qt/game_list_p.h
@@ -70,6 +70,17 @@ static QString GetQStringShortTitleFromSMDH(const Loader::SMDH& smdh,
     return QString::fromUtf16(smdh.GetShortTitle(language).data());
 }
 
+/**
+ * Gets the long game title from SMDH data.
+ * @param smdh SMDH data
+ * @param language title language
+ * @return QString long title
+ */
+static QString GetQStringLongTitleFromSMDH(const Loader::SMDH& smdh,
+                                           Loader::SMDH::TitleLanguage language) {
+    return QString::fromUtf16(smdh.GetLongTitle(language).data());
+}
+
 /**
  * Gets the game region from SMDH data.
  * @param smdh SMDH data
@@ -139,6 +150,7 @@ class GameListItemPath : public GameListItem {
     static const int FullPathRole = SortRole + 1;
     static const int ProgramIdRole = SortRole + 2;
     static const int ExtdataIdRole = SortRole + 3;
+    static const int LongTitleRole = SortRole + 4;
 
     GameListItemPath() = default;
     GameListItemPath(const QString& game_path, const std::vector<u8>& smdh_data, u64 program_id,
@@ -173,6 +185,10 @@ class GameListItemPath : public GameListItem {
         // Get title from SMDH
         setData(GetQStringShortTitleFromSMDH(smdh, Loader::SMDH::TitleLanguage::English),
                 TitleRole);
+
+        // Get long title from SMDH
+        setData(GetQStringLongTitleFromSMDH(smdh, Loader::SMDH::TitleLanguage::English),
+                LongTitleRole);
     }
 
     int type() const override {
@@ -189,11 +205,12 @@ class GameListItemPath : public GameListItem {
                 {UISettings::GameListText::FileName, QString::fromStdString(filename + extension)},
                 {UISettings::GameListText::FullPath, data(FullPathRole).toString()},
                 {UISettings::GameListText::TitleName, data(TitleRole).toString()},
+                {UISettings::GameListText::LongTitleName, data(LongTitleRole).toString()},
                 {UISettings::GameListText::TitleID,
                  QString::fromStdString(fmt::format("{:016X}", data(ProgramIdRole).toULongLong()))},
             };
 
-            const QString& row1 = display_texts.at(UISettings::values.game_list_row_1);
+            const QString& row1 = display_texts.at(UISettings::values.game_list_row_1).simplified();
 
             QString row2;
             auto row_2_id = UISettings::values.game_list_row_2;
@@ -203,7 +220,7 @@ class GameListItemPath : public GameListItem {
                                ? QStringLiteral("     ")
                                : QStringLiteral("\n     ");
                 }
-                row2 += display_texts.at(row_2_id);
+                row2 += display_texts.at(row_2_id).simplified();
             }
             return QString(row1 + row2);
         } else {
@@ -333,18 +350,20 @@ class GameListDir : public GameListItem {
         UISettings::GameDir* game_dir = &directory;
         setData(QVariant::fromValue(game_dir), GameDirRole);
 
-        int icon_size = IconSizes.at(UISettings::values.game_list_icon_size);
+        const int icon_size = IconSizes.at(UISettings::values.game_list_icon_size);
         switch (dir_type) {
         case GameListItemType::InstalledDir:
-            setData(QIcon::fromTheme("sd_card").pixmap(icon_size), Qt::DecorationRole);
-            setData("Installed Titles", Qt::DisplayRole);
+            setData(QIcon::fromTheme(QStringLiteral("sd_card")).pixmap(icon_size),
+                    Qt::DecorationRole);
+            setData(QObject::tr("Installed Titles"), Qt::DisplayRole);
             break;
         case GameListItemType::SystemDir:
-            setData(QIcon::fromTheme("chip").pixmap(icon_size), Qt::DecorationRole);
-            setData("System Titles", Qt::DisplayRole);
+            setData(QIcon::fromTheme(QStringLiteral("chip")).pixmap(icon_size), Qt::DecorationRole);
+            setData(QObject::tr("System Titles"), Qt::DisplayRole);
             break;
         case GameListItemType::CustomDir:
-            QString icon_name = QFileInfo::exists(game_dir->path) ? "folder" : "bad_folder";
+            QString icon_name = QFileInfo::exists(game_dir->path) ? QStringLiteral("folder")
+                                                                  : QStringLiteral("bad_folder");
             setData(QIcon::fromTheme(icon_name).pixmap(icon_size), Qt::DecorationRole);
             setData(game_dir->path, Qt::DisplayRole);
             break;
@@ -365,8 +384,8 @@ class GameListAddDir : public GameListItem {
         setData(type(), TypeRole);
 
         int icon_size = IconSizes.at(UISettings::values.game_list_icon_size);
-        setData(QIcon::fromTheme("plus").pixmap(icon_size), Qt::DecorationRole);
-        setData("Add New Game Directory", Qt::DisplayRole);
+        setData(QIcon::fromTheme(QStringLiteral("plus")).pixmap(icon_size), Qt::DecorationRole);
+        setData(QObject::tr("Add New Game Directory"), Qt::DisplayRole);
     }
 
     int type() const override {
@@ -392,9 +411,6 @@ class GameListSearchField : public QWidget {
     void clear();
     void setFocus();
 
-    int visible;
-    int total;
-
 private:
     class KeyReleaseEater : public QObject {
     public:
@@ -408,6 +424,9 @@ class GameListSearchField : public QWidget {
         // EventFilter in order to process systemkeys while editing the searchfield
         bool eventFilter(QObject* obj, QEvent* event) override;
     };
+    int visible;
+    int total;
+
     QHBoxLayout* layout_filter = nullptr;
     QTreeView* tree_view = nullptr;
     QLabel* label_filter = nullptr;
diff --git a/src/citra_qt/game_list_worker.cpp b/src/citra_qt/game_list_worker.cpp
index 42d748ece32..13ba8c676fd 100644
--- a/src/citra_qt/game_list_worker.cpp
+++ b/src/citra_qt/game_list_worker.cpp
@@ -26,7 +26,7 @@ bool HasSupportedFileExtension(const std::string& file_name) {
 }
 } // Anonymous namespace
 
-GameListWorker::GameListWorker(QList<UISettings::GameDir>& game_dirs,
+GameListWorker::GameListWorker(QVector<UISettings::GameDir>& game_dirs,
                                const CompatibilityList& compatibility_list)
     : game_dirs(game_dirs), compatibility_list(compatibility_list) {}
 
@@ -134,7 +134,7 @@ void GameListWorker::run() {
                 "00040002";
             watch_list.append(games_path);
             watch_list.append(demos_path);
-            GameListDir* game_list_dir = new GameListDir(game_dir, GameListItemType::InstalledDir);
+            auto* const game_list_dir = new GameListDir(game_dir, GameListItemType::InstalledDir);
             emit DirEntryReady({game_list_dir});
             AddFstEntriesToGameList(games_path.toStdString(), 2, game_list_dir);
             AddFstEntriesToGameList(demos_path.toStdString(), 2, game_list_dir);
@@ -143,12 +143,12 @@ void GameListWorker::run() {
                 QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)) +
                 "00000000000000000000000000000000/title/00040010";
             watch_list.append(path);
-            GameListDir* game_list_dir = new GameListDir(game_dir, GameListItemType::SystemDir);
+            auto* const game_list_dir = new GameListDir(game_dir, GameListItemType::SystemDir);
             emit DirEntryReady({game_list_dir});
             AddFstEntriesToGameList(path.toStdString(), 2, game_list_dir);
         } else {
             watch_list.append(game_dir.path);
-            GameListDir* game_list_dir = new GameListDir(game_dir);
+            auto* const game_list_dir = new GameListDir(game_dir);
             emit DirEntryReady({game_list_dir});
             AddFstEntriesToGameList(game_dir.path.toStdString(), game_dir.deep_scan ? 256 : 0,
                                     game_list_dir);
diff --git a/src/citra_qt/game_list_worker.h b/src/citra_qt/game_list_worker.h
index a955e6376a6..91adbd21281 100644
--- a/src/citra_qt/game_list_worker.h
+++ b/src/citra_qt/game_list_worker.h
@@ -13,6 +13,7 @@
 #include <QObject>
 #include <QRunnable>
 #include <QString>
+#include <QVector>
 #include "citra_qt/compatibility_list.h"
 #include "common/common_types.h"
 
@@ -26,7 +27,7 @@ class GameListWorker : public QObject, public QRunnable {
     Q_OBJECT
 
 public:
-    GameListWorker(QList<UISettings::GameDir>& game_dirs,
+    GameListWorker(QVector<UISettings::GameDir>& game_dirs,
                    const CompatibilityList& compatibility_list);
     ~GameListWorker() override;
 
@@ -57,6 +58,6 @@ class GameListWorker : public QObject, public QRunnable {
 
     QStringList watch_list;
     const CompatibilityList& compatibility_list;
-    QList<UISettings::GameDir>& game_dirs;
+    QVector<UISettings::GameDir>& game_dirs;
     std::atomic_bool stop_processing;
 };
diff --git a/src/citra_qt/main.cpp b/src/citra_qt/main.cpp
index 3e8889f75fd..e94b73cfcf5 100644
--- a/src/citra_qt/main.cpp
+++ b/src/citra_qt/main.cpp
@@ -11,6 +11,7 @@
 #include <QFileDialog>
 #include <QFutureWatcher>
 #include <QMessageBox>
+#include <QSysInfo>
 #include <QtConcurrent/QtConcurrentRun>
 #include <QtGui>
 #include <QtWidgets>
@@ -39,6 +40,7 @@
 #include "citra_qt/debugger/graphics/graphics_surface.h"
 #include "citra_qt/debugger/graphics/graphics_tracing.h"
 #include "citra_qt/debugger/graphics/graphics_vertex_shader.h"
+#include "citra_qt/debugger/ipc/recorder.h"
 #include "citra_qt/debugger/lle_service_modules.h"
 #include "citra_qt/debugger/profiler.h"
 #include "citra_qt/debugger/registers.h"
@@ -61,6 +63,9 @@
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
 #include "common/scope_exit.h"
+#ifdef ARCHITECTURE_x86_64
+#include "common/x64/cpu_detect.h"
+#endif
 #include "core/core.h"
 #include "core/file_sys/archive_extsavedata.h"
 #include "core/file_sys/archive_source_sd_savedata.h"
@@ -166,6 +171,10 @@ GMainWindow::GMainWindow() : config(new Config()), emu_thread(nullptr) {
 
     LOG_INFO(Frontend, "Citra Version: {} | {}-{}", Common::g_build_fullname, Common::g_scm_branch,
              Common::g_scm_desc);
+#ifdef ARCHITECTURE_x86_64
+    LOG_INFO(Frontend, "Host CPU: {}", Common::GetCPUCaps().cpu_string);
+#endif
+    LOG_INFO(Frontend, "Host OS: {}", QSysInfo::prettyProductName().toStdString());
     UpdateWindowTitle();
 
     show();
@@ -328,6 +337,13 @@ void GMainWindow::InitializeDebugWidgets() {
             [this] { lleServiceModulesWidget->setDisabled(true); });
     connect(this, &GMainWindow::EmulationStopping, waitTreeWidget,
             [this] { lleServiceModulesWidget->setDisabled(false); });
+
+    ipcRecorderWidget = new IPCRecorderWidget(this);
+    addDockWidget(Qt::RightDockWidgetArea, ipcRecorderWidget);
+    ipcRecorderWidget->hide();
+    debug_menu->addAction(ipcRecorderWidget->toggleViewAction());
+    connect(this, &GMainWindow::EmulationStarting, ipcRecorderWidget,
+            &IPCRecorderWidget::OnEmulationStarting);
 }
 
 void GMainWindow::InitializeRecentFileMenuActions() {
@@ -496,6 +512,24 @@ void GMainWindow::RestoreUIState() {
     statusBar()->setVisible(ui.action_Show_Status_Bar->isChecked());
 }
 
+void GMainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
+    if (!UISettings::values.pause_when_in_background) {
+        return;
+    }
+    if (state != Qt::ApplicationHidden && state != Qt::ApplicationInactive &&
+        state != Qt::ApplicationActive) {
+        LOG_DEBUG(Frontend, "ApplicationState unusual flag: {} ", state);
+    }
+    if (ui.action_Pause->isEnabled() &&
+        (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
+        auto_paused = true;
+        OnPauseGame();
+    } else if (ui.action_Start->isEnabled() && auto_paused && state == Qt::ApplicationActive) {
+        auto_paused = false;
+        OnStartGame();
+    }
+}
+
 void GMainWindow::ConnectWidgetEvents() {
     connect(game_list, &GameList::GameChosen, this, &GMainWindow::OnGameListLoadFile);
     connect(game_list, &GameList::OpenDirectory, this, &GMainWindow::OnGameListOpenDirectory);
@@ -1048,18 +1082,16 @@ void GMainWindow::OnGameListNavigateToGamedbEntry(u64 program_id,
     QDesktopServices::openUrl(QUrl("https://citra-emu.org/game/" + directory));
 }
 
-void GMainWindow::OnGameListOpenDirectory(QString directory) {
+void GMainWindow::OnGameListOpenDirectory(const QString& directory) {
     QString path;
     if (directory == "INSTALLED") {
-        path =
-            QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir).c_str() +
-                                   std::string("Nintendo "
-                                               "3DS/00000000000000000000000000000000/"
-                                               "00000000000000000000000000000000/title/00040000"));
+        path = QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir) +
+                                      "Nintendo "
+                                      "3DS/00000000000000000000000000000000/"
+                                      "00000000000000000000000000000000/title/00040000");
     } else if (directory == "SYSTEM") {
-        path =
-            QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir).c_str() +
-                                   std::string("00000000000000000000000000000000/title/00040010"));
+        path = QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
+                                      "00000000000000000000000000000000/title/00040010");
     } else {
         path = directory;
     }
@@ -1071,7 +1103,7 @@ void GMainWindow::OnGameListOpenDirectory(QString directory) {
 }
 
 void GMainWindow::OnGameListAddDirectory() {
-    QString dir_path = QFileDialog::getExistingDirectory(this, tr("Select Directory"));
+    const QString dir_path = QFileDialog::getExistingDirectory(this, tr("Select Directory"));
     if (dir_path.isEmpty())
         return;
     UISettings::GameDir game_dir{dir_path, false, true};
@@ -1939,6 +1971,10 @@ int main(int argc, char* argv[]) {
     Core::System::GetInstance().RegisterSoftwareKeyboard(std::make_shared<QtKeyboard>(main_window));
 
     main_window.show();
+
+    QObject::connect(&app, &QGuiApplication::applicationStateChanged, &main_window,
+                     &GMainWindow::OnAppFocusStateChanged);
+
     int result = app.exec();
     detached_tasks.WaitForAllTasks();
     return result;
diff --git a/src/citra_qt/main.h b/src/citra_qt/main.h
index 9322f0403d1..eb14c725177 100644
--- a/src/citra_qt/main.h
+++ b/src/citra_qt/main.h
@@ -30,6 +30,7 @@ class GraphicsBreakPointsWidget;
 class GraphicsTracingWidget;
 class GraphicsVertexShaderWidget;
 class GRenderWindow;
+class IPCRecorderWidget;
 class LLEServiceModulesWidget;
 class MicroProfileDialog;
 class MultiplayerState;
@@ -68,6 +69,8 @@ class GMainWindow : public QMainWindow {
     GameList* game_list;
     std::unique_ptr<DiscordRPC::DiscordInterface> discord_rpc;
 
+public slots:
+    void OnAppFocusStateChanged(Qt::ApplicationState state);
 signals:
 
     /**
@@ -158,7 +161,7 @@ private slots:
     void OnGameListOpenFolder(u64 program_id, GameListOpenTarget target);
     void OnGameListNavigateToGamedbEntry(u64 program_id,
                                          const CompatibilityList& compatibility_list);
-    void OnGameListOpenDirectory(QString path);
+    void OnGameListOpenDirectory(const QString& directory);
     void OnGameListAddDirectory();
     void OnGameListShowList(bool show);
     void OnMenuLoadFile();
@@ -229,6 +232,8 @@ private slots:
     // The path to the game currently running
     QString game_path;
 
+    bool auto_paused = false;
+
     // Movie
     bool movie_record_on_start = false;
     QString movie_record_path;
@@ -242,6 +247,7 @@ private slots:
     GraphicsBreakPointsWidget* graphicsBreakpointsWidget;
     GraphicsVertexShaderWidget* graphicsVertexShaderWidget;
     GraphicsTracingWidget* graphicsTracingWidget;
+    IPCRecorderWidget* ipcRecorderWidget;
     LLEServiceModulesWidget* lleServiceModulesWidget;
     WaitTreeWidget* waitTreeWidget;
     Updater* updater;
diff --git a/src/citra_qt/uisettings.h b/src/citra_qt/uisettings.h
index 2beac50c2b1..49d383481f5 100644
--- a/src/citra_qt/uisettings.h
+++ b/src/citra_qt/uisettings.h
@@ -12,6 +12,7 @@
 #include <QMetaType>
 #include <QString>
 #include <QStringList>
+#include <QVector>
 #include "common/common_types.h"
 
 namespace UISettings {
@@ -46,11 +47,13 @@ enum class GameListIconSize {
 };
 
 enum class GameListText {
-    NoText = -1, ///< No text
-    FileName,    ///< Display the file name of the entry
-    FullPath,    ///< Display the full path of the entry
-    TitleName,   ///< Display the name of the title
-    TitleID,     ///< Display the title ID
+    NoText = -1,   ///< No text
+    FileName,      ///< Display the file name of the entry
+    FullPath,      ///< Display the full path of the entry
+    TitleName,     ///< Display the name of the title
+    TitleID,       ///< Display the title ID
+    LongTitleName, ///< Display the long name of the title
+    ListEnd,       ///< Keep this at the end of the enum.
 };
 
 struct Values {
@@ -72,6 +75,7 @@ struct Values {
 
     bool confirm_before_closing;
     bool first_start;
+    bool pause_when_in_background;
 
     bool updater_found;
     bool update_on_close;
@@ -96,7 +100,7 @@ struct Values {
     QString screenshot_path;
     QString game_dir_deprecated;
     bool game_dir_deprecated_deepscan;
-    QList<UISettings::GameDir> game_dirs;
+    QVector<UISettings::GameDir> game_dirs;
     QStringList recent_files;
     QString language;
 
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index ba970673751..f2674573749 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -58,6 +58,7 @@ add_library(common STATIC
     common_types.h
     file_util.cpp
     file_util.h
+    hash.cpp
     hash.h
     linear_disk_cache.h
     logging/backend.cpp
@@ -98,7 +99,6 @@ if(ARCHITECTURE_x86_64)
     target_sources(common
         PRIVATE
             x64/cpu_detect.cpp
-
             x64/cpu_detect.h
             x64/xbyak_abi.h
             x64/xbyak_util.h
diff --git a/src/common/hash.cpp b/src/common/hash.cpp
new file mode 100644
index 00000000000..2fc635184b0
--- /dev/null
+++ b/src/common/hash.cpp
@@ -0,0 +1,51 @@
+// Copyright 2015 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/common_types.h"
+#include "common/hash.h"
+
+#ifdef _M_ARM64
+// Arm C Language Extension
+#include <arm_acle.h>
+#else
+#include "common/cityhash.h"
+#endif
+
+namespace Common {
+#ifdef ANDROID
+u64 ComputeHash64(const void* data, u32 len) {
+    const u8* p = static_cast<const u8*>(data);
+    union {
+        u64 crc64;
+        u32 crc32[2];
+    } result{};
+    u32 i = 0;
+    while (len >= 8) {
+        result.crc32[i & 1] = __crc32d(result.crc32[i & 1], *((u64*)p));
+        p += 8;
+        len -= 8;
+        i += 1;
+    }
+    if (len >= 4) {
+        result.crc32[i & 1] = __crc32w(result.crc32[i & 1], *((u32*)p));
+        p += 4;
+        len -= 4;
+        i += 1;
+    }
+    if (len >= 2) {
+        result.crc32[i & 1] = __crc32h(result.crc32[i & 1], *((u16*)p));
+        p += 2;
+        len -= 2;
+        i += 1;
+    }
+    if (len == 1)
+        result.crc32[i & 1] = __crc32b(result.crc32[i & 1], *p);
+    return result.crc64;
+}
+#else
+u64 ComputeHash64(const void* data, u32 len) {
+    return CityHash64(static_cast<const char*>(data), len);
+}
+#endif
+} // namespace Common
diff --git a/src/common/hash.h b/src/common/hash.h
index 40194d1ee4c..a26888dca27 100644
--- a/src/common/hash.h
+++ b/src/common/hash.h
@@ -4,68 +4,14 @@
 
 #pragma once
 
-#include <cstddef>
-#include <cstring>
-#include "common/cityhash.h"
 #include "common/common_types.h"
 
 namespace Common {
-
 /**
  * Computes a 64-bit hash over the specified block of data
  * @param data Block of data to compute hash over
  * @param len Length of data (in bytes) to compute hash over
  * @returns 64-bit hash value that was computed over the data block
  */
-static inline u64 ComputeHash64(const void* data, std::size_t len) {
-    return CityHash64(static_cast<const char*>(data), len);
-}
-
-/**
- * Computes a 64-bit hash of a struct. In addition to being trivially copyable, it is also critical
- * that either the struct includes no padding, or that any padding is initialized to a known value
- * by memsetting the struct to 0 before filling it in.
- */
-template <typename T>
-static inline u64 ComputeStructHash64(const T& data) {
-    static_assert(std::is_trivially_copyable_v<T>,
-                  "Type passed to ComputeStructHash64 must be trivially copyable");
-    return ComputeHash64(&data, sizeof(data));
-}
-
-/// A helper template that ensures the padding in a struct is initialized by memsetting to 0.
-template <typename T>
-struct HashableStruct {
-    // In addition to being trivially copyable, T must also have a trivial default constructor,
-    // because any member initialization would be overridden by memset
-    static_assert(std::is_trivial_v<T>, "Type passed to HashableStruct must be trivial");
-    /*
-     * We use a union because "implicitly-defined copy/move constructor for a union X copies the
-     * object representation of X." and "implicitly-defined copy assignment operator for a union X
-     * copies the object representation (3.9) of X." = Bytewise copy instead of memberwise copy.
-     * This is important because the padding bytes are included in the hash and comparison between
-     * objects.
-     */
-    union {
-        T state;
-    };
-
-    HashableStruct() {
-        // Memset structure to zero padding bits, so that they will be deterministic when hashing
-        std::memset(&state, 0, sizeof(T));
-    }
-
-    bool operator==(const HashableStruct<T>& o) const {
-        return std::memcmp(&state, &o.state, sizeof(T)) == 0;
-    };
-
-    bool operator!=(const HashableStruct<T>& o) const {
-        return !(*this == o);
-    };
-
-    std::size_t Hash() const {
-        return Common::ComputeStructHash64(state);
-    }
-};
-
+u64 ComputeHash64(const void* data, u32 len);
 } // namespace Common
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 0c586a4c716..d04f3a10091 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -132,6 +132,8 @@ add_library(core STATIC
     hle/kernel/hle_ipc.h
     hle/kernel/ipc.cpp
     hle/kernel/ipc.h
+    hle/kernel/ipc_debugger/recorder.cpp
+    hle/kernel/ipc_debugger/recorder.h
     hle/kernel/kernel.cpp
     hle/kernel/kernel.h
     hle/kernel/memory.cpp
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 2b97de067d4..201e510dfd7 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -41,7 +41,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
     if (!cpu_core) {
         return ResultStatus::ErrorNotInitialized;
     }
-
+#ifdef DEBUG_CONTEXT
     if (GDBStub::IsServerEnabled()) {
         GDBStub::HandlePacket();
 
@@ -55,7 +55,7 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
             }
         }
     }
-
+#endif
     // If we don't have a currently active thread then don't execute instructions,
     // instead advance to the next event and try to yield to the next thread
     if (kernel->GetThreadManager().GetCurrentThread() == nullptr) {
@@ -71,11 +71,11 @@ System::ResultStatus System::RunLoop(bool tight_loop) {
             cpu_core->Step();
         }
     }
-
+#ifdef DEBUG_CONTEXT
     if (GDBStub::IsServerEnabled()) {
         GDBStub::SetCpuStepFlag(false);
     }
-
+#endif
     HW::Update();
     Reschedule();
 
@@ -116,7 +116,8 @@ System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::st
     }
 
     ASSERT(system_mode.first);
-    ResultStatus init_result{Init(emu_window, Settings::values.is_new_3ds ? 6 : *system_mode.first)};
+    ResultStatus init_result{
+        Init(emu_window, Settings::values.is_new_3ds ? 6 : *system_mode.first)};
     if (init_result != ResultStatus::Success) {
         LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                      static_cast<u32>(init_result));
@@ -175,9 +176,7 @@ System::ResultStatus System::Init(Frontend::EmuWindow& emu_window, u32 system_mo
     LOG_DEBUG(HW_Memory, "initialized OK");
 
     memory = std::make_unique<Memory::MemorySystem>();
-
     timing = std::make_unique<Timing>();
-
     kernel = std::make_unique<Kernel::KernelSystem>(*memory, *timing,
                                                     [this] { PrepareReschedule(); }, system_mode);
 
@@ -292,8 +291,7 @@ void System::Shutdown() {
                                 perf_results.game_fps);
     telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
                                 perf_results.frametime * 1000.0);
-    telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS",
-                                20.0);
+    telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS", 20.0);
 
     // Shutdown emulation session
     GDBStub::Shutdown();
diff --git a/src/core/core_timing.cpp b/src/core/core_timing.cpp
index df355ab2733..21544a08b9b 100644
--- a/src/core/core_timing.cpp
+++ b/src/core/core_timing.cpp
@@ -111,7 +111,7 @@ void Timing::ForceExceptionCheck(s64 cycles) {
 void Timing::MoveEvents() {
     for (Event ev; ts_queue.Pop(ev);) {
         ev.fifo_order = event_fifo_id++;
-        event_queue.emplace_back(std::move(ev));
+        event_queue.emplace_back(ev);
         std::push_heap(event_queue.begin(), event_queue.end(), std::greater<>());
     }
 }
@@ -126,7 +126,7 @@ void Timing::Advance() {
     is_global_timer_sane = true;
 
     while (!event_queue.empty() && event_queue.front().time <= global_timer) {
-        Event evt = std::move(event_queue.front());
+        Event evt = event_queue.front();
         std::pop_heap(event_queue.begin(), event_queue.end(), std::greater<>());
         event_queue.pop_back();
         evt.type->callback(evt.userdata, global_timer - evt.time);
diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index cd2f9fc87cf..ab4ecfd0597 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -10,6 +10,7 @@
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/hle_ipc.h"
+#include "core/hle/kernel/ipc_debugger/recorder.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 
@@ -107,6 +108,13 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const u32_le* sr
 
     std::copy_n(src_cmdbuf, untranslated_size, cmd_buf.begin());
 
+    const bool should_record = kernel.GetIPCRecorder().IsEnabled();
+
+    std::vector<u32> untranslated_cmdbuf;
+    if (should_record) {
+        untranslated_cmdbuf = std::vector<u32>{src_cmdbuf, src_cmdbuf + command_size};
+    }
+
     std::size_t i = untranslated_size;
     while (i < command_size) {
         u32 descriptor = cmd_buf[i] = src_cmdbuf[i];
@@ -160,6 +168,12 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const u32_le* sr
         }
     }
 
+    if (should_record) {
+        std::vector<u32> translated_cmdbuf{cmd_buf.begin(), cmd_buf.begin() + command_size};
+        kernel.GetIPCRecorder().SetRequestInfo(SharedFrom(thread), std::move(untranslated_cmdbuf),
+                                               std::move(translated_cmdbuf));
+    }
+
     return RESULT_SUCCESS;
 }
 
@@ -173,6 +187,13 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf,
 
     std::copy_n(cmd_buf.begin(), untranslated_size, dst_cmdbuf);
 
+    const bool should_record = kernel.GetIPCRecorder().IsEnabled();
+
+    std::vector<u32> untranslated_cmdbuf;
+    if (should_record) {
+        untranslated_cmdbuf = std::vector<u32>{cmd_buf.begin(), cmd_buf.begin() + command_size};
+    }
+
     std::size_t i = untranslated_size;
     while (i < command_size) {
         u32 descriptor = dst_cmdbuf[i] = cmd_buf[i];
@@ -225,6 +246,12 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf,
         }
     }
 
+    if (should_record) {
+        std::vector<u32> translated_cmdbuf{dst_cmdbuf, dst_cmdbuf + command_size};
+        kernel.GetIPCRecorder().SetReplyInfo(SharedFrom(thread), std::move(untranslated_cmdbuf),
+                                             std::move(translated_cmdbuf));
+    }
+
     return RESULT_SUCCESS;
 }
 
@@ -233,6 +260,12 @@ MappedBuffer& HLERequestContext::GetMappedBuffer(u32 id_from_cmdbuf) {
     return request_mapped_buffers[id_from_cmdbuf];
 }
 
+void HLERequestContext::ReportUnimplemented() const {
+    if (kernel.GetIPCRecorder().IsEnabled()) {
+        kernel.GetIPCRecorder().SetHLEUnimplemented(SharedFrom(thread));
+    }
+}
+
 MappedBuffer::MappedBuffer(Memory::MemorySystem& memory, const Process& process, u32 descriptor,
                            VAddr address, u32 id)
     : memory(&memory), id(id), address(address), process(&process) {
diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h
index f684985d017..26942fe6b1a 100644
--- a/src/core/hle/kernel/hle_ipc.h
+++ b/src/core/hle/kernel/hle_ipc.h
@@ -234,6 +234,9 @@ class HLERequestContext {
     /// Writes data from this context back to the requesting process/thread.
     ResultCode WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, Process& dst_process) const;
 
+    /// Reports an unimplemented function.
+    void ReportUnimplemented() const;
+
 private:
     KernelSystem& kernel;
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
diff --git a/src/core/hle/kernel/ipc.cpp b/src/core/hle/kernel/ipc.cpp
index c9616e566c3..3dacb98317c 100644
--- a/src/core/hle/kernel/ipc.cpp
+++ b/src/core/hle/kernel/ipc.cpp
@@ -8,6 +8,7 @@
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/ipc.h"
+#include "core/hle/kernel/ipc_debugger/recorder.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/process.h"
@@ -16,7 +17,8 @@
 
 namespace Kernel {
 
-ResultCode TranslateCommandBuffer(Memory::MemorySystem& memory, std::shared_ptr<Thread> src_thread,
+ResultCode TranslateCommandBuffer(Kernel::KernelSystem& kernel, Memory::MemorySystem& memory,
+                                  std::shared_ptr<Thread> src_thread,
                                   std::shared_ptr<Thread> dst_thread, VAddr src_address,
                                   VAddr dst_address,
                                   std::vector<MappedBufferContext>& mapped_buffer_context,
@@ -37,6 +39,13 @@ ResultCode TranslateCommandBuffer(Memory::MemorySystem& memory, std::shared_ptr<
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
     memory.ReadBlock(*src_process, src_address, cmd_buf.data(), command_size * sizeof(u32));
 
+    const bool should_record = kernel.GetIPCRecorder().IsEnabled();
+
+    std::vector<u32> untranslated_cmdbuf;
+    if (should_record) {
+        untranslated_cmdbuf = std::vector<u32>{cmd_buf.begin(), cmd_buf.begin() + command_size};
+    }
+
     std::size_t i = untranslated_size;
     while (i < command_size) {
         u32 descriptor = cmd_buf[i];
@@ -218,6 +227,17 @@ ResultCode TranslateCommandBuffer(Memory::MemorySystem& memory, std::shared_ptr<
         }
     }
 
+    if (should_record) {
+        std::vector<u32> translated_cmdbuf{cmd_buf.begin(), cmd_buf.begin() + command_size};
+        if (reply) {
+            kernel.GetIPCRecorder().SetReplyInfo(dst_thread, std::move(untranslated_cmdbuf),
+                                                 std::move(translated_cmdbuf));
+        } else {
+            kernel.GetIPCRecorder().SetRequestInfo(src_thread, std::move(untranslated_cmdbuf),
+                                                   std::move(translated_cmdbuf), dst_thread);
+        }
+    }
+
     memory.WriteBlock(*dst_process, dst_address, cmd_buf.data(), command_size * sizeof(u32));
 
     return RESULT_SUCCESS;
diff --git a/src/core/hle/kernel/ipc.h b/src/core/hle/kernel/ipc.h
index d84028767ce..b060799586f 100644
--- a/src/core/hle/kernel/ipc.h
+++ b/src/core/hle/kernel/ipc.h
@@ -16,6 +16,8 @@ class MemorySystem;
 
 namespace Kernel {
 
+class KernelSystem;
+
 struct MappedBufferContext {
     IPC::MappedBufferPermissions permissions;
     u32 size;
@@ -27,7 +29,8 @@ struct MappedBufferContext {
 };
 
 /// Performs IPC command buffer translation from one process to another.
-ResultCode TranslateCommandBuffer(Memory::MemorySystem& memory, std::shared_ptr<Thread> src_thread,
+ResultCode TranslateCommandBuffer(KernelSystem& system, Memory::MemorySystem& memory,
+                                  std::shared_ptr<Thread> src_thread,
                                   std::shared_ptr<Thread> dst_thread, VAddr src_address,
                                   VAddr dst_address,
                                   std::vector<MappedBufferContext>& mapped_buffer_context,
diff --git a/src/core/hle/kernel/ipc_debugger/recorder.cpp b/src/core/hle/kernel/ipc_debugger/recorder.cpp
new file mode 100644
index 00000000000..12c57d6a0c3
--- /dev/null
+++ b/src/core/hle/kernel/ipc_debugger/recorder.cpp
@@ -0,0 +1,169 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "common/logging/log.h"
+#include "core/hle/kernel/client_port.h"
+#include "core/hle/kernel/client_session.h"
+#include "core/hle/kernel/ipc_debugger/recorder.h"
+#include "core/hle/kernel/process.h"
+#include "core/hle/kernel/server_port.h"
+#include "core/hle/kernel/server_session.h"
+#include "core/hle/kernel/session.h"
+#include "core/hle/kernel/thread.h"
+#include "core/hle/service/service.h"
+
+namespace IPCDebugger {
+
+namespace {
+ObjectInfo GetObjectInfo(const Kernel::Object* object) {
+    if (object == nullptr) {
+        return {};
+    }
+    return {object->GetTypeName(), object->GetName(), static_cast<int>(object->GetObjectId())};
+}
+
+ObjectInfo GetObjectInfo(const Kernel::Thread* thread) {
+    if (thread == nullptr) {
+        return {};
+    }
+    return {thread->GetTypeName(), thread->GetName(), static_cast<int>(thread->GetThreadId())};
+}
+
+ObjectInfo GetObjectInfo(const Kernel::Process* process) {
+    if (process == nullptr) {
+        return {};
+    }
+    return {process->GetTypeName(), process->GetName(), static_cast<int>(process->process_id)};
+}
+} // namespace
+
+Recorder::Recorder() = default;
+Recorder::~Recorder() = default;
+
+bool Recorder::IsEnabled() const {
+#ifdef ANDROID
+    return false;
+#else
+    return enabled.load(std::memory_order_relaxed);
+#endif
+}
+
+void Recorder::RegisterRequest(const std::shared_ptr<Kernel::ClientSession>& client_session,
+                               const std::shared_ptr<Kernel::Thread>& client_thread) {
+    const u32 thread_id = client_thread->GetThreadId();
+
+    RequestRecord record = {/* id */ ++record_count,
+                            /* status */ RequestStatus::Sent,
+                            /* client_process */ GetObjectInfo(client_thread->owner_process),
+                            /* client_thread */ GetObjectInfo(client_thread.get()),
+                            /* client_session */ GetObjectInfo(client_session.get()),
+                            /* client_port */ GetObjectInfo(client_session->parent->port.get()),
+                            /* server_process */ {},
+                            /* server_thread */ {},
+                            /* server_session */ GetObjectInfo(client_session->parent->server)};
+    record_map.insert_or_assign(thread_id, std::make_unique<RequestRecord>(record));
+    client_session_map.insert_or_assign(thread_id, client_session);
+
+    InvokeCallbacks(record);
+}
+
+void Recorder::SetRequestInfo(const std::shared_ptr<Kernel::Thread>& client_thread,
+                              std::vector<u32> untranslated_cmdbuf,
+                              std::vector<u32> translated_cmdbuf,
+                              const std::shared_ptr<Kernel::Thread>& server_thread) {
+    const u32 thread_id = client_thread->GetThreadId();
+    if (!record_map.count(thread_id)) {
+        // This is possible when the recorder is enabled after application started
+        LOG_ERROR(Kernel, "No request is assoicated with the thread");
+        return;
+    }
+
+    auto& record = *record_map[thread_id];
+    record.status = RequestStatus::Handling;
+    record.untranslated_request_cmdbuf = std::move(untranslated_cmdbuf);
+    record.translated_request_cmdbuf = std::move(translated_cmdbuf);
+
+    if (server_thread) {
+        record.server_process = GetObjectInfo(server_thread->owner_process);
+        record.server_thread = GetObjectInfo(server_thread.get());
+    } else {
+        record.is_hle = true;
+    }
+
+    // Function name
+    ASSERT_MSG(client_session_map.count(thread_id), "Client session is missing");
+    const auto& client_session = client_session_map[thread_id];
+    if (client_session->parent->port &&
+        client_session->parent->port->GetServerPort()->hle_handler) {
+
+        record.function_name = std::dynamic_pointer_cast<Service::ServiceFrameworkBase>(
+                                   client_session->parent->port->GetServerPort()->hle_handler)
+                                   ->GetFunctionName(record.untranslated_request_cmdbuf[0]);
+    }
+    client_session_map.erase(thread_id);
+
+    InvokeCallbacks(record);
+}
+
+void Recorder::SetReplyInfo(const std::shared_ptr<Kernel::Thread>& client_thread,
+                            std::vector<u32> untranslated_cmdbuf,
+                            std::vector<u32> translated_cmdbuf) {
+    const u32 thread_id = client_thread->GetThreadId();
+    if (!record_map.count(thread_id)) {
+        // This is possible when the recorder is enabled after application started
+        LOG_ERROR(Kernel, "No request is assoicated with the thread");
+        return;
+    }
+
+    auto& record = *record_map[thread_id];
+    if (record.status != RequestStatus::HLEUnimplemented) {
+        record.status = RequestStatus::Handled;
+    }
+
+    record.untranslated_reply_cmdbuf = std::move(untranslated_cmdbuf);
+    record.translated_reply_cmdbuf = std::move(translated_cmdbuf);
+    InvokeCallbacks(record);
+
+    record_map.erase(thread_id);
+}
+
+void Recorder::SetHLEUnimplemented(const std::shared_ptr<Kernel::Thread>& client_thread) {
+    const u32 thread_id = client_thread->GetThreadId();
+    if (!record_map.count(thread_id)) {
+        // This is possible when the recorder is enabled after application started
+        LOG_ERROR(Kernel, "No request is assoicated with the thread");
+        return;
+    }
+
+    auto& record = *record_map[thread_id];
+    record.status = RequestStatus::HLEUnimplemented;
+}
+
+CallbackHandle Recorder::BindCallback(CallbackType callback) {
+    std::unique_lock lock(callback_mutex);
+    CallbackHandle handle = std::make_shared<CallbackType>(callback);
+    callbacks.emplace(handle);
+    return handle;
+}
+
+void Recorder::UnbindCallback(const CallbackHandle& handle) {
+    std::unique_lock lock(callback_mutex);
+    callbacks.erase(handle);
+}
+
+void Recorder::InvokeCallbacks(const RequestRecord& request) {
+    {
+        std::shared_lock lock(callback_mutex);
+        for (const auto& iter : callbacks) {
+            (*iter)(request);
+        }
+    }
+}
+
+void Recorder::SetEnabled(bool enabled_) {
+    enabled.store(enabled_, std::memory_order_relaxed);
+}
+
+} // namespace IPCDebugger
diff --git a/src/core/hle/kernel/ipc_debugger/recorder.h b/src/core/hle/kernel/ipc_debugger/recorder.h
new file mode 100644
index 00000000000..ebd8bf5d1d0
--- /dev/null
+++ b/src/core/hle/kernel/ipc_debugger/recorder.h
@@ -0,0 +1,129 @@
+// Copyright 2019 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <set>
+#include <shared_mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "common/common_types.h"
+
+namespace Kernel {
+class ClientSession;
+class Thread;
+} // namespace Kernel
+
+namespace IPCDebugger {
+
+/**
+ * Record of a kernel object, for debugging purposes.
+ */
+struct ObjectInfo {
+    std::string type;
+    std::string name;
+    int id = -1;
+};
+
+/**
+ * Status of a request.
+ */
+enum class RequestStatus {
+    Invalid,          ///< Invalid status
+    Sent,             ///< The request is sent to the kernel and is waiting to be handled
+    Handling,         ///< The request is being handled
+    Handled,          ///< The request is handled with reply sent
+    HLEUnimplemented, ///< The request is unimplemented by HLE, and unhandled
+};
+
+/**
+ * Record of an IPC request.
+ */
+struct RequestRecord {
+    int id;
+    RequestStatus status = RequestStatus::Invalid;
+    ObjectInfo client_process;
+    ObjectInfo client_thread;
+    ObjectInfo client_session;
+    ObjectInfo client_port;    // Not available for portless
+    ObjectInfo server_process; // Only available for LLE requests
+    ObjectInfo server_thread;  // Only available for LLE requests
+    ObjectInfo server_session;
+    std::string function_name; // Not available for LLE or portless
+    bool is_hle = false;
+    // Request info is only available when status is not `Invalid` or `Sent`
+    std::vector<u32> untranslated_request_cmdbuf;
+    std::vector<u32> translated_request_cmdbuf;
+    // Reply info is only available when status is `Handled`
+    std::vector<u32> untranslated_reply_cmdbuf;
+    std::vector<u32> translated_reply_cmdbuf;
+};
+
+using CallbackType = std::function<void(const RequestRecord&)>;
+using CallbackHandle = std::shared_ptr<CallbackType>;
+
+class Recorder {
+public:
+    explicit Recorder();
+    ~Recorder();
+
+    /**
+     * Returns whether the recorder is enabled.
+     */
+    bool IsEnabled() const;
+
+    /**
+     * Registers a request into the recorder. The request is then assoicated with the client thread.
+     */
+    void RegisterRequest(const std::shared_ptr<Kernel::ClientSession>& client_session,
+                         const std::shared_ptr<Kernel::Thread>& client_thread);
+
+    /**
+     * Sets the request information of the request record associated with the client thread.
+     * When the server thread is empty, the request will be considered HLE.
+     */
+    void SetRequestInfo(const std::shared_ptr<Kernel::Thread>& client_thread,
+                        std::vector<u32> untranslated_cmdbuf, std::vector<u32> translated_cmdbuf,
+                        const std::shared_ptr<Kernel::Thread>& server_thread = {});
+
+    /**
+     * Sets the reply information of the request record assoicated with the client thread.
+     * The request is then unlinked from the client thread.
+     */
+    void SetReplyInfo(const std::shared_ptr<Kernel::Thread>& client_thread,
+                      std::vector<u32> untranslated_cmdbuf, std::vector<u32> translated_cmdbuf);
+
+    /**
+     * Set the status of a record to HLEUnimplemented.
+     */
+    void SetHLEUnimplemented(const std::shared_ptr<Kernel::Thread>& client_thread);
+
+    /**
+     * Set the status of the debugger (enabled/disabled).
+     */
+    void SetEnabled(bool enabled);
+
+    CallbackHandle BindCallback(CallbackType callback);
+    void UnbindCallback(const CallbackHandle& handle);
+
+private:
+    void InvokeCallbacks(const RequestRecord& request);
+
+    std::unordered_map<u32, std::unique_ptr<RequestRecord>> record_map;
+    int record_count{};
+
+    // Temporary client session map for function name handling
+    std::unordered_map<u32, std::shared_ptr<Kernel::ClientSession>> client_session_map;
+
+    std::atomic_bool enabled{false};
+
+    std::set<CallbackHandle> callbacks;
+    mutable std::shared_mutex callback_mutex;
+};
+
+} // namespace IPCDebugger
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index f480f6362e1..ceb2f14f5fe 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -5,6 +5,7 @@
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/config_mem.h"
 #include "core/hle/kernel/handle_table.h"
+#include "core/hle/kernel/ipc_debugger/recorder.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/process.h"
@@ -25,6 +26,7 @@ KernelSystem::KernelSystem(Memory::MemorySystem& memory, Core::Timing& timing,
     resource_limits = std::make_unique<ResourceLimitList>(*this);
     thread_manager = std::make_unique<ThreadManager>(*this);
     timer_manager = std::make_unique<TimerManager>(timing);
+    ipc_recorder = std::make_unique<IPCDebugger::Recorder>();
 }
 
 /// Shutdown the kernel
@@ -87,6 +89,14 @@ const SharedPage::Handler& KernelSystem::GetSharedPageHandler() const {
     return *shared_page_handler;
 }
 
+IPCDebugger::Recorder& KernelSystem::GetIPCRecorder() {
+    return *ipc_recorder;
+}
+
+const IPCDebugger::Recorder& KernelSystem::GetIPCRecorder() const {
+    return *ipc_recorder;
+}
+
 void KernelSystem::AddNamedPort(std::string name, std::shared_ptr<ClientPort> port) {
     named_ports.emplace(std::move(name), std::move(port));
 }
diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 38045a42554..58f63938bed 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -32,6 +32,10 @@ namespace Core {
 class Timing;
 }
 
+namespace IPCDebugger {
+class Recorder;
+}
+
 namespace Kernel {
 
 class AddressArbiter;
@@ -222,6 +226,9 @@ class KernelSystem {
     SharedPage::Handler& GetSharedPageHandler();
     const SharedPage::Handler& GetSharedPageHandler() const;
 
+    IPCDebugger::Recorder& GetIPCRecorder();
+    const IPCDebugger::Recorder& GetIPCRecorder() const;
+
     MemoryRegionInfo* GetMemoryRegion(MemoryRegion region);
 
     void HandleSpecialMapping(VMManager& address_space, const AddressMapping& mapping);
@@ -274,6 +281,8 @@ class KernelSystem {
 
     std::unique_ptr<ConfigMem::Handler> config_mem_handler;
     std::unique_ptr<SharedPage::Handler> shared_page_handler;
+
+    std::unique_ptr<IPCDebugger::Recorder> ipc_recorder;
 };
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/memory.cpp b/src/core/hle/kernel/memory.cpp
index bd77c0f03b8..96e8243d1d9 100644
--- a/src/core/hle/kernel/memory.cpp
+++ b/src/core/hle/kernel/memory.cpp
@@ -42,7 +42,7 @@ static const u32 memory_region_sizes[8][3] = {
 
 void KernelSystem::MemoryInit(u32 mem_type) {
     // TODO(yuriks): On the n3DS, all o3DS configurations (<=5) are forced to 6 instead.
-    //ASSERT_MSG(mem_type <= 5, "New 3DS memory configuration aren't supported yet!");
+    // ASSERT_MSG(mem_type <= 5, "New 3DS memory configuration aren't supported yet!");
     ASSERT(mem_type != 1);
 
     // The kernel allocation regions (APPLICATION, SYSTEM and BASE) are laid out in sequence, with
@@ -55,7 +55,7 @@ void KernelSystem::MemoryInit(u32 mem_type) {
     }
 
     // We must've allocated the entire FCRAM by the end
-    //ASSERT(base == Memory::FCRAM_SIZE);
+    // ASSERT(base == Memory::FCRAM_SIZE);
 
     config_mem_handler = std::make_unique<ConfigMem::Handler>();
     auto& config_mem = config_mem_handler->GetConfigMem();
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 1f24b33c577..0d57ebc8789 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -19,6 +19,7 @@
 #include "core/hle/kernel/event.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/ipc.h"
+#include "core/hle/kernel/ipc_debugger/recorder.h"
 #include "core/hle/kernel/memory.h"
 #include "core/hle/kernel/mutex.h"
 #include "core/hle/kernel/process.h"
@@ -387,7 +388,13 @@ ResultCode SVC::SendSyncRequest(Handle handle) {
 
     system.PrepareReschedule();
 
-    return session->SendSyncRequest(SharedFrom(kernel.GetThreadManager().GetCurrentThread()));
+    auto thread = SharedFrom(kernel.GetThreadManager().GetCurrentThread());
+
+    if (kernel.GetIPCRecorder().IsEnabled()) {
+        kernel.GetIPCRecorder().RegisterRequest(session, thread);
+    }
+
+    return session->SendSyncRequest(thread);
 }
 
 /// Close a handle
@@ -593,7 +600,7 @@ ResultCode SVC::WaitSynchronizationN(s32* out, VAddr handles_address, s32 handle
     }
 }
 
-static ResultCode ReceiveIPCRequest(Memory::MemorySystem& memory,
+static ResultCode ReceiveIPCRequest(Kernel::KernelSystem& kernel, Memory::MemorySystem& memory,
                                     std::shared_ptr<ServerSession> server_session,
                                     std::shared_ptr<Thread> thread) {
     if (server_session->parent->client == nullptr) {
@@ -603,9 +610,9 @@ static ResultCode ReceiveIPCRequest(Memory::MemorySystem& memory,
     VAddr target_address = thread->GetCommandBufferAddress();
     VAddr source_address = server_session->currently_handling->GetCommandBufferAddress();
 
-    ResultCode translation_result =
-        TranslateCommandBuffer(memory, server_session->currently_handling, thread, source_address,
-                               target_address, server_session->mapped_buffer_context, false);
+    ResultCode translation_result = TranslateCommandBuffer(
+        kernel, memory, server_session->currently_handling, thread, source_address, target_address,
+        server_session->mapped_buffer_context, false);
 
     // If a translation error occurred, immediately resume the client thread.
     if (translation_result.IsError()) {
@@ -670,9 +677,9 @@ ResultCode SVC::ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_co
         VAddr source_address = thread->GetCommandBufferAddress();
         VAddr target_address = request_thread->GetCommandBufferAddress();
 
-        ResultCode translation_result =
-            TranslateCommandBuffer(memory, SharedFrom(thread), request_thread, source_address,
-                                   target_address, session->mapped_buffer_context, true);
+        ResultCode translation_result = TranslateCommandBuffer(
+            kernel, memory, SharedFrom(thread), request_thread, source_address, target_address,
+            session->mapped_buffer_context, true);
 
         // Note: The real kernel seems to always panic if the Server->Client buffer translation
         // fails for whatever reason.
@@ -707,7 +714,7 @@ ResultCode SVC::ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_co
             return RESULT_SUCCESS;
 
         auto server_session = static_cast<ServerSession*>(object);
-        return ReceiveIPCRequest(memory, SharedFrom(server_session), SharedFrom(thread));
+        return ReceiveIPCRequest(kernel, memory, SharedFrom(server_session), SharedFrom(thread));
     }
 
     // No objects were ready to be acquired, prepare to suspend the thread.
@@ -723,9 +730,9 @@ ResultCode SVC::ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_co
 
     thread->wait_objects = std::move(objects);
 
-    thread->wakeup_callback = [& memory = this->memory](ThreadWakeupReason reason,
-                                                        std::shared_ptr<Thread> thread,
-                                                        std::shared_ptr<WaitObject> object) {
+    thread->wakeup_callback = [& kernel = this->kernel, &memory = this->memory](
+                                  ThreadWakeupReason reason, std::shared_ptr<Thread> thread,
+                                  std::shared_ptr<WaitObject> object) {
         ASSERT(thread->status == ThreadStatus::WaitSynchAny);
         ASSERT(reason == ThreadWakeupReason::Signal);
 
@@ -733,7 +740,7 @@ ResultCode SVC::ReplyAndReceive(s32* index, VAddr handles_address, s32 handle_co
 
         if (object->GetHandleType() == HandleType::ServerSession) {
             auto server_session = DynamicObjectCast<ServerSession>(object);
-            result = ReceiveIPCRequest(memory, server_session, thread);
+            result = ReceiveIPCRequest(kernel, memory, server_session, thread);
         }
 
         thread->SetWaitSynchronizationResult(result);
diff --git a/src/core/hle/service/dsp/dsp_dsp.cpp b/src/core/hle/service/dsp/dsp_dsp.cpp
index 12a472baab9..595ad13cde9 100644
--- a/src/core/hle/service/dsp/dsp_dsp.cpp
+++ b/src/core/hle/service/dsp/dsp_dsp.cpp
@@ -301,7 +301,8 @@ void DSP_DSP::ForceHeadphoneOut(Kernel::HLERequestContext& ctx) {
 // that's waiting for an interrupt event. Immediately after this interrupt event, userland
 // normally updates the state in the next region and increments the relevant frame counter by two.
 void DSP_DSP::SignalInterrupt(InterruptType type, DspPipe pipe) {
-    //LOG_DEBUG(Service_DSP, "called, type={}, pipe={}", static_cast<u32>(type), static_cast<u32>(pipe));
+    // LOG_DEBUG(Service_DSP, "called, type={}, pipe={}", static_cast<u32>(type),
+    // static_cast<u32>(pipe));
     const auto& event = GetInterruptEvent(type, pipe);
     if (event)
         event->Signal();
diff --git a/src/core/hle/service/fs/fs_user.cpp b/src/core/hle/service/fs/fs_user.cpp
index bca8e77e53f..02338a33892 100644
--- a/src/core/hle/service/fs/fs_user.cpp
+++ b/src/core/hle/service/fs/fs_user.cpp
@@ -343,11 +343,28 @@ void FS_USER::OpenArchive(Kernel::HLERequestContext& ctx) {
     }
 }
 
+void FS_USER::ControlArchive(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp(ctx, 0x80D, 5, 4);
+    auto archive_handle = rp.PopRaw<ArchiveHandle>();
+    const u32 action = rp.Pop<u32>();
+    const u32 input_size = rp.Pop<u32>();
+    const u32 output_size = rp.Pop<u32>();
+    auto& input_buffer = rp.PopMappedBuffer();
+    auto& output_buffer = rp.PopMappedBuffer();
+    IPC::RequestBuilder rb = rp.MakeBuilder(1, 4);
+    rb.Push(RESULT_SUCCESS);
+    rb.PushMappedBuffer(input_buffer);
+    rb.PushMappedBuffer(output_buffer);
+    LOG_WARNING(Service_FS, "(STUBBED) action={:#08}, called input_size={:#08}, output_size={:#08}",
+                action, input_size, output_size);
+}
+
 void FS_USER::CloseArchive(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp(ctx, 0x80E, 2, 0);
     auto archive_handle = rp.PopRaw<ArchiveHandle>();
 
-    IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
+    IPC::RequestBuilder rb = rp.MakeBuilder(2, 0);
+    rb.Push(RESULT_SUCCESS);
     rb.Push(archives.CloseArchive(archive_handle));
 }
 
@@ -791,7 +808,7 @@ FS_USER::FS_USER(Core::System& system)
         {0x080A0244, &FS_USER::RenameDirectory, "RenameDirectory"},
         {0x080B0102, &FS_USER::OpenDirectory, "OpenDirectory"},
         {0x080C00C2, &FS_USER::OpenArchive, "OpenArchive"},
-        {0x080D0144, nullptr, "ControlArchive"},
+        {0x080D0144, &FS_USER::ControlArchive, "ControlArchive"},
         {0x080E0080, &FS_USER::CloseArchive, "CloseArchive"},
         {0x080F0180, &FS_USER::FormatThisUserSaveData, "FormatThisUserSaveData"},
         {0x08100200, &FS_USER::CreateLegacySystemSaveData, "CreateLegacySystemSaveData"},
diff --git a/src/core/hle/service/fs/fs_user.h b/src/core/hle/service/fs/fs_user.h
index 97b45714b2f..92520861717 100644
--- a/src/core/hle/service/fs/fs_user.h
+++ b/src/core/hle/service/fs/fs_user.h
@@ -213,6 +213,8 @@ class FS_USER final : public ServiceFramework<FS_USER, ClientSlot> {
      */
     void OpenArchive(Kernel::HLERequestContext& ctx);
 
+    void ControlArchive(Kernel::HLERequestContext& ctx);
+
     /**
      * FS_User::CloseArchive service function
      *  Inputs:
diff --git a/src/core/hle/service/gsp/gsp_gpu.cpp b/src/core/hle/service/gsp/gsp_gpu.cpp
index 9e3e9737c25..ef396662617 100644
--- a/src/core/hle/service/gsp/gsp_gpu.cpp
+++ b/src/core/hle/service/gsp/gsp_gpu.cpp
@@ -301,11 +301,12 @@ ResultCode SetBufferSwap(u32 screen_id, const FrameBufferInfo& info) {
     WriteSingleHWReg(
         base_address + 4 * static_cast<u32>(GPU_REG_INDEX(framebuffer_config[screen_id].active_fb)),
         info.shown_fb);
-
+#ifdef DEBUG_CONTEXT
     if (Pica::g_debug_context)
         Pica::g_debug_context->OnEvent(Pica::DebugContext::Event::BufferSwapped, nullptr);
-
+#endif
     if (screen_id == 0) {
+        // MicroProfileFlip();
         MicroProfileFlip();
         Core::System::GetInstance().perf_stats->EndGameFrame();
     }
@@ -633,14 +634,14 @@ void GSP_GPU::TriggerCmdReqQueue(Kernel::HLERequestContext& ctx) {
 
         // Iterate through each command...
         for (unsigned i = 0; i < command_buffer->number_commands; ++i) {
+#ifdef DEBUG_CONTEXT
             g_debugger.GXCommandProcessed((u8*)&command_buffer->commands[i]);
-
+#endif
             // Decode and execute command
             ExecuteCommand(command_buffer->commands[i], thread_id);
-
-            // Indicates that command has completed
-            command_buffer->number_commands.Assign(command_buffer->number_commands - 1);
         }
+        // Indicates that command has completed
+        command_buffer->number_commands.Assign(0);
     }
 
     IPC::RequestBuilder rb = rp.MakeBuilder(1, 0);
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 64f049612a5..c91bb73986d 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -171,6 +171,7 @@ void ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& context)
     auto itr = handlers.find(header_code);
     const FunctionInfoBase* info = itr == handlers.end() ? nullptr : &itr->second;
     if (info == nullptr || info->handler_callback == nullptr) {
+        context.ReportUnimplemented();
         return ReportUnimplementedFunction(context.CommandBuffer(), info);
     }
 
@@ -179,6 +180,14 @@ void ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& context)
     handler_invoker(this, info->handler_callback, context);
 }
 
+std::string ServiceFrameworkBase::GetFunctionName(u32 header) const {
+    if (!handlers.count(header)) {
+        return "";
+    }
+
+    return handlers.at(header).name;
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Module interface
 
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 1d9e800e2ac..db6a0ad233d 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -64,6 +64,9 @@ class ServiceFrameworkBase : public Kernel::SessionRequestHandler {
 
     void HandleSyncRequest(Kernel::HLERequestContext& context) override;
 
+    /// Retrieves name of a function based on the header code. For IPC Recorder.
+    std::string GetFunctionName(u32 header) const;
+
 protected:
     /// Member-function pointer type of SyncRequest handlers.
     template <typename Self>
diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp
index e37c72cc159..3caca2f93e5 100644
--- a/src/core/hle/service/sm/sm.cpp
+++ b/src/core/hle/service/sm/sm.cpp
@@ -42,6 +42,7 @@ ResultVal<std::shared_ptr<Kernel::ServerPort>> ServiceManager::RegisterService(
 
     auto [server_port, client_port] = system.Kernel().CreatePortPair(max_sessions, name);
 
+    registered_services_inverse.emplace(client_port->GetObjectId(), name);
     registered_services.emplace(std::move(name), std::move(client_port));
     return MakeResult(std::move(server_port));
 }
@@ -65,4 +66,12 @@ ResultVal<std::shared_ptr<Kernel::ClientSession>> ServiceManager::ConnectToServi
     return client_port->Connect();
 }
 
+std::string ServiceManager::GetServiceNameByPortId(u32 port) const {
+    if (registered_services_inverse.count(port)) {
+        return registered_services_inverse.at(port);
+    }
+
+    return "";
+}
+
 } // namespace Service::SM
diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h
index dc26d881484..6e47fd15257 100644
--- a/src/core/hle/service/sm/sm.h
+++ b/src/core/hle/service/sm/sm.h
@@ -51,6 +51,8 @@ class ServiceManager {
                                                                    unsigned int max_sessions);
     ResultVal<std::shared_ptr<Kernel::ClientPort>> GetServicePort(const std::string& name);
     ResultVal<std::shared_ptr<Kernel::ClientSession>> ConnectToService(const std::string& name);
+    // For IPC Recorder
+    std::string GetServiceNameByPortId(u32 port) const;
 
     template <typename T>
     std::shared_ptr<T> GetService(const std::string& service_name) const {
@@ -74,6 +76,10 @@ class ServiceManager {
 
     /// Map of registered services, retrieved using GetServicePort or ConnectToService.
     std::unordered_map<std::string, std::shared_ptr<Kernel::ClientPort>> registered_services;
+
+    // For IPC Recorder
+    /// client port Object id -> service name
+    std::unordered_map<u32, std::string> registered_services_inverse;
 };
 
 } // namespace Service::SM
diff --git a/src/core/hw/gpu.cpp b/src/core/hw/gpu.cpp
index b1e5f8a014e..5a9829107c0 100644
--- a/src/core/hw/gpu.cpp
+++ b/src/core/hw/gpu.cpp
@@ -472,12 +472,12 @@ inline void Write(u32 addr, const T data) {
             MICROPROFILE_SCOPE(GPU_CmdlistProcessing);
 
             u32* buffer = (u32*)g_memory->GetPhysicalPointer(config.GetPhysicalAddress());
-
+#ifdef DEBUG_CONTEXT
             if (Pica::g_debug_context && Pica::g_debug_context->recorder) {
                 Pica::g_debug_context->recorder->MemoryAccessed((u8*)buffer, config.size,
                                                                 config.GetPhysicalAddress());
             }
-
+#endif
             Pica::CommandProcessor::ProcessCommandList(buffer, config.size);
 
             g_regs.command_processor_config.trigger = 0;
@@ -488,7 +488,7 @@ inline void Write(u32 addr, const T data) {
     default:
         break;
     }
-
+#ifdef DEBUG_CONTEXT
     // Notify tracer about the register write
     // This is happening *after* handling the write to make sure we properly catch all memory reads.
     if (Pica::g_debug_context && Pica::g_debug_context->recorder) {
@@ -496,6 +496,7 @@ inline void Write(u32 addr, const T data) {
         Pica::g_debug_context->recorder->RegisterWritten<T>(
             addr + 0x1EF00000 - 0x1EC00000 + 0x10100000, data);
     }
+#endif
 }
 
 // Explicitly instantiate template functions because we aren't defining this in the header:
diff --git a/src/core/hw/hw.cpp b/src/core/hw/hw.cpp
index e7d80a5c738..66b47d46bea 100644
--- a/src/core/hw/hw.cpp
+++ b/src/core/hw/hw.cpp
@@ -13,58 +13,22 @@ namespace HW {
 
 template <typename T>
 inline void Read(T& var, const u32 addr) {
-    switch (addr & 0xFFFFF000) {
-    case VADDR_GPU:
-    case VADDR_GPU + 0x1000:
-    case VADDR_GPU + 0x2000:
-    case VADDR_GPU + 0x3000:
-    case VADDR_GPU + 0x4000:
-    case VADDR_GPU + 0x5000:
-    case VADDR_GPU + 0x6000:
-    case VADDR_GPU + 0x7000:
-    case VADDR_GPU + 0x8000:
-    case VADDR_GPU + 0x9000:
-    case VADDR_GPU + 0xA000:
-    case VADDR_GPU + 0xB000:
-    case VADDR_GPU + 0xC000:
-    case VADDR_GPU + 0xD000:
-    case VADDR_GPU + 0xE000:
-    case VADDR_GPU + 0xF000:
+    if ((addr & 0xFFFF0000) == VADDR_GPU) {
         GPU::Read(var, addr);
-        break;
-    case VADDR_LCD:
+    } else if ((addr & 0xFFFFF000) == VADDR_LCD) {
         LCD::Read(var, addr);
-        break;
-    default:
+    } else {
         LOG_ERROR(HW_Memory, "unknown Read{} @ {:#010X}", sizeof(var) * 8, addr);
     }
 }
 
 template <typename T>
 inline void Write(u32 addr, const T data) {
-    switch (addr & 0xFFFFF000) {
-    case VADDR_GPU:
-    case VADDR_GPU + 0x1000:
-    case VADDR_GPU + 0x2000:
-    case VADDR_GPU + 0x3000:
-    case VADDR_GPU + 0x4000:
-    case VADDR_GPU + 0x5000:
-    case VADDR_GPU + 0x6000:
-    case VADDR_GPU + 0x7000:
-    case VADDR_GPU + 0x8000:
-    case VADDR_GPU + 0x9000:
-    case VADDR_GPU + 0xA000:
-    case VADDR_GPU + 0xB000:
-    case VADDR_GPU + 0xC000:
-    case VADDR_GPU + 0xD000:
-    case VADDR_GPU + 0xE000:
-    case VADDR_GPU + 0xF000:
+    if ((addr & 0xFFFF0000) == VADDR_GPU) {
         GPU::Write(addr, data);
-        break;
-    case VADDR_LCD:
+    } else if ((addr & 0xFFFFF000) == VADDR_LCD) {
         LCD::Write(addr, data);
-        break;
-    default:
+    } else {
         LOG_ERROR(HW_Memory, "unknown Write{} {:#010X} @ {:#010X}", sizeof(data) * 8, (u32)data,
                   addr);
     }
diff --git a/src/core/hw/lcd.cpp b/src/core/hw/lcd.cpp
index b7e86dd42a5..946f697a10f 100644
--- a/src/core/hw/lcd.cpp
+++ b/src/core/hw/lcd.cpp
@@ -40,7 +40,7 @@ inline void Write(u32 addr, const T data) {
     }
 
     g_regs[index] = static_cast<u32>(data);
-
+#ifdef DEBUG_CONTEXT
     // Notify tracer about the register write
     // This is happening *after* handling the write to make sure we properly catch all memory reads.
     if (Pica::g_debug_context && Pica::g_debug_context->recorder) {
@@ -48,6 +48,7 @@ inline void Write(u32 addr, const T data) {
         Pica::g_debug_context->recorder->RegisterWritten<T>(
             addr + HW::VADDR_LCD - 0x1EC00000 + 0x10100000, data);
     }
+#endif
 }
 
 // Explicitly instantiate template functions because we aren't defining this in the header:
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 096f4c69779..94d19984296 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -286,51 +286,21 @@ std::string MemorySystem::ReadCString(VAddr vaddr, std::size_t max_length) {
 }
 
 u8* MemorySystem::GetPhysicalPointer(PAddr address) {
-    struct MemoryArea {
-        PAddr paddr_base;
-        u32 size;
-    };
-
-    static constexpr MemoryArea memory_areas[] = {
-        {VRAM_PADDR, VRAM_SIZE},
-        {DSP_RAM_PADDR, DSP_RAM_SIZE},
-        {FCRAM_PADDR, FCRAM_N3DS_SIZE},
-        {N3DS_EXTRA_RAM_PADDR, N3DS_EXTRA_RAM_SIZE},
-    };
-
-    const auto area =
-        std::find_if(std::begin(memory_areas), std::end(memory_areas), [&](const auto& area) {
-            // Note: the region end check is inclusive because the user can pass in an address that
-            // represents an open right bound
-            return address >= area.paddr_base && address <= area.paddr_base + area.size;
-        });
-
-    if (area == std::end(memory_areas)) {
-        LOG_ERROR(HW_Memory, "unknown GetPhysicalPointer @ 0x{:08X}", address);
-        return nullptr;
+    if (address > VRAM_PADDR - 1 && address < VRAM_PADDR + VRAM_SIZE + 1) {
+        return impl->vram.get() + (address - VRAM_PADDR);
     }
-
-    u32 offset_into_region = address - area->paddr_base;
-
-    u8* target_pointer = nullptr;
-    switch (area->paddr_base) {
-    case VRAM_PADDR:
-        target_pointer = impl->vram.get() + offset_into_region;
-        break;
-    case DSP_RAM_PADDR:
-        target_pointer = impl->dsp->GetDspMemory().data() + offset_into_region;
-        break;
-    case FCRAM_PADDR:
-        target_pointer = impl->fcram.get() + offset_into_region;
-        break;
-    case N3DS_EXTRA_RAM_PADDR:
-        target_pointer = impl->n3ds_extra_ram.get() + offset_into_region;
-        break;
-    default:
-        UNREACHABLE();
+    if (address > DSP_RAM_PADDR - 1 && address < DSP_RAM_PADDR + DSP_RAM_SIZE + 1) {
+        return impl->dsp->GetDspMemory().data() + (address - DSP_RAM_PADDR);
     }
-
-    return target_pointer;
+    if (address > FCRAM_PADDR - 1 && address < FCRAM_PADDR + FCRAM_N3DS_SIZE + 1) {
+        return impl->fcram.get() + (address - FCRAM_PADDR);
+    }
+    if (address > N3DS_EXTRA_RAM_PADDR - 1 &&
+        address < N3DS_EXTRA_RAM_PADDR + N3DS_EXTRA_RAM_SIZE + 1) {
+        return impl->n3ds_extra_ram.get() + (address - N3DS_EXTRA_RAM_PADDR);
+    }
+    LOG_ERROR(HW_Memory, "unknown GetPhysicalPointer @ 0x{:08X}", address);
+    return nullptr;
 }
 
 /// For a rasterizer-accessible PAddr, gets a list of all possible VAddr
diff --git a/src/core/perf_stats.h b/src/core/perf_stats.h
index dae7ce988cb..7d05f4a225f 100644
--- a/src/core/perf_stats.h
+++ b/src/core/perf_stats.h
@@ -6,6 +6,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <cstddef>
 #include <mutex>
 #include "common/common_types.h"
 #include "common/thread.h"
diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt
index 77f9144fdc2..da629c3d482 100644
--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -46,6 +46,8 @@ add_library(video_core STATIC
     renderer_opengl/pica_to_gl.h
     renderer_opengl/renderer_opengl.cpp
     renderer_opengl/renderer_opengl.h
+    renderer_opengl/on_screen_display.cpp
+    renderer_opengl/on_screen_display.h
     shader/debug_data.h
     shader/shader.cpp
     shader/shader.h
diff --git a/src/video_core/command_processor.cpp b/src/video_core/command_processor.cpp
index 72f6f21611c..6e83428da7e 100644
--- a/src/video_core/command_processor.cpp
+++ b/src/video_core/command_processor.cpp
@@ -125,7 +125,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
     const u32 write_mask = expand_bits_to_bytes[mask];
 
     regs.reg_array[id] = (old_value & ~write_mask) | (value & write_mask);
-
+#ifdef DEBUG_CONTEXT
     // Double check for is_pica_tracing to avoid call overhead
     if (DebugUtils::IsPicaTracing()) {
         DebugUtils::OnPicaRegWrite({(u16)id, (u16)mask, regs.reg_array[id]});
@@ -134,7 +134,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
     if (g_debug_context)
         g_debug_context->OnEvent(DebugContext::Event::PicaCommandLoaded,
                                  reinterpret_cast<void*>(&id));
-
+#endif
     switch (id) {
     // Trigger IRQ
     case PICA_REG_INDEX(trigger_irq):
@@ -300,9 +300,11 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
 
         if (accelerate_draw &&
             VideoCore::g_renderer->Rasterizer()->AccelerateDrawBatch(is_indexed)) {
+#ifdef DEBUG_CONTEXT
             if (g_debug_context) {
                 g_debug_context->OnEvent(DebugContext::Event::FinishedPrimitiveBatch, nullptr);
             }
+#endif
             break;
         }
 
@@ -319,7 +321,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
             VideoCore::g_memory->GetPhysicalPointer(base_address + index_info.offset);
         const u16* index_address_16 = reinterpret_cast<const u16*>(index_address_8);
         bool index_u16 = index_info.format != 0;
-
+#ifdef DEBUG_CONTEXT
         if (g_debug_context && g_debug_context->recorder) {
             for (int i = 0; i < 3; ++i) {
                 const auto texture = regs.texturing.GetTextures()[i];
@@ -335,7 +337,7 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
                     texture.config.GetPhysicalAddress());
             }
         }
-
+#endif
         DebugUtils::MemoryAccessTracker memory_accesses;
 
         // Simple circular-replacement vertex cache
@@ -371,13 +373,13 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
                     g_state.geometry_pipeline.SubmitIndex(vertex);
                     continue;
                 }
-
+#ifdef DEBUG_CONTEXT
                 if (g_debug_context && Pica::g_debug_context->recorder) {
                     int size = index_u16 ? 2 : 1;
                     memory_accesses.AddAccess(base_address + index_info.offset + size * index,
                                               size);
                 }
-
+#endif
                 for (unsigned int i = 0; i < VERTEX_CACHE_SIZE; ++i) {
                     if (vertex_cache_valid[i] && vertex == vertex_cache_ids[i]) {
                         vs_output = vertex_cache[i];
@@ -411,17 +413,18 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
             // Send to geometry pipeline
             g_state.geometry_pipeline.SubmitVertex(vs_output);
         }
-
+#ifdef DEBUG_CONTEXT
         for (auto& range : memory_accesses.ranges) {
             g_debug_context->recorder->MemoryAccessed(
                 VideoCore::g_memory->GetPhysicalPointer(range.first), range.second, range.first);
         }
-
+#endif
         VideoCore::g_renderer->Rasterizer()->DrawTriangles();
+#ifdef DEBUG_CONTEXT
         if (g_debug_context) {
             g_debug_context->OnEvent(DebugContext::Event::FinishedPrimitiveBatch, nullptr);
         }
-
+#endif
         break;
     }
 
@@ -634,10 +637,11 @@ static void WritePicaReg(u32 id, u32 value, u32 mask) {
     }
 
     VideoCore::g_renderer->Rasterizer()->NotifyPicaRegisterChanged(id);
-
+#ifdef DEBUG_CONTEXT
     if (g_debug_context)
         g_debug_context->OnEvent(DebugContext::Event::PicaCommandProcessed,
                                  reinterpret_cast<void*>(&id));
+#endif
 }
 
 void ProcessCommandList(const u32* list, u32 size) {
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 932cf84172e..ff6875182c4 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -16,6 +16,7 @@
 #include "common/scope_exit.h"
 #include "common/vector_math.h"
 #include "core/hw/gpu.h"
+#include "core/settings.h"
 #include "video_core/pica_state.h"
 #include "video_core/regs_framebuffer.h"
 #include "video_core/regs_rasterizer.h"
@@ -23,6 +24,7 @@
 #include "video_core/renderer_opengl/gl_rasterizer.h"
 #include "video_core/renderer_opengl/gl_shader_gen.h"
 #include "video_core/renderer_opengl/gl_vars.h"
+#include "video_core/renderer_opengl/on_screen_display.h"
 #include "video_core/renderer_opengl/pica_to_gl.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
 #include "video_core/video_core.h"
@@ -51,9 +53,10 @@ RasterizerOpenGL::RasterizerOpenGL()
       index_buffer(GL_ELEMENT_ARRAY_BUFFER, INDEX_BUFFER_SIZE, false),
       texture_buffer(GL_TEXTURE_BUFFER, TEXTURE_BUFFER_SIZE, false) {
 
-    allow_shadow = GLAD_GL_ARB_shader_image_load_store && GLAD_GL_ARB_shader_image_size &&
-                   GLAD_GL_ARB_framebuffer_no_attachments;
-    if (!allow_shadow) {
+    AllowShadow = (GLAD_GL_ARB_shader_image_load_store && GLAD_GL_ARB_shader_image_size &&
+                   GLAD_GL_ARB_framebuffer_no_attachments) ||
+                  Settings::values.allow_shadow;
+    if (!AllowShadow) {
         LOG_WARNING(Render_OpenGL,
                     "Shadow might not be able to render because of unsupported OpenGL extensions.");
     }
@@ -66,14 +69,6 @@ RasterizerOpenGL::RasterizerOpenGL()
     // Clipping plane 0 is always enabled for PICA fixed clip plane z <= 0
     state.clip_distance[0] = true;
 
-    // Create a 1x1 clear texture to use in the NULL case,
-    // instead of OpenGL's default of solid black
-    glGenTextures(1, &default_texture);
-    glBindTexture(GL_TEXTURE_2D, default_texture);
-    // For some reason alpha 0 wraps around to 1.0, so use 1/255 instead
-    u8 framebuffer_data[4] = {0, 0, 0, 1};
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, framebuffer_data);
-
     // Create sampler objects
     for (std::size_t i = 0; i < texture_samplers.size(); ++i) {
         texture_samplers[i].Create();
@@ -88,6 +83,19 @@ RasterizerOpenGL::RasterizerOpenGL()
     sw_vao.Create();
     hw_vao.Create();
 
+    // Create render framebuffer
+    framebuffer.Create();
+
+    // null texture
+    texture_null.Create();
+    state.texture_units[0].texture_2d = texture_null.handle;
+
+    // Allocate and bind texture buffer lut textures
+    texture_buffer_lut_rg.Create();
+    texture_buffer_lut_rgba.Create();
+    state.texture_buffer_lut_rg.texture_buffer = texture_buffer_lut_rg.handle;
+    state.texture_buffer_lut_rgba.texture_buffer = texture_buffer_lut_rgba.handle;
+
     uniform_block_data.dirty = true;
 
     uniform_block_data.lighting_lut_dirty.fill(true);
@@ -142,29 +150,34 @@ RasterizerOpenGL::RasterizerOpenGL()
                           (GLvoid*)offsetof(HardwareVertex, view));
     glEnableVertexAttribArray(ATTRIBUTE_VIEW);
 
-    // Create render framebuffer
-    framebuffer.Create();
+    // Create a 1x1 clear texture to use in the NULL case,
+    // instead of OpenGL's default of solid black
+    // For some reason alpha 0 wraps around to 1.0, so use 1/255 instead
+    u8 null_data[4] = {0, 0, 0, 1};
+    glActiveTexture(TextureUnits::PicaTexture(0).Enum());
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, null_data);
 
-    // Allocate and bind texture buffer lut textures
-    texture_buffer_lut_rg.Create();
-    texture_buffer_lut_rgba.Create();
-    state.texture_buffer_lut_rg.texture_buffer = texture_buffer_lut_rg.handle;
-    state.texture_buffer_lut_rgba.texture_buffer = texture_buffer_lut_rgba.handle;
-    state.Apply();
     glActiveTexture(TextureUnits::TextureBufferLUT_RG.Enum());
     glTexBuffer(GL_TEXTURE_BUFFER, GL_RG32F, texture_buffer.GetHandle());
     glActiveTexture(TextureUnits::TextureBufferLUT_RGBA.Enum());
     glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, texture_buffer.GetHandle());
 
+    // restore
+    state.texture_units[0].texture_2d = 0;
     // Bind index buffer for hardware shader path
     state.draw.vertex_array = hw_vao.handle;
     state.Apply();
+
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer.GetHandle());
 
-    shader_program_manager =
-        std::make_unique<ShaderProgramManager>(GLAD_GL_ARB_separate_shader_objects, is_amd);
+    // 845需要开启分离着色器，但开启后Mali GPU会挂掉，究极日也有显示问题！
+    shader_program_manager = std::make_unique<ShaderProgramManager>(false, is_amd);
 
-    glEnable(GL_BLEND);
+    // init opengl state
+    glEnable(GL_CULL_FACE);
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_STENCIL_TEST);
+    glDisable(GL_BLEND);
 
     SyncEntireState();
 }
@@ -270,7 +283,7 @@ RasterizerOpenGL::VertexArrayInfo RasterizerOpenGL::AnalyzeVertexArray(bool is_i
         PAddr address = vertex_attributes.GetPhysicalBaseAddress() + index_info.offset;
         const u8* index_address_8 = VideoCore::g_memory->GetPhysicalPointer(address);
         const u16* index_address_16 = reinterpret_cast<const u16*>(index_address_8);
-        bool index_u16 = index_info.format != 0;
+        const bool index_u16 = index_info.format != 0;
 
         vertex_min = 0xFFFF;
         vertex_max = 0;
@@ -304,10 +317,6 @@ void RasterizerOpenGL::SetupVertexArray(u8* array_ptr, GLintptr buffer_offset,
     const auto& vertex_attributes = regs.pipeline.vertex_attributes;
     PAddr base_address = vertex_attributes.GetPhysicalBaseAddress();
 
-    state.draw.vertex_array = hw_vao.handle;
-    state.draw.vertex_buffer = vertex_buffer.GetHandle();
-    state.Apply();
-
     std::array<bool, 16> enable_attributes{};
 
     for (const auto& loader : vertex_attributes.attribute_loaders) {
@@ -378,16 +387,15 @@ void RasterizerOpenGL::SetupVertexArray(u8* array_ptr, GLintptr buffer_offset,
 
 bool RasterizerOpenGL::SetupVertexShader() {
     MICROPROFILE_SCOPE(OpenGL_VS);
-    PicaVSConfig vs_config(Pica::g_state.regs, Pica::g_state.vs);
-    return shader_program_manager->UseProgrammableVertexShader(vs_config, Pica::g_state.vs);
+    return shader_program_manager->UseProgrammableVertexShader(Pica::g_state.regs,
+                                                               Pica::g_state.vs);
 }
 
 bool RasterizerOpenGL::SetupGeometryShader() {
     MICROPROFILE_SCOPE(OpenGL_GS);
     const auto& regs = Pica::g_state.regs;
     if (regs.pipeline.use_gs == Pica::PipelineRegs::UseGS::No) {
-        PicaFixedGSConfig gs_config(regs);
-        shader_program_manager->UseFixedGeometryShader(gs_config);
+        shader_program_manager->UseFixedGeometryShader(regs);
         return true;
     } else {
         LOG_ERROR(Render_OpenGL, "Accelerate draw doesn't support geometry shader");
@@ -415,18 +423,8 @@ bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
 }
 
 static GLenum GetCurrentPrimitiveMode() {
-    const auto& regs = Pica::g_state.regs;
-    switch (regs.pipeline.triangle_topology) {
-    case Pica::PipelineRegs::TriangleTopology::Shader:
-    case Pica::PipelineRegs::TriangleTopology::List:
-        return GL_TRIANGLES;
-    case Pica::PipelineRegs::TriangleTopology::Fan:
-        return GL_TRIANGLE_FAN;
-    case Pica::PipelineRegs::TriangleTopology::Strip:
-        return GL_TRIANGLE_STRIP;
-    default:
-        UNREACHABLE();
-    }
+    const GLenum prims[] = {GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES};
+    return prims[static_cast<u32>(Pica::g_state.regs.pipeline.triangle_topology.Value())];
 }
 
 bool RasterizerOpenGL::AccelerateDrawBatchInternal(bool is_indexed) {
@@ -440,7 +438,9 @@ bool RasterizerOpenGL::AccelerateDrawBatchInternal(bool is_indexed) {
         return false;
     }
 
+    state.draw.vertex_array = hw_vao.handle;
     state.draw.vertex_buffer = vertex_buffer.GetHandle();
+    shader_program_manager->ApplyTo(state);
     state.Apply();
 
     u8* buffer_ptr;
@@ -449,9 +449,6 @@ bool RasterizerOpenGL::AccelerateDrawBatchInternal(bool is_indexed) {
     SetupVertexArray(buffer_ptr, buffer_offset, vs_input_index_min, vs_input_index_max);
     vertex_buffer.Unmap(vs_input_size);
 
-    shader_program_manager->ApplyTo(state);
-    state.Apply();
-
     if (is_indexed) {
         bool index_u16 = regs.pipeline.index_array.format != 0;
         std::size_t index_buffer_size = regs.pipeline.num_vertices * (index_u16 ? 2 : 1);
@@ -490,6 +487,9 @@ bool RasterizerOpenGL::Draw(bool accelerate, bool is_indexed) {
 
     bool shadow_rendering = regs.framebuffer.output_merger.fragment_operation_mode ==
                             Pica::FramebufferRegs::FragmentOperationMode::Shadow;
+    if (shadow_rendering && !AllowShadow) {
+        return true;
+    }
 
     const bool has_stencil =
         regs.framebuffer.framebuffer.depth_format == Pica::FramebufferRegs::DepthFormat::D24S8;
@@ -551,7 +551,7 @@ bool RasterizerOpenGL::Draw(bool accelerate, bool is_indexed) {
     state.Apply();
 
     if (shadow_rendering) {
-        if (!allow_shadow || color_surface == nullptr) {
+        if (color_surface == nullptr) {
             return true;
         }
         glFramebufferParameteri(GL_DRAW_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH,
@@ -640,9 +640,8 @@ bool RasterizerOpenGL::Draw(bool accelerate, bool is_indexed) {
                 using TextureType = Pica::TexturingRegs::TextureConfig::TextureType;
                 switch (texture.config.type.Value()) {
                 case TextureType::Shadow2D: {
-                    if (!allow_shadow)
+                    if (!AllowShadow)
                         continue;
-
                     Surface surface = res_cache.GetTextureSurface(texture);
                     if (surface != nullptr) {
                         CheckBarrier(state.image_shadow_texture_px = surface->texture.handle);
@@ -652,7 +651,7 @@ bool RasterizerOpenGL::Draw(bool accelerate, bool is_indexed) {
                     continue;
                 }
                 case TextureType::ShadowCube: {
-                    if (!allow_shadow)
+                    if (!AllowShadow)
                         continue;
                     Pica::Texture::TextureInfo info = Pica::Texture::TextureInfo::FromPicaRegister(
                         texture.config, texture.format);
@@ -749,10 +748,10 @@ bool RasterizerOpenGL::Draw(bool accelerate, bool is_indexed) {
                 // the geometry in question.
                 // For example: a bug in Pokemon X/Y causes NULL-texture squares to be drawn
                 // on the male character's face, which in the OpenGL default appear black.
-                state.texture_units[texture_index].texture_2d = default_texture;
+                state.texture_units[texture_index].texture_2d = texture_null.handle;
             }
         } else {
-            state.texture_units[texture_index].texture_2d = default_texture;
+            state.texture_units[texture_index].texture_2d = texture_null.handle;
         }
     }
 
@@ -777,7 +776,6 @@ bool RasterizerOpenGL::Draw(bool accelerate, bool is_indexed) {
     state.scissor.y = draw_rect.bottom;
     state.scissor.width = draw_rect.GetWidth();
     state.scissor.height = draw_rect.GetHeight();
-    state.Apply();
 
     // Draw the vertex batch
     bool succeeded = true;
@@ -813,7 +811,7 @@ bool RasterizerOpenGL::Draw(bool accelerate, bool is_indexed) {
         state.texture_units[texture_index].texture_2d = 0;
     }
     state.texture_cube_unit.texture_cube = 0;
-    if (allow_shadow) {
+    if (AllowShadow) {
         state.image_shadow_texture_px = 0;
         state.image_shadow_texture_nx = 0;
         state.image_shadow_texture_py = 0;
@@ -1622,8 +1620,7 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(
 }
 
 void RasterizerOpenGL::SetShader() {
-    auto config = PicaFSConfig::BuildFromRegs(Pica::g_state.regs);
-    shader_program_manager->UseFragmentShader(config);
+    shader_program_manager->UseFragmentShader(Pica::g_state.regs);
 }
 
 void RasterizerOpenGL::SyncClipEnabled() {
@@ -1642,28 +1639,9 @@ void RasterizerOpenGL::SyncClipCoef() {
 
 void RasterizerOpenGL::SyncCullMode() {
     const auto& regs = Pica::g_state.regs;
-
-    switch (regs.rasterizer.cull_mode) {
-    case Pica::RasterizerRegs::CullMode::KeepAll:
-        state.cull.enabled = false;
-        break;
-
-    case Pica::RasterizerRegs::CullMode::KeepClockWise:
-        state.cull.enabled = true;
-        state.cull.front_face = GL_CW;
-        break;
-
-    case Pica::RasterizerRegs::CullMode::KeepCounterClockWise:
-        state.cull.enabled = true;
-        state.cull.front_face = GL_CCW;
-        break;
-
-    default:
-        LOG_CRITICAL(Render_OpenGL, "Unknown cull mode {}",
-                     static_cast<u32>(regs.rasterizer.cull_mode.Value()));
-        UNIMPLEMENTED();
-        break;
-    }
+    state.cull.enabled = regs.rasterizer.cull_mode != Pica::RasterizerRegs::CullMode::KeepAll;
+    state.cull.front_face =
+        regs.rasterizer.cull_mode == Pica::RasterizerRegs::CullMode::KeepClockWise ? GL_CW : GL_CCW;
 }
 
 void RasterizerOpenGL::SyncDepthScale() {
@@ -1759,7 +1737,11 @@ void RasterizerOpenGL::SyncAlphaTest() {
 }
 
 void RasterizerOpenGL::SyncLogicOp() {
-    state.logic_op = PicaToGL::LogicOp(Pica::g_state.regs.framebuffer.output_merger.logic_op);
+    const auto& regs = Pica::g_state.regs;
+    state.logic_op = PicaToGL::LogicOp(regs.framebuffer.output_merger.logic_op);
+    if (GLES && (GLAD_GL_ARM_shader_framebuffer_fetch || GLAD_GL_EXT_shader_framebuffer_fetch)) {
+        shader_dirty = true;
+    }
 }
 
 void RasterizerOpenGL::SyncColorWriteMask() {
@@ -1933,7 +1915,7 @@ void RasterizerOpenGL::SyncShadowBias() {
         linear != uniform_block_data.data.shadow_bias_linear) {
         uniform_block_data.data.shadow_bias_constant = constant;
         uniform_block_data.data.shadow_bias_linear = linear;
-        uniform_block_data.dirty = true;
+        uniform_block_data.dirty = AllowShadow;
     }
 }
 
@@ -1941,7 +1923,7 @@ void RasterizerOpenGL::SyncShadowTextureBias() {
     GLint bias = Pica::g_state.regs.texturing.shadow.bias << 1;
     if (bias != uniform_block_data.data.shadow_texture_bias) {
         uniform_block_data.data.shadow_texture_bias = bias;
-        uniform_block_data.dirty = true;
+        uniform_block_data.dirty = AllowShadow;
     }
 }
 
@@ -2100,8 +2082,7 @@ void RasterizerOpenGL::SyncAndUploadLUTs() {
 void RasterizerOpenGL::UploadUniforms(bool accelerate_draw) {
     // glBindBufferRange below also changes the generic buffer binding point, so we sync the state
     // first
-    state.draw.uniform_buffer = uniform_buffer.GetHandle();
-    state.Apply();
+    OpenGLState::BindUniformBuffer(uniform_buffer.GetHandle());
 
     bool sync_vs = accelerate_draw;
     bool sync_fs = uniform_block_data.dirty;
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h
index 1ce47885d17..6a8f2949dbd 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -261,7 +261,6 @@ class RasterizerOpenGL : public VideoCore::RasterizerInterface {
     bool is_amd;
 
     OpenGLState state;
-    GLuint default_texture;
 
     RasterizerCacheOpenGL res_cache;
 
@@ -286,8 +285,8 @@ class RasterizerOpenGL : public VideoCore::RasterizerInterface {
 
     // They shall be big enough for about one frame.
     static constexpr std::size_t VERTEX_BUFFER_SIZE = 16 * 1024 * 1024;
-    static constexpr std::size_t INDEX_BUFFER_SIZE = 1 * 1024 * 1024;
-    static constexpr std::size_t UNIFORM_BUFFER_SIZE = 2 * 1024 * 1024;
+    static constexpr std::size_t INDEX_BUFFER_SIZE = 4 * 1024 * 1024;
+    static constexpr std::size_t UNIFORM_BUFFER_SIZE = 4 * 1024 * 1024;
     static constexpr std::size_t TEXTURE_BUFFER_SIZE = 1 * 1024 * 1024;
 
     OGLVertexArray sw_vao; // VAO for software shader draw
@@ -306,6 +305,7 @@ class RasterizerOpenGL : public VideoCore::RasterizerInterface {
 
     SamplerInfo texture_cube_sampler;
 
+    OGLTexture texture_null;
     OGLTexture texture_buffer_lut_rg;
     OGLTexture texture_buffer_lut_rgba;
 
@@ -316,8 +316,6 @@ class RasterizerOpenGL : public VideoCore::RasterizerInterface {
     std::array<GLvec2, 128> proctex_alpha_map_data{};
     std::array<GLvec4, 256> proctex_lut_data{};
     std::array<GLvec4, 256> proctex_diff_lut_data{};
-
-    bool allow_shadow;
 };
 
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index a77334b52d0..d36e457a95f 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -24,6 +24,7 @@
 #include "common/vector_math.h"
 #include "core/frontend/emu_window.h"
 #include "core/memory.h"
+#include "core/settings.h"
 #include "video_core/pica_state.h"
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
@@ -87,77 +88,6 @@ static const FormatTuple& GetFormatTuple(PixelFormat pixel_format) {
     return tex_tuple;
 }
 
-/**
- * OpenGL ES does not support glGetTexImage. Obtain the pixels by attaching the
- * texture to a framebuffer.
- * Originally from https://github.com/apitrace/apitrace/blob/master/retrace/glstate_images.cpp
- */
-static inline void GetTexImageOES(GLenum target, GLint level, GLenum format, GLenum type,
-                                  GLint height, GLint width, GLint depth, GLubyte* pixels) {
-
-    memset(pixels, 0x80, height * width * 4);
-
-    GLenum texture_binding = GL_NONE;
-    switch (target) {
-    case GL_TEXTURE_2D:
-        texture_binding = GL_TEXTURE_BINDING_2D;
-        break;
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-        texture_binding = GL_TEXTURE_BINDING_CUBE_MAP;
-        break;
-    case GL_TEXTURE_3D_OES:
-        texture_binding = GL_TEXTURE_BINDING_3D_OES;
-    default:
-        return;
-    }
-
-    GLint texture = 0;
-    glGetIntegerv(texture_binding, &texture);
-    if (!texture) {
-        return;
-    }
-
-    GLint prev_fbo = 0;
-    GLuint fbo = 0;
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prev_fbo);
-    glGenFramebuffers(1, &fbo);
-    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
-
-    switch (target) {
-    case GL_TEXTURE_2D:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: {
-        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, level);
-        GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-        if (status != GL_FRAMEBUFFER_COMPLETE) {
-            LOG_DEBUG(Render_OpenGL, "Framebuffer is incomplete, status: {:X}", status);
-        }
-        glReadPixels(0, 0, width, height, format, type, pixels);
-        break;
-    }
-    case GL_TEXTURE_3D_OES:
-        for (int i = 0; i < depth; i++) {
-            glFramebufferTexture3D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_3D, texture,
-                                   level, i);
-            glReadPixels(0, 0, width, height, format, type, pixels + 4 * i * width * height);
-        }
-        break;
-    }
-
-    glBindFramebuffer(GL_FRAMEBUFFER, prev_fbo);
-
-    glDeleteFramebuffers(1, &fbo);
-}
-
 template <typename Map, typename Interval>
 constexpr auto RangeFromInterval(Map& map, const Interval& interval) {
     return boost::make_iterator_range(map.equal_range(interval));
@@ -311,13 +241,8 @@ static constexpr std::array<void (*)(u32, u32, u8*, PAddr, PAddr, PAddr), 18> gl
 // Allocate an uninitialized texture of appropriate size and format for the surface
 static void AllocateSurfaceTexture(GLuint texture, const FormatTuple& format_tuple, u32 width,
                                    u32 height) {
-    OpenGLState cur_state = OpenGLState::GetCurState();
-
     // Keep track of previous texture bindings
-    GLuint old_tex = cur_state.texture_units[0].texture_2d;
-    cur_state.texture_units[0].texture_2d = texture;
-    cur_state.Apply();
-    glActiveTexture(GL_TEXTURE0);
+    GLuint old_tex = OpenGLState::BindTexture2D(0, texture);
 
     glTexImage2D(GL_TEXTURE_2D, 0, format_tuple.internal_format, width, height, 0,
                  format_tuple.format, format_tuple.type, nullptr);
@@ -328,18 +253,12 @@ static void AllocateSurfaceTexture(GLuint texture, const FormatTuple& format_tup
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
     // Restore previous texture bindings
-    cur_state.texture_units[0].texture_2d = old_tex;
-    cur_state.Apply();
+    OpenGLState::BindTexture2D(0, old_tex);
 }
 
 static void AllocateTextureCube(GLuint texture, const FormatTuple& format_tuple, u32 width) {
-    OpenGLState cur_state = OpenGLState::GetCurState();
-
     // Keep track of previous texture bindings
-    GLuint old_tex = cur_state.texture_cube_unit.texture_cube;
-    cur_state.texture_cube_unit.texture_cube = texture;
-    cur_state.Apply();
-    glActiveTexture(TextureUnits::TextureCube.Enum());
+    GLuint old_tex = OpenGLState::BindTextureCube(texture);
 
     for (auto faces : {
              GL_TEXTURE_CUBE_MAP_POSITIVE_X,
@@ -354,16 +273,13 @@ static void AllocateTextureCube(GLuint texture, const FormatTuple& format_tuple,
     }
 
     // Restore previous texture bindings
-    cur_state.texture_cube_unit.texture_cube = old_tex;
-    cur_state.Apply();
+    OpenGLState::BindTextureCube(old_tex);
 }
 
 static bool BlitTextures(GLuint src_tex, const Common::Rectangle<u32>& src_rect, GLuint dst_tex,
                          const Common::Rectangle<u32>& dst_rect, SurfaceType type,
                          GLuint read_fb_handle, GLuint draw_fb_handle) {
     OpenGLState prev_state = OpenGLState::GetCurState();
-    SCOPE_EXIT({ prev_state.Apply(); });
-
     OpenGLState state;
     state.draw.read_framebuffer = read_fb_handle;
     state.draw.draw_framebuffer = draw_fb_handle;
@@ -413,22 +329,19 @@ static bool BlitTextures(GLuint src_tex, const Common::Rectangle<u32>& src_rect,
     glBlitFramebuffer(src_rect.left, src_rect.bottom, src_rect.right, src_rect.top, dst_rect.left,
                       dst_rect.bottom, dst_rect.right, dst_rect.top, buffers,
                       buffers == GL_COLOR_BUFFER_BIT ? GL_LINEAR : GL_NEAREST);
-
+    prev_state.Apply();
     return true;
 }
 
 static bool FillSurface(const Surface& surface, const u8* fill_data,
                         const Common::Rectangle<u32>& fill_rect, GLuint draw_fb_handle) {
     OpenGLState prev_state = OpenGLState::GetCurState();
-    SCOPE_EXIT({ prev_state.Apply(); });
-
     OpenGLState state;
     state.scissor.enabled = true;
     state.scissor.x = static_cast<GLint>(fill_rect.left);
     state.scissor.y = static_cast<GLint>(fill_rect.bottom);
     state.scissor.width = static_cast<GLsizei>(fill_rect.GetWidth());
     state.scissor.height = static_cast<GLsizei>(fill_rect.GetHeight());
-
     state.draw.draw_framebuffer = draw_fb_handle;
     state.Apply();
 
@@ -489,6 +402,7 @@ static bool FillSurface(const Surface& surface, const u8* fill_data,
         state.Apply();
         glClearBufferfi(GL_DEPTH_STENCIL, 0, value_float, value_int);
     }
+    prev_state.Apply();
     return true;
 }
 
@@ -730,15 +644,13 @@ void RasterizerCacheOpenGL::CopySurface(const Surface& src_surface, const Surfac
 MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 192, 64));
 void CachedSurface::LoadGLBuffer(PAddr load_start, PAddr load_end) {
     ASSERT(type != SurfaceType::Fill);
-    const bool need_swap =
-        GLES && (pixel_format == PixelFormat::RGBA8 || pixel_format == PixelFormat::RGB8);
 
     const u8* const texture_src_data = VideoCore::g_memory->GetPhysicalPointer(addr);
     if (texture_src_data == nullptr)
         return;
 
     if (gl_buffer == nullptr) {
-        gl_buffer_size = width * height * GetGLBytesPerPixel(pixel_format);
+        gl_buffer_size = stride * height * GetGLBytesPerPixel(pixel_format);
         gl_buffer.reset(new u8[gl_buffer_size]);
     }
 
@@ -756,6 +668,8 @@ void CachedSurface::LoadGLBuffer(PAddr load_start, PAddr load_end) {
 
     if (!is_tiled) {
         ASSERT(type == SurfaceType::Color);
+        const bool need_swap =
+            GLES && (pixel_format == PixelFormat::RGBA8 || pixel_format == PixelFormat::RGB8);
         if (need_swap) {
             // TODO(liushuyu): check if the byteswap here is 100% correct
             // cannot fully test this
@@ -811,8 +725,6 @@ void CachedSurface::FlushGLBuffer(PAddr flush_start, PAddr flush_end) {
     if (dst_buffer == nullptr)
         return;
 
-    ASSERT(gl_buffer_size == width * height * GetGLBytesPerPixel(pixel_format));
-
     // TODO: Should probably be done in ::Memory:: and check for other regions too
     // same as loadglbuffer()
     if (flush_start < Memory::VRAM_VADDR_END && flush_end > Memory::VRAM_VADDR_END)
@@ -853,20 +765,13 @@ void CachedSurface::FlushGLBuffer(PAddr flush_start, PAddr flush_end) {
 MICROPROFILE_DEFINE(OpenGL_TextureUL, "OpenGL", "Texture Upload", MP_RGB(128, 192, 64));
 void CachedSurface::UploadGLTexture(const Common::Rectangle<u32>& rect, GLuint read_fb_handle,
                                     GLuint draw_fb_handle) {
-    if (type == SurfaceType::Fill)
-        return;
-
     MICROPROFILE_SCOPE(OpenGL_TextureUL);
-
-    ASSERT(gl_buffer_size == width * height * GetGLBytesPerPixel(pixel_format));
-
     // Load data from memory to the surface
-    GLint x0 = static_cast<GLint>(rect.left);
-    GLint y0 = static_cast<GLint>(rect.bottom);
-    std::size_t buffer_offset = (y0 * stride + x0) * GetGLBytesPerPixel(pixel_format);
-
     const FormatTuple& tuple = GetFormatTuple(pixel_format);
+    u32 x0 = rect.left;
+    u32 y0 = rect.bottom;
     GLuint target_tex = texture.handle;
+    u32 bytes_per_pixel = GetGLBytesPerPixel(pixel_format);
 
     // If not 1x scale, create 1x texture that we will blit from to replace texture subrect in
     // surface
@@ -874,31 +779,32 @@ void CachedSurface::UploadGLTexture(const Common::Rectangle<u32>& rect, GLuint r
     if (res_scale != 1) {
         x0 = 0;
         y0 = 0;
-
         unscaled_tex.Create();
         AllocateSurfaceTexture(unscaled_tex.handle, tuple, rect.GetWidth(), rect.GetHeight());
         target_tex = unscaled_tex.handle;
     }
 
-    OpenGLState cur_state = OpenGLState::GetCurState();
-
-    GLuint old_tex = cur_state.texture_units[0].texture_2d;
-    cur_state.texture_units[0].texture_2d = target_tex;
-    cur_state.Apply();
+    if (!upload_pbo.handle) {
+        upload_pbo.Create();
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, upload_pbo.handle);
+        glBufferData(GL_PIXEL_UNPACK_BUFFER, Common::AlignUp(gl_buffer_size, 8), nullptr,
+                     GL_STREAM_DRAW);
+    } else {
+        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, upload_pbo.handle);
+    }
 
-    // Ensure no bad interactions with GL_UNPACK_ALIGNMENT
-    ASSERT(stride * GetGLBytesPerPixel(pixel_format) % 4 == 0);
+    GLuint old_tex = OpenGLState::BindTexture2D(0, target_tex);
+    std::size_t buffer_offset = (y0 * stride + x0) * bytes_per_pixel;
     glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(stride));
-
-    glActiveTexture(GL_TEXTURE0);
+    glBufferSubData(GL_PIXEL_UNPACK_BUFFER, buffer_offset,
+                    rect.GetWidth() * rect.GetHeight() * bytes_per_pixel,
+                    &gl_buffer[buffer_offset]);
     glTexSubImage2D(GL_TEXTURE_2D, 0, x0, y0, static_cast<GLsizei>(rect.GetWidth()),
                     static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
-                    &gl_buffer[buffer_offset]);
-
+                    (void*)buffer_offset);
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
-
-    cur_state.texture_units[0].texture_2d = old_tex;
-    cur_state.Apply();
+    OpenGLState::BindTexture2D(0, old_tex);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
     if (res_scale != 1) {
         auto scaled_rect = rect;
@@ -906,7 +812,6 @@ void CachedSurface::UploadGLTexture(const Common::Rectangle<u32>& rect, GLuint r
         scaled_rect.top *= res_scale;
         scaled_rect.right *= res_scale;
         scaled_rect.bottom *= res_scale;
-
         BlitTextures(unscaled_tex.handle, {0, rect.GetHeight(), rect.GetWidth(), 0}, texture.handle,
                      scaled_rect, type, read_fb_handle, draw_fb_handle);
     }
@@ -917,79 +822,62 @@ void CachedSurface::UploadGLTexture(const Common::Rectangle<u32>& rect, GLuint r
 MICROPROFILE_DEFINE(OpenGL_TextureDL, "OpenGL", "Texture Download", MP_RGB(128, 192, 64));
 void CachedSurface::DownloadGLTexture(const Common::Rectangle<u32>& rect, GLuint read_fb_handle,
                                       GLuint draw_fb_handle) {
-    if (type == SurfaceType::Fill)
-        return;
-
     MICROPROFILE_SCOPE(OpenGL_TextureDL);
-
+    u32 bytes_per_pixel = GetGLBytesPerPixel(pixel_format);
+    const FormatTuple& tuple = GetFormatTuple(pixel_format);
     if (gl_buffer == nullptr) {
-        gl_buffer_size = width * height * GetGLBytesPerPixel(pixel_format);
+        gl_buffer_size = stride * height * bytes_per_pixel;
         gl_buffer.reset(new u8[gl_buffer_size]);
     }
 
-    OpenGLState state = OpenGLState::GetCurState();
-    OpenGLState prev_state = state;
-    SCOPE_EXIT({ prev_state.Apply(); });
-
-    const FormatTuple& tuple = GetFormatTuple(pixel_format);
-
-    // Ensure no bad interactions with GL_PACK_ALIGNMENT
-    ASSERT(stride * GetGLBytesPerPixel(pixel_format) % 4 == 0);
-    glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(stride));
-    std::size_t buffer_offset =
-        (rect.bottom * stride + rect.left) * GetGLBytesPerPixel(pixel_format);
+    GLint x0 = rect.left;
+    GLint y0 = rect.bottom;
+    GLuint target_tex = texture.handle;
 
     // If not 1x scale, blit scaled texture to a new 1x texture and use that to flush
+    OGLTexture unscaled_tex;
     if (res_scale != 1) {
         auto scaled_rect = rect;
         scaled_rect.left *= res_scale;
         scaled_rect.top *= res_scale;
         scaled_rect.right *= res_scale;
         scaled_rect.bottom *= res_scale;
-
-        OGLTexture unscaled_tex;
         unscaled_tex.Create();
+        x0 = 0;
+        y0 = 0;
+        target_tex = unscaled_tex.handle;
 
         Common::Rectangle<u32> unscaled_tex_rect{0, rect.GetHeight(), rect.GetWidth(), 0};
         AllocateSurfaceTexture(unscaled_tex.handle, tuple, rect.GetWidth(), rect.GetHeight());
         BlitTextures(texture.handle, scaled_rect, unscaled_tex.handle, unscaled_tex_rect, type,
                      read_fb_handle, draw_fb_handle);
-
-        state.texture_units[0].texture_2d = unscaled_tex.handle;
-        state.Apply();
-
-        glActiveTexture(GL_TEXTURE0);
-        if (GLES) {
-            GetTexImageOES(GL_TEXTURE_2D, 0, tuple.format, tuple.type, rect.GetHeight(),
-                           rect.GetWidth(), 0, &gl_buffer[buffer_offset]);
-        } else {
-            glGetTexImage(GL_TEXTURE_2D, 0, tuple.format, tuple.type, &gl_buffer[buffer_offset]);
-        }
     } else {
-        state.ResetTexture(texture.handle);
-        state.draw.read_framebuffer = read_fb_handle;
-        state.Apply();
+        OpenGLState::ResetTexture(target_tex);
+    }
 
-        if (type == SurfaceType::Color || type == SurfaceType::Texture) {
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                                   texture.handle, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
-                                   0, 0);
-        } else if (type == SurfaceType::Depth) {
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D,
-                                   texture.handle, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
-        } else {
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
-            glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
-                                   texture.handle, 0);
-        }
-        glReadPixels(static_cast<GLint>(rect.left), static_cast<GLint>(rect.bottom),
-                     static_cast<GLsizei>(rect.GetWidth()), static_cast<GLsizei>(rect.GetHeight()),
-                     tuple.format, tuple.type, &gl_buffer[buffer_offset]);
+    glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(stride));
+    GLuint old_fb = OpenGLState::BindReadFramebuffer(read_fb_handle);
+    std::size_t buffer_offset = (y0 * stride + x0) * bytes_per_pixel;
+    if (type == SurfaceType::Color || type == SurfaceType::Texture) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, target_tex,
+                               0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
+                               0);
+    } else if (type == SurfaceType::Depth) {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, target_tex,
+                               0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
+    } else {
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
+        glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
+                               target_tex, 0);
     }
+    glReadPixels(x0, y0, static_cast<GLsizei>(rect.GetWidth()),
+                 static_cast<GLsizei>(rect.GetHeight()), tuple.format, tuple.type,
+                 &gl_buffer[buffer_offset]);
 
+    OpenGLState::BindReadFramebuffer(old_fb);
     glPixelStorei(GL_PACK_ROW_LENGTH, 0);
 }
 
@@ -1175,13 +1063,22 @@ void RasterizerCacheOpenGL::ConvertD24S8toABGR(GLuint src_tex,
                                                GLuint dst_tex,
                                                const Common::Rectangle<u32>& dst_rect) {
     OpenGLState prev_state = OpenGLState::GetCurState();
-    SCOPE_EXIT({ prev_state.Apply(); });
 
     OpenGLState state;
     state.draw.read_framebuffer = read_framebuffer.handle;
     state.draw.draw_framebuffer = draw_framebuffer.handle;
+    state.draw.shader_program = d24s8_abgr_shader.handle;
+    state.draw.vertex_array = attributeless_vao.handle;
+    state.viewport.x = static_cast<GLint>(dst_rect.left);
+    state.viewport.y = static_cast<GLint>(dst_rect.bottom);
+    state.viewport.width = static_cast<GLsizei>(dst_rect.GetWidth());
+    state.viewport.height = static_cast<GLsizei>(dst_rect.GetHeight());
     state.Apply();
 
+    OGLTexture tbo;
+    tbo.Create();
+    OpenGLState::BindTexture2D(0, tbo.handle);
+
     glBindBuffer(GL_PIXEL_PACK_BUFFER, d24s8_abgr_buffer.handle);
 
     GLsizeiptr target_pbo_size = src_rect.GetWidth() * src_rect.GetHeight() * 4;
@@ -1201,18 +1098,6 @@ void RasterizerCacheOpenGL::ConvertD24S8toABGR(GLuint src_tex,
     glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
 
     // PBO now contains src_tex in RABG format
-    state.draw.shader_program = d24s8_abgr_shader.handle;
-    state.draw.vertex_array = attributeless_vao.handle;
-    state.viewport.x = static_cast<GLint>(dst_rect.left);
-    state.viewport.y = static_cast<GLint>(dst_rect.bottom);
-    state.viewport.width = static_cast<GLsizei>(dst_rect.GetWidth());
-    state.viewport.height = static_cast<GLsizei>(dst_rect.GetHeight());
-    state.Apply();
-
-    OGLTexture tbo;
-    tbo.Create();
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_BUFFER, tbo.handle);
     glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA8, d24s8_abgr_buffer.handle);
 
     glUniform2f(d24s8_abgr_tbo_size_u_id, static_cast<GLfloat>(src_rect.GetWidth()),
@@ -1226,6 +1111,7 @@ void RasterizerCacheOpenGL::ConvertD24S8toABGR(GLuint src_tex,
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
     glBindTexture(GL_TEXTURE_BUFFER, 0);
+    prev_state.Apply();
 }
 
 Surface RasterizerCacheOpenGL::GetSurface(const SurfaceParams& params, ScaleMatch match_res_scale,
@@ -1401,16 +1287,11 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Pica::Texture::TextureInf
             LOG_CRITICAL(Render_OpenGL, "Unsupported mipmap level {}", max_level);
             return nullptr;
         }
-        OpenGLState prev_state = OpenGLState::GetCurState();
-        OpenGLState state;
-        SCOPE_EXIT({ prev_state.Apply(); });
-        auto format_tuple = GetFormatTuple(params.pixel_format);
+        const FormatTuple& format_tuple = GetFormatTuple(params.pixel_format);
 
         // Allocate more mipmap level if necessary
         if (surface->max_level < max_level) {
-            state.texture_units[0].texture_2d = surface->texture.handle;
-            state.Apply();
-            glActiveTexture(GL_TEXTURE0);
+            GLuint old_tex = OpenGLState::BindTexture2D(0, surface->texture.handle);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, max_level);
             u32 width = surface->width * surface->res_scale;
             u32 height = surface->height * surface->res_scale;
@@ -1419,12 +1300,14 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Pica::Texture::TextureInf
                              height >> level, 0, format_tuple.format, format_tuple.type, nullptr);
             }
             surface->max_level = max_level;
+            OpenGLState::BindTexture2D(0, old_tex);
         }
 
         // Blit mipmaps that have been invalidated
+        OpenGLState prev_state = OpenGLState::GetCurState();
+        OpenGLState state;
         state.draw.read_framebuffer = read_framebuffer.handle;
         state.draw.draw_framebuffer = draw_framebuffer.handle;
-        state.ResetTexture(surface->texture.handle);
         SurfaceParams params = *surface;
         for (u32 level = 1; level <= max_level; ++level) {
             // In PICA all mipmap levels are stored next to each other
@@ -1448,7 +1331,6 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Pica::Texture::TextureInf
                 if (!level_surface->invalid_regions.empty()) {
                     ValidateSurface(level_surface, level_surface->addr, level_surface->size);
                 }
-                state.ResetTexture(level_surface->texture.handle);
                 state.Apply();
                 glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                                        level_surface->texture.handle, 0);
@@ -1468,6 +1350,7 @@ Surface RasterizerCacheOpenGL::GetTextureSurface(const Pica::Texture::TextureInf
                 watcher->Validate();
             }
         }
+        prev_state.Apply();
     }
 
     return surface;
@@ -1530,20 +1413,15 @@ const CachedTextureCube& RasterizerCacheOpenGL::GetTextureCube(const TextureCube
     u32 scaled_size = cube.res_scale * config.width;
 
     OpenGLState prev_state = OpenGLState::GetCurState();
-    SCOPE_EXIT({ prev_state.Apply(); });
-
     OpenGLState state;
     state.draw.read_framebuffer = read_framebuffer.handle;
     state.draw.draw_framebuffer = draw_framebuffer.handle;
-    state.ResetTexture(cube.texture.handle);
-
     for (const Face& face : faces) {
         if (face.watcher && !face.watcher->IsValid()) {
             auto surface = face.watcher->Get();
             if (!surface->invalid_regions.empty()) {
                 ValidateSurface(surface, surface->addr, surface->size);
             }
-            state.ResetTexture(surface->texture.handle);
             state.Apply();
             glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                                    surface->texture.handle, 0);
@@ -1561,7 +1439,7 @@ const CachedTextureCube& RasterizerCacheOpenGL::GetTextureCube(const TextureCube
             face.watcher->Validate();
         }
     }
-
+    prev_state.Apply();
     return cube;
 }
 
@@ -1763,15 +1641,15 @@ void RasterizerCacheOpenGL::ValidateSurface(const Surface& surface, PAddr addr,
                 FindMatch<MatchFlags::Copy>(surface_cache, params, ScaleMatch::Ignore, interval);
             if (reinterpret_surface != nullptr) {
                 ASSERT(reinterpret_surface->pixel_format == PixelFormat::D24S8);
-
                 SurfaceInterval convert_interval = params.GetCopyableInterval(reinterpret_surface);
-                SurfaceParams convert_params = surface->FromInterval(convert_interval);
-                auto src_rect = reinterpret_surface->GetScaledSubRect(convert_params);
-                auto dest_rect = surface->GetScaledSubRect(convert_params);
-
-                ConvertD24S8toABGR(reinterpret_surface->texture.handle, src_rect,
-                                   surface->texture.handle, dest_rect);
+                if (!GLES) {
+                    SurfaceParams convert_params = surface->FromInterval(convert_interval);
+                    auto src_rect = reinterpret_surface->GetScaledSubRect(convert_params);
+                    auto dest_rect = surface->GetScaledSubRect(convert_params);
 
+                    ConvertD24S8toABGR(reinterpret_surface->texture.handle, src_rect,
+                                       surface->texture.handle, dest_rect);
+                }
                 surface->invalid_regions.erase(convert_interval);
                 continue;
             }
@@ -1779,9 +1657,11 @@ void RasterizerCacheOpenGL::ValidateSurface(const Surface& surface, PAddr addr,
 
         // Load data from 3DS memory
         FlushRegion(params.addr, params.size);
-        surface->LoadGLBuffer(params.addr, params.end);
-        surface->UploadGLTexture(surface->GetSubRect(params), read_framebuffer.handle,
-                                 draw_framebuffer.handle);
+        if (!GLES || surface->pixel_format < PixelFormat::D16) {
+            surface->LoadGLBuffer(params.addr, params.end);
+            surface->UploadGLTexture(surface->GetSubRect(params), read_framebuffer.handle,
+                                     draw_framebuffer.handle);
+        }
         surface->invalid_regions.erase(params.GetInterval());
     }
 }
@@ -1803,15 +1683,14 @@ void RasterizerCacheOpenGL::FlushRegion(PAddr addr, u32 size, Surface flush_surf
         if (flush_surface != nullptr && surface != flush_surface)
             continue;
 
-        // Sanity check, this surface is the last one that marked this region dirty
-        ASSERT(surface->IsRegionValid(interval));
-
-        if (surface->type != SurfaceType::Fill) {
-            SurfaceParams params = surface->FromInterval(interval);
-            surface->DownloadGLTexture(surface->GetSubRect(params), read_framebuffer.handle,
-                                       draw_framebuffer.handle);
+        if (!GLES || surface->pixel_format < PixelFormat::D16) {
+            if (surface->type != SurfaceType::Fill) {
+                SurfaceParams params = surface->FromInterval(interval);
+                surface->DownloadGLTexture(surface->GetSubRect(params), read_framebuffer.handle,
+                                           draw_framebuffer.handle);
+            }
+            surface->FlushGLBuffer(boost::icl::first(interval), boost::icl::last_next(interval));
         }
-        surface->FlushGLBuffer(boost::icl::first(interval), boost::icl::last_next(interval));
         flushed_intervals += interval;
     }
     // Reset dirty regions
@@ -1890,7 +1769,6 @@ Surface RasterizerCacheOpenGL::CreateSurface(const SurfaceParams& params) {
 
     surface->texture.Create();
 
-    surface->gl_buffer_size = 0;
     surface->invalid_regions.insert(surface->GetInterval());
     AllocateSurfaceTexture(surface->texture.handle, GetFormatTuple(surface->pixel_format),
                            surface->GetScaledWidth(), surface->GetScaledHeight());
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index 962cbceb6fb..054739abd97 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -30,6 +30,9 @@
 #include "video_core/regs_texturing.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/texture/texture_decode.h"
+#ifdef ANDROID
+#include "video_core/renderer_opengl/graphic_buffer.h"
+#endif
 
 namespace OpenGL {
 
@@ -409,6 +412,7 @@ struct CachedSurface : SurfaceParams, std::enable_shared_from_this<CachedSurface
 
 private:
     std::list<std::weak_ptr<SurfaceWatcher>> watchers;
+    OGLBuffer upload_pbo;
 };
 
 struct CachedTextureCube {
diff --git a/src/video_core/renderer_opengl/gl_resource_manager.cpp b/src/video_core/renderer_opengl/gl_resource_manager.cpp
index 1cffc8ea725..ea08b829633 100644
--- a/src/video_core/renderer_opengl/gl_resource_manager.cpp
+++ b/src/video_core/renderer_opengl/gl_resource_manager.cpp
@@ -29,7 +29,7 @@ void OGLTexture::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteTextures(1, &handle);
-    OpenGLState::GetCurState().ResetTexture(handle).Apply();
+    OpenGLState::ResetTexture(handle);
     handle = 0;
 }
 
@@ -47,7 +47,7 @@ void OGLSampler::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteSamplers(1, &handle);
-    OpenGLState::GetCurState().ResetSampler(handle).Apply();
+    OpenGLState::ResetSampler(handle);
     handle = 0;
 }
 
@@ -93,7 +93,7 @@ void OGLProgram::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteProgram(handle);
-    OpenGLState::GetCurState().ResetProgram(handle).Apply();
+    OpenGLState::ResetProgram(handle);
     handle = 0;
 }
 
@@ -111,7 +111,7 @@ void OGLPipeline::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteProgramPipelines(1, &handle);
-    OpenGLState::GetCurState().ResetPipeline(handle).Apply();
+    OpenGLState::ResetPipeline(handle);
     handle = 0;
 }
 
@@ -129,7 +129,7 @@ void OGLBuffer::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteBuffers(1, &handle);
-    OpenGLState::GetCurState().ResetBuffer(handle).Apply();
+    OpenGLState::ResetBuffer(handle);
     handle = 0;
 }
 
@@ -147,7 +147,7 @@ void OGLVertexArray::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteVertexArrays(1, &handle);
-    OpenGLState::GetCurState().ResetVertexArray(handle).Apply();
+    OpenGLState::ResetVertexArray(handle);
     handle = 0;
 }
 
@@ -165,7 +165,7 @@ void OGLFramebuffer::Release() {
 
     MICROPROFILE_SCOPE(OpenGL_ResourceDeletion);
     glDeleteFramebuffers(1, &handle);
-    OpenGLState::GetCurState().ResetFramebuffer(handle).Apply();
+    OpenGLState::ResetFramebuffer(handle);
     handle = 0;
 }
 
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.cpp b/src/video_core/renderer_opengl/gl_shader_gen.cpp
index 49f307060c5..66f1965a6c9 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_gen.cpp
@@ -110,7 +110,7 @@ out gl_PerVertex {
 }
 
 PicaFSConfig PicaFSConfig::BuildFromRegs(const Pica::Regs& regs) {
-    PicaFSConfig res;
+    PicaFSConfig res{};
 
     auto& state = res.state;
 
@@ -118,6 +118,13 @@ PicaFSConfig PicaFSConfig::BuildFromRegs(const Pica::Regs& regs) {
 
     state.depthmap_enable = regs.rasterizer.depthmap_enable;
 
+    if (GLES && (GLAD_GL_ARM_shader_framebuffer_fetch || GLAD_GL_EXT_shader_framebuffer_fetch) &&
+        regs.framebuffer.output_merger.alphablend_enable == 0) {
+        state.logic_op = regs.framebuffer.output_merger.logic_op;
+    } else {
+        state.logic_op = FramebufferRegs::LogicOp::Copy;
+    }
+
     state.alpha_test_func = regs.framebuffer.output_merger.alpha_test.enable
                                 ? regs.framebuffer.output_merger.alpha_test.func.Value()
                                 : FramebufferRegs::CompareFunc::Always;
@@ -147,75 +154,79 @@ PicaFSConfig PicaFSConfig::BuildFromRegs(const Pica::Regs& regs) {
                                       << 4;
 
     // Fragment lighting
-
     state.lighting.enable = !regs.lighting.disable;
-    state.lighting.src_num = regs.lighting.max_light_index + 1;
-
-    for (unsigned light_index = 0; light_index < state.lighting.src_num; ++light_index) {
-        unsigned num = regs.lighting.light_enable.GetNum(light_index);
-        const auto& light = regs.lighting.light[num];
-        state.lighting.light[light_index].num = num;
-        state.lighting.light[light_index].directional = light.config.directional != 0;
-        state.lighting.light[light_index].two_sided_diffuse = light.config.two_sided_diffuse != 0;
-        state.lighting.light[light_index].geometric_factor_0 = light.config.geometric_factor_0 != 0;
-        state.lighting.light[light_index].geometric_factor_1 = light.config.geometric_factor_1 != 0;
-        state.lighting.light[light_index].dist_atten_enable =
-            !regs.lighting.IsDistAttenDisabled(num);
-        state.lighting.light[light_index].spot_atten_enable =
-            !regs.lighting.IsSpotAttenDisabled(num);
-        state.lighting.light[light_index].shadow_enable = !regs.lighting.IsShadowDisabled(num);
-    }
+    if (state.lighting.enable) {
+        state.lighting.src_num = regs.lighting.max_light_index + 1;
+
+        for (unsigned light_index = 0; light_index < state.lighting.src_num; ++light_index) {
+            unsigned num = regs.lighting.light_enable.GetNum(light_index);
+            const auto& light = regs.lighting.light[num];
+            state.lighting.light[light_index].num = num;
+            state.lighting.light[light_index].directional = light.config.directional != 0;
+            state.lighting.light[light_index].two_sided_diffuse =
+                light.config.two_sided_diffuse != 0;
+            state.lighting.light[light_index].geometric_factor_0 =
+                light.config.geometric_factor_0 != 0;
+            state.lighting.light[light_index].geometric_factor_1 =
+                light.config.geometric_factor_1 != 0;
+            state.lighting.light[light_index].dist_atten_enable =
+                !regs.lighting.IsDistAttenDisabled(num);
+            state.lighting.light[light_index].spot_atten_enable =
+                !regs.lighting.IsSpotAttenDisabled(num);
+            state.lighting.light[light_index].shadow_enable = !regs.lighting.IsShadowDisabled(num);
+        }
 
-    state.lighting.lut_d0.enable = regs.lighting.config1.disable_lut_d0 == 0;
-    state.lighting.lut_d0.abs_input = regs.lighting.abs_lut_input.disable_d0 == 0;
-    state.lighting.lut_d0.type = regs.lighting.lut_input.d0.Value();
-    state.lighting.lut_d0.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.d0);
-
-    state.lighting.lut_d1.enable = regs.lighting.config1.disable_lut_d1 == 0;
-    state.lighting.lut_d1.abs_input = regs.lighting.abs_lut_input.disable_d1 == 0;
-    state.lighting.lut_d1.type = regs.lighting.lut_input.d1.Value();
-    state.lighting.lut_d1.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.d1);
-
-    // this is a dummy field due to lack of the corresponding register
-    state.lighting.lut_sp.enable = true;
-    state.lighting.lut_sp.abs_input = regs.lighting.abs_lut_input.disable_sp == 0;
-    state.lighting.lut_sp.type = regs.lighting.lut_input.sp.Value();
-    state.lighting.lut_sp.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.sp);
-
-    state.lighting.lut_fr.enable = regs.lighting.config1.disable_lut_fr == 0;
-    state.lighting.lut_fr.abs_input = regs.lighting.abs_lut_input.disable_fr == 0;
-    state.lighting.lut_fr.type = regs.lighting.lut_input.fr.Value();
-    state.lighting.lut_fr.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.fr);
-
-    state.lighting.lut_rr.enable = regs.lighting.config1.disable_lut_rr == 0;
-    state.lighting.lut_rr.abs_input = regs.lighting.abs_lut_input.disable_rr == 0;
-    state.lighting.lut_rr.type = regs.lighting.lut_input.rr.Value();
-    state.lighting.lut_rr.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.rr);
-
-    state.lighting.lut_rg.enable = regs.lighting.config1.disable_lut_rg == 0;
-    state.lighting.lut_rg.abs_input = regs.lighting.abs_lut_input.disable_rg == 0;
-    state.lighting.lut_rg.type = regs.lighting.lut_input.rg.Value();
-    state.lighting.lut_rg.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.rg);
-
-    state.lighting.lut_rb.enable = regs.lighting.config1.disable_lut_rb == 0;
-    state.lighting.lut_rb.abs_input = regs.lighting.abs_lut_input.disable_rb == 0;
-    state.lighting.lut_rb.type = regs.lighting.lut_input.rb.Value();
-    state.lighting.lut_rb.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.rb);
-
-    state.lighting.config = regs.lighting.config0.config;
-    state.lighting.enable_primary_alpha = regs.lighting.config0.enable_primary_alpha;
-    state.lighting.enable_secondary_alpha = regs.lighting.config0.enable_secondary_alpha;
-    state.lighting.bump_mode = regs.lighting.config0.bump_mode;
-    state.lighting.bump_selector = regs.lighting.config0.bump_selector;
-    state.lighting.bump_renorm = regs.lighting.config0.disable_bump_renorm == 0;
-    state.lighting.clamp_highlights = regs.lighting.config0.clamp_highlights != 0;
-
-    state.lighting.enable_shadow = regs.lighting.config0.enable_shadow != 0;
-    state.lighting.shadow_primary = regs.lighting.config0.shadow_primary != 0;
-    state.lighting.shadow_secondary = regs.lighting.config0.shadow_secondary != 0;
-    state.lighting.shadow_invert = regs.lighting.config0.shadow_invert != 0;
-    state.lighting.shadow_alpha = regs.lighting.config0.shadow_alpha != 0;
-    state.lighting.shadow_selector = regs.lighting.config0.shadow_selector;
+        state.lighting.lut_d0.enable = regs.lighting.config1.disable_lut_d0 == 0;
+        state.lighting.lut_d0.abs_input = regs.lighting.abs_lut_input.disable_d0 == 0;
+        state.lighting.lut_d0.type = regs.lighting.lut_input.d0.Value();
+        state.lighting.lut_d0.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.d0);
+
+        state.lighting.lut_d1.enable = regs.lighting.config1.disable_lut_d1 == 0;
+        state.lighting.lut_d1.abs_input = regs.lighting.abs_lut_input.disable_d1 == 0;
+        state.lighting.lut_d1.type = regs.lighting.lut_input.d1.Value();
+        state.lighting.lut_d1.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.d1);
+
+        // this is a dummy field due to lack of the corresponding register
+        state.lighting.lut_sp.enable = true;
+        state.lighting.lut_sp.abs_input = regs.lighting.abs_lut_input.disable_sp == 0;
+        state.lighting.lut_sp.type = regs.lighting.lut_input.sp.Value();
+        state.lighting.lut_sp.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.sp);
+
+        state.lighting.lut_fr.enable = regs.lighting.config1.disable_lut_fr == 0;
+        state.lighting.lut_fr.abs_input = regs.lighting.abs_lut_input.disable_fr == 0;
+        state.lighting.lut_fr.type = regs.lighting.lut_input.fr.Value();
+        state.lighting.lut_fr.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.fr);
+
+        state.lighting.lut_rr.enable = regs.lighting.config1.disable_lut_rr == 0;
+        state.lighting.lut_rr.abs_input = regs.lighting.abs_lut_input.disable_rr == 0;
+        state.lighting.lut_rr.type = regs.lighting.lut_input.rr.Value();
+        state.lighting.lut_rr.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.rr);
+
+        state.lighting.lut_rg.enable = regs.lighting.config1.disable_lut_rg == 0;
+        state.lighting.lut_rg.abs_input = regs.lighting.abs_lut_input.disable_rg == 0;
+        state.lighting.lut_rg.type = regs.lighting.lut_input.rg.Value();
+        state.lighting.lut_rg.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.rg);
+
+        state.lighting.lut_rb.enable = regs.lighting.config1.disable_lut_rb == 0;
+        state.lighting.lut_rb.abs_input = regs.lighting.abs_lut_input.disable_rb == 0;
+        state.lighting.lut_rb.type = regs.lighting.lut_input.rb.Value();
+        state.lighting.lut_rb.scale = regs.lighting.lut_scale.GetScale(regs.lighting.lut_scale.rb);
+
+        state.lighting.config = regs.lighting.config0.config;
+        state.lighting.enable_primary_alpha = regs.lighting.config0.enable_primary_alpha;
+        state.lighting.enable_secondary_alpha = regs.lighting.config0.enable_secondary_alpha;
+        state.lighting.bump_mode = regs.lighting.config0.bump_mode;
+        state.lighting.bump_selector = regs.lighting.config0.bump_selector;
+        state.lighting.bump_renorm = regs.lighting.config0.disable_bump_renorm == 0;
+        state.lighting.clamp_highlights = regs.lighting.config0.clamp_highlights != 0;
+
+        state.lighting.enable_shadow = regs.lighting.config0.enable_shadow != 0;
+        state.lighting.shadow_primary = regs.lighting.config0.shadow_primary != 0;
+        state.lighting.shadow_secondary = regs.lighting.config0.shadow_secondary != 0;
+        state.lighting.shadow_invert = regs.lighting.config0.shadow_invert != 0;
+        state.lighting.shadow_alpha = regs.lighting.config0.shadow_alpha != 0;
+        state.lighting.shadow_selector = regs.lighting.config0.shadow_selector;
+    }
 
     state.proctex.enable = regs.texturing.main_config.texture3_enable;
     if (state.proctex.enable) {
@@ -972,7 +983,7 @@ using ProcTexCombiner = TexturingRegs::ProcTexCombiner;
 using ProcTexFilter = TexturingRegs::ProcTexFilter;
 
 static void AppendProcTexShiftOffset(std::string& out, const std::string& v, ProcTexShift mode,
-                              ProcTexClamp clamp_mode) {
+                                     ProcTexClamp clamp_mode) {
     std::string offset = (clamp_mode == ProcTexClamp::MirroredRepeat) ? "1.0" : "0.5";
     switch (mode) {
     case ProcTexShift::None:
@@ -1018,7 +1029,7 @@ static void AppendProcTexClamp(std::string& out, const std::string& var, ProcTex
 }
 
 static void AppendProcTexCombineAndMap(std::string& out, ProcTexCombiner combiner,
-                                const std::string& offset) {
+                                       const std::string& offset) {
     std::string combined;
     switch (combiner) {
     case ProcTexCombiner::U:
@@ -1231,32 +1242,82 @@ float ProcTexNoiseCoef(vec2 x) {
     }
 }
 
+static void AppendProcLogicOp(std::string& out, FramebufferRegs::LogicOp logic_op) {
+    constexpr std::array<const char*, 16> logicOps{{
+        "new_color = ivec3(0, 0, 0);\n",           // CLEAR
+        "new_color = new_color & old_color;\n",    // AND
+        "new_color = new_color & (~old_color);\n", // AND_REVERSE
+        "\n",                                      // COPY
+        "new_color = ivec3(255, 255, 255);\n",     // SET
+        "new_color = ~new_color;\n",               // COPY_INVERTED
+        "new_color = old_color;\n",                // NOOP
+        "new_color = ~old_color;\n",               // INVERT
+        "new_color = ~(new_color & old_color);\n", // NAND
+        "new_color = new_color | old_color;\n",    // OR
+        "new_color = ~(new_color | old_color);\n", // NOR
+        "new_color = new_color ^ old_color;\n",    // XOR
+        "new_color = ~(new_color ^ old_color);\n", // EQUIV
+        "new_color = (~new_color) & old_color;\n", // AND_INVERTED
+        "new_color = new_color | (~old_color);\n", // OR_REVERSE
+        "new_color = (~new_color) | old_color;\n", // OR_INVERTED
+    }};
+    out += "ivec3 old_color = ivec3(initial_color.rgb * 255.0);\n";
+    out += "ivec3 new_color = ivec3(last_tex_env_out.rgb * 255.0);\n";
+    out += logicOps[static_cast<u32>(logic_op)];
+    out += "color = vec4(vec3(new_color & 255) * (1.0 / 255.0), byteround(last_tex_env_out.a));\n";
+}
+
 std::string GenerateFragmentShader(const PicaFSConfig& config, bool separable_shader) {
     const auto& state = config.state;
-
-    std::string out = R"(
-#extension GL_ARB_shader_image_load_store : enable
-#extension GL_ARB_shader_image_size : enable
-#define ALLOW_SHADOW (defined(GL_ARB_shader_image_load_store) && defined(GL_ARB_shader_image_size))
-)";
+    std::string out;
+    bool shader_logic_ops = false;
 
     if (separable_shader) {
         out += "#extension GL_ARB_separate_shader_objects : enable\n";
     }
 
     if (GLES) {
+        if (state.logic_op != FramebufferRegs::LogicOp::Copy) {
+            if (GLAD_GL_EXT_shader_framebuffer_fetch) {
+                out += "#extension GL_EXT_shader_framebuffer_fetch : enable\n"
+                       "#define FB_FETCH_VALUE color\n"
+                       "#define FRAGMENT_INOUT inout\n";
+                shader_logic_ops = true;
+            } else if (GLAD_GL_ARM_shader_framebuffer_fetch) {
+                out += "#extension GL_ARM_shader_framebuffer_fetch : enable\n"
+                       "#define FB_FETCH_VALUE gl_LastFragColorARM\n"
+                       "#define FRAGMENT_INOUT out\n";
+                shader_logic_ops = true;
+            }
+        }
+        if (AllowShadow && state.shadow_rendering) {
+            out += "#define ALLOW_SHADOW 1\n";
+        } else {
+            out += "#define ALLOW_SHADOW 0\n";
+        }
         out += fragment_shader_precision_OES;
+    } else {
+        out += R"(
+#extension GL_ARB_shader_image_load_store : enable
+#extension GL_ARB_shader_image_size : enable
+#define ALLOW_SHADOW (defined(GL_ARB_shader_image_load_store) && defined(GL_ARB_shader_image_size))
+)";
     }
 
     out += GetVertexInterfaceDeclaration(false, separable_shader);
-
     out += R"(
 #ifndef CITRA_GLES
 in vec4 gl_FragCoord;
 #endif // CITRA_GLES
+)";
 
-out vec4 color;
+    if (shader_logic_ops) {
+        out += "FRAGMENT_INOUT vec4 color;\n";
+    } else {
+        out += "out vec4 color;\n";
+    }
 
+    out += R"(
 uniform sampler2D tex0;
 uniform sampler2D tex1;
 uniform sampler2D tex2;
@@ -1479,6 +1540,10 @@ vec4 primary_fragment_color = vec4(0.0);
 vec4 secondary_fragment_color = vec4(0.0);
 )";
 
+    if (shader_logic_ops) {
+        out += "vec4 initial_color = FB_FETCH_VALUE;\n";
+    }
+
     // Do not do any sort of processing if it's obvious we're not going to pass the alpha test
     if (state.alpha_test_func == FramebufferRegs::CompareFunc::Never) {
         out += "discard; }";
@@ -1578,8 +1643,13 @@ do {
 )";
     } else {
         out += "gl_FragDepth = depth;\n";
-        // Round the final fragment color to maintain the PICA's 8 bits of precision
-        out += "color = byteround(last_tex_env_out);\n";
+
+        if (shader_logic_ops) {
+            AppendProcLogicOp(out, state.logic_op);
+        } else {
+            // Round the final fragment color to maintain the PICA's 8 bits of precision
+            out += "color = byteround(last_tex_env_out);\n";
+        }
     }
 
     out += "}";
@@ -1633,9 +1703,9 @@ void main() {
     return out;
 }
 
-std::optional<std::string> GenerateVertexShader(const Pica::Shader::ShaderSetup& setup,
-                                                const PicaVSConfig& config, bool separable_shader) {
-    std::string out = "";
+std::string GenerateVertexShader(const Pica::Shader::ShaderSetup& setup, const PicaVSConfig& config,
+                                 bool separable_shader) {
+    std::string out;
     if (separable_shader) {
         out += "#extension GL_ARB_separate_shader_objects : enable\n";
     }
@@ -1816,4 +1886,5 @@ void main() {
 
     return out;
 }
+
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.h b/src/video_core/renderer_opengl/gl_shader_gen.h
index 8875c62b4cb..25ca12195af 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.h
+++ b/src/video_core/renderer_opengl/gl_shader_gen.h
@@ -49,6 +49,7 @@ struct TevStageConfigRaw {
 };
 
 struct PicaFSConfigState {
+    Pica::FramebufferRegs::LogicOp logic_op;
     Pica::FramebufferRegs::CompareFunc alpha_test_func;
     Pica::RasterizerRegs::ScissorMode scissor_test_mode;
     Pica::TexturingRegs::TextureConfig::TextureType texture0_type;
@@ -128,8 +129,7 @@ struct PicaFSConfigState {
  * Pica state is not being captured in the shader cache key, thereby resulting in (what should be)
  * two separate shaders sharing the same key.
  */
-struct PicaFSConfig : Common::HashableStruct<PicaFSConfigState> {
-
+struct PicaFSConfig {
     /// Construct a PicaFSConfig with the given Pica register configuration.
     static PicaFSConfig BuildFromRegs(const Pica::Regs& regs);
 
@@ -140,6 +140,8 @@ struct PicaFSConfig : Common::HashableStruct<PicaFSConfigState> {
     bool TevStageUpdatesCombinerBufferAlpha(unsigned stage_index) const {
         return (stage_index < 4) && ((state.combiner_buffer_input >> 4) & (1 << stage_index));
     }
+
+    PicaFSConfigState state;
 };
 
 /**
@@ -164,10 +166,11 @@ struct PicaShaderConfigCommon {
  * This struct contains information to identify a GL vertex shader generated from PICA vertex
  * shader.
  */
-struct PicaVSConfig : Common::HashableStruct<PicaShaderConfigCommon> {
-    explicit PicaVSConfig(const Pica::Regs& regs, Pica::Shader::ShaderSetup& setup) {
+struct PicaVSConfig {
+    PicaVSConfig(const Pica::Regs& regs, Pica::Shader::ShaderSetup& setup) {
         state.Init(regs.vs, setup);
     }
+    PicaShaderConfigCommon state;
 };
 
 struct PicaGSConfigCommonRaw {
@@ -189,10 +192,11 @@ struct PicaGSConfigCommonRaw {
  * This struct contains information to identify a GL geometry shader generated from PICA no-geometry
  * shader pipeline
  */
-struct PicaFixedGSConfig : Common::HashableStruct<PicaGSConfigCommonRaw> {
-    explicit PicaFixedGSConfig(const Pica::Regs& regs) {
+struct PicaFixedGSConfig {
+    PicaFixedGSConfig(const Pica::Regs& regs) {
         state.Init(regs);
     }
+    PicaGSConfigCommonRaw state;
 };
 
 /**
@@ -207,8 +211,8 @@ std::string GenerateTrivialVertexShader(bool separable_shader);
  * Generates the GLSL vertex shader program source code for the given VS program
  * @returns String of the shader source code; boost::none on failure
  */
-std::optional<std::string> GenerateVertexShader(const Pica::Shader::ShaderSetup& setup,
-                                                const PicaVSConfig& config, bool separable_shader);
+std::string GenerateVertexShader(const Pica::Shader::ShaderSetup& setup, const PicaVSConfig& config,
+                                 bool separable_shader);
 
 /*
  * Generates the GLSL fixed geometry shader program source code for non-GS PICA pipeline
@@ -226,26 +230,3 @@ std::string GenerateFixedGeometryShader(const PicaFixedGSConfig& config, bool se
 std::string GenerateFragmentShader(const PicaFSConfig& config, bool separable_shader);
 
 } // namespace OpenGL
-
-namespace std {
-template <>
-struct hash<OpenGL::PicaFSConfig> {
-    std::size_t operator()(const OpenGL::PicaFSConfig& k) const {
-        return k.Hash();
-    }
-};
-
-template <>
-struct hash<OpenGL::PicaVSConfig> {
-    std::size_t operator()(const OpenGL::PicaVSConfig& k) const {
-        return k.Hash();
-    }
-};
-
-template <>
-struct hash<OpenGL::PicaFixedGSConfig> {
-    std::size_t operator()(const OpenGL::PicaFixedGSConfig& k) const {
-        return k.Hash();
-    }
-};
-} // namespace std
diff --git a/src/video_core/renderer_opengl/gl_shader_manager.cpp b/src/video_core/renderer_opengl/gl_shader_manager.cpp
index c0172c9008d..afb96dc600c 100644
--- a/src/video_core/renderer_opengl/gl_shader_manager.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_manager.cpp
@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <unordered_map>
-#include <boost/functional/hash.hpp>
 #include <boost/variant.hpp>
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 
@@ -45,9 +44,7 @@ static void SetShaderImageBinding(GLuint shader, const char* name, GLuint bindin
 }
 
 static void SetShaderSamplerBindings(GLuint shader) {
-    OpenGLState cur_state = OpenGLState::GetCurState();
-    GLuint old_program = std::exchange(cur_state.draw.shader_program, shader);
-    cur_state.Apply();
+    GLuint old_program = OpenGLState::BindShaderProgram(shader);
 
     // Set the texture samplers to correspond to different texture units
     SetShaderSamplerBinding(shader, "tex0", TextureUnits::PicaTexture(0));
@@ -67,8 +64,7 @@ static void SetShaderSamplerBindings(GLuint shader) {
     SetShaderImageBinding(shader, "shadow_texture_pz", ImageUnits::ShadowTexturePZ);
     SetShaderImageBinding(shader, "shadow_texture_nz", ImageUnits::ShadowTextureNZ);
 
-    cur_state.draw.shader_program = old_program;
-    cur_state.Apply();
+    OpenGLState::BindShaderProgram(old_program);
 }
 
 void PicaUniformsData::SetFromRegs(const Pica::ShaderRegs& regs,
@@ -138,125 +134,128 @@ class TrivialVertexShader {
     OGLShaderStage program;
 };
 
-template <typename KeyConfigType, std::string (*CodeGenerator)(const KeyConfigType&, bool),
-          GLenum ShaderType>
-class ShaderCache {
+class ShaderProgramManager::Impl {
 public:
-    explicit ShaderCache(bool separable) : separable(separable) {}
-    GLuint Get(const KeyConfigType& config) {
-        auto [iter, new_shader] = shaders.emplace(config, OGLShaderStage{separable});
-        OGLShaderStage& cached_shader = iter->second;
-        if (new_shader) {
-            cached_shader.Create(CodeGenerator(config, separable).c_str(), ShaderType);
+    Impl(bool separable, bool is_amd)
+        : separable(separable), is_amd(is_amd), trivial_vertex_shader(separable) {
+        if (separable) {
+            pipeline.Create();
         }
-        return cached_shader.GetHandle();
     }
 
-private:
-    bool separable;
-    std::unordered_map<KeyConfigType, OGLShaderStage> shaders;
-};
-
-// This is a cache designed for shaders translated from PICA shaders. The first cache matches the
-// config structure like a normal cache does. On cache miss, the second cache matches the generated
-// GLSL code. The configuration is like this because there might be leftover code in the PICA shader
-// program buffer from the previous shader, which is hashed into the config, resulting several
-// different config values from the same shader program.
-template <typename KeyConfigType,
-          std::optional<std::string> (*CodeGenerator)(const Pica::Shader::ShaderSetup&,
-                                                      const KeyConfigType&, bool),
-          GLenum ShaderType>
-class ShaderDoubleCache {
-public:
-    explicit ShaderDoubleCache(bool separable) : separable(separable) {}
-    GLuint Get(const KeyConfigType& key, const Pica::Shader::ShaderSetup& setup) {
-        auto map_it = shader_map.find(key);
-        if (map_it == shader_map.end()) {
-            auto program_opt = CodeGenerator(setup, key, separable);
-            if (!program_opt) {
-                shader_map[key] = nullptr;
-                return 0;
+    bool UseProgrammableVertexShader(const Pica::Regs& regs, Pica::Shader::ShaderSetup& setup) {
+        PicaVSConfig key(regs, setup);
+        u64 key_hash = Common::ComputeHash64(&key, sizeof(key));
+        auto iter_ref = shaders_ref.find(key_hash);
+        if (iter_ref == shaders_ref.end()) {
+            std::string vs_code = GenerateVertexShader(setup, key, separable);
+            if (vs_code.empty()) {
+                shaders_ref[key_hash] = nullptr;
+                current_shader.vs = 0;
+            } else {
+                u64 code_hash = Common::ComputeHash64(vs_code.data(), vs_code.size());
+                auto [iter, new_shader] = shaders.emplace(code_hash, OGLShaderStage{separable});
+                OGLShaderStage& cached_shader = iter->second;
+                if (new_shader) {
+                    cached_shader.Create(vs_code.c_str(), GL_VERTEX_SHADER);
+                }
+                shaders_ref[key_hash] = &cached_shader;
+                current_shader.vs = cached_shader.GetHandle();
             }
+        } else if (iter_ref->second == nullptr) {
+            current_shader.vs = 0;
+        } else {
+            current_shader.vs = iter_ref->second->GetHandle();
+        }
+        return (current_shader.vs != 0);
+    }
+
+    void UseFixedGeometryShader(const Pica::Regs& regs) {
+        PicaFixedGSConfig key(regs);
+        u64 key_hash = Common::ComputeHash64(&key, sizeof(key));
+        auto [iter, new_shader] = shaders.emplace(key_hash, separable);
+        OGLShaderStage& cached_shader = iter->second;
+        if (new_shader) {
+            std::string gs_code = GenerateFixedGeometryShader(key, separable);
+            cached_shader.Create(gs_code.c_str(), GL_GEOMETRY_SHADER);
+        }
+        current_shader.gs = cached_shader.GetHandle();
+    }
 
-            std::string& program = *program_opt;
-            auto [iter, new_shader] = shader_cache.emplace(program, OGLShaderStage{separable});
+    void UseFragmentShader(const Pica::Regs& regs) {
+        auto key = PicaFSConfig::BuildFromRegs(regs);
+        u64 key_hash = Common::ComputeHash64(&key, sizeof(key));
+        auto iter_ref = shaders_ref.find(key_hash);
+        if (iter_ref == shaders_ref.end()) {
+            std::string fs_code = GenerateFragmentShader(key, separable);
+            u64 code_hash = Common::ComputeHash64(fs_code.data(), fs_code.size());
+            auto [iter, new_shader] = shaders.emplace(code_hash, OGLShaderStage{separable});
             OGLShaderStage& cached_shader = iter->second;
             if (new_shader) {
-                cached_shader.Create(program.c_str(), ShaderType);
+                cached_shader.Create(fs_code.c_str(), GL_FRAGMENT_SHADER);
             }
-            shader_map[key] = &cached_shader;
-            return cached_shader.GetHandle();
-        }
-
-        if (map_it->second == nullptr) {
-            return 0;
+            shaders_ref[key_hash] = &cached_shader;
+            current_shader.fs = cached_shader.GetHandle();
+        } else {
+            current_shader.fs = iter_ref->second->GetHandle();
         }
-
-        return map_it->second->GetHandle();
     }
 
-private:
-    bool separable;
-    std::unordered_map<KeyConfigType, OGLShaderStage*> shader_map;
-    std::unordered_map<std::string, OGLShaderStage> shader_cache;
-};
-
-using ProgrammableVertexShaders =
-    ShaderDoubleCache<PicaVSConfig, &GenerateVertexShader, GL_VERTEX_SHADER>;
+    void UseTrivialVertexShader() {
+        current_shader.vs = trivial_vertex_shader.Get();
+    }
 
-using FixedGeometryShaders =
-    ShaderCache<PicaFixedGSConfig, &GenerateFixedGeometryShader, GL_GEOMETRY_SHADER>;
+    void UseTrivialGeometryShader() {
+        current_shader.gs = 0;
+    }
 
-using FragmentShaders = ShaderCache<PicaFSConfig, &GenerateFragmentShader, GL_FRAGMENT_SHADER>;
+    void ApplyTo(OpenGLState& state) {
+        if (separable) {
+            if (is_amd) {
+                // Without this reseting, AMD sometimes freezes when one stage is changed but not
+                // for the others. On the other hand, including this reset seems to introduce memory
+                // leak in Intel Graphics.
+                glUseProgramStages(
+                    pipeline.handle,
+                    GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, 0);
+            }
 
-class ShaderProgramManager::Impl {
-public:
-    explicit Impl(bool separable, bool is_amd)
-        : is_amd(is_amd), separable(separable), programmable_vertex_shaders(separable),
-          trivial_vertex_shader(separable), fixed_geometry_shaders(separable),
-          fragment_shaders(separable) {
-        if (separable)
-            pipeline.Create();
+            glUseProgramStages(pipeline.handle, GL_VERTEX_SHADER_BIT, current_shader.vs);
+            glUseProgramStages(pipeline.handle, GL_GEOMETRY_SHADER_BIT, current_shader.gs);
+            glUseProgramStages(pipeline.handle, GL_FRAGMENT_SHADER_BIT, current_shader.fs);
+            state.draw.shader_program = 0;
+            state.draw.program_pipeline = pipeline.handle;
+        } else {
+            u64 hash = Common::ComputeHash64(&current_shader, sizeof(current_shader));
+            OGLProgram& cached_program = program_cache[hash];
+            if (cached_program.handle == 0) {
+                cached_program.Create(false,
+                                      {current_shader.vs, current_shader.gs, current_shader.fs});
+                SetShaderUniformBlockBindings(cached_program.handle);
+                SetShaderSamplerBindings(cached_program.handle);
+            }
+            state.draw.shader_program = cached_program.handle;
+            state.draw.program_pipeline = 0;
+        }
     }
 
+private:
+    bool separable;
+    bool is_amd;
+
     struct ShaderTuple {
         GLuint vs = 0;
         GLuint gs = 0;
         GLuint fs = 0;
-
-        bool operator==(const ShaderTuple& rhs) const {
-            return std::tie(vs, gs, fs) == std::tie(rhs.vs, rhs.gs, rhs.fs);
-        }
-
-        bool operator!=(const ShaderTuple& rhs) const {
-            return std::tie(vs, gs, fs) != std::tie(rhs.vs, rhs.gs, rhs.fs);
-        }
-
-        struct Hash {
-            std::size_t operator()(const ShaderTuple& tuple) const {
-                std::size_t hash = 0;
-                boost::hash_combine(hash, tuple.vs);
-                boost::hash_combine(hash, tuple.gs);
-                boost::hash_combine(hash, tuple.fs);
-                return hash;
-            }
-        };
     };
+    ShaderTuple current_shader;
 
-    bool is_amd;
-
-    ShaderTuple current;
-
-    ProgrammableVertexShaders programmable_vertex_shaders;
     TrivialVertexShader trivial_vertex_shader;
+    std::unordered_map<u64, OGLShaderStage*> shaders_ref;
+    std::unordered_map<u64, OGLShaderStage> shaders;
 
-    FixedGeometryShaders fixed_geometry_shaders;
-
-    FragmentShaders fragment_shaders;
-
-    bool separable;
-    std::unordered_map<ShaderTuple, OGLProgram, ShaderTuple::Hash> program_cache;
     OGLPipeline pipeline;
+    std::unordered_map<u64, OGLProgram> program_cache;
 };
 
 ShaderProgramManager::ShaderProgramManager(bool separable, bool is_amd)
@@ -264,56 +263,28 @@ ShaderProgramManager::ShaderProgramManager(bool separable, bool is_amd)
 
 ShaderProgramManager::~ShaderProgramManager() = default;
 
-bool ShaderProgramManager::UseProgrammableVertexShader(const PicaVSConfig& config,
-                                                       const Pica::Shader::ShaderSetup setup) {
-    GLuint handle = impl->programmable_vertex_shaders.Get(config, setup);
-    if (handle == 0)
-        return false;
-    impl->current.vs = handle;
-    return true;
+bool ShaderProgramManager::UseProgrammableVertexShader(const Pica::Regs& regs,
+                                                       Pica::Shader::ShaderSetup& setup) {
+    return impl->UseProgrammableVertexShader(regs, setup);
 }
 
 void ShaderProgramManager::UseTrivialVertexShader() {
-    impl->current.vs = impl->trivial_vertex_shader.Get();
+    impl->UseTrivialVertexShader();
 }
 
-void ShaderProgramManager::UseFixedGeometryShader(const PicaFixedGSConfig& config) {
-    impl->current.gs = impl->fixed_geometry_shaders.Get(config);
+void ShaderProgramManager::UseFixedGeometryShader(const Pica::Regs& regs) {
+    impl->UseFixedGeometryShader(regs);
 }
 
 void ShaderProgramManager::UseTrivialGeometryShader() {
-    impl->current.gs = 0;
+    impl->UseTrivialGeometryShader();
 }
 
-void ShaderProgramManager::UseFragmentShader(const PicaFSConfig& config) {
-    impl->current.fs = impl->fragment_shaders.Get(config);
+void ShaderProgramManager::UseFragmentShader(const Pica::Regs& regs) {
+    impl->UseFragmentShader(regs);
 }
 
 void ShaderProgramManager::ApplyTo(OpenGLState& state) {
-    if (impl->separable) {
-        if (impl->is_amd) {
-            // Without this reseting, AMD sometimes freezes when one stage is changed but not for
-            // the others.
-            // On the other hand, including this reset seems to introduce memory leak in Intel
-            // Graphics.
-            glUseProgramStages(
-                impl->pipeline.handle,
-                GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, 0);
-        }
-
-        glUseProgramStages(impl->pipeline.handle, GL_VERTEX_SHADER_BIT, impl->current.vs);
-        glUseProgramStages(impl->pipeline.handle, GL_GEOMETRY_SHADER_BIT, impl->current.gs);
-        glUseProgramStages(impl->pipeline.handle, GL_FRAGMENT_SHADER_BIT, impl->current.fs);
-        state.draw.shader_program = 0;
-        state.draw.program_pipeline = impl->pipeline.handle;
-    } else {
-        OGLProgram& cached_program = impl->program_cache[impl->current];
-        if (cached_program.handle == 0) {
-            cached_program.Create(false, {impl->current.vs, impl->current.gs, impl->current.fs});
-            SetShaderUniformBlockBindings(cached_program.handle);
-            SetShaderSamplerBindings(cached_program.handle);
-        }
-        state.draw.shader_program = cached_program.handle;
-    }
+    impl->ApplyTo(state);
 }
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/gl_shader_manager.h b/src/video_core/renderer_opengl/gl_shader_manager.h
index a31fbc4e655..1bdb1150f0e 100644
--- a/src/video_core/renderer_opengl/gl_shader_manager.h
+++ b/src/video_core/renderer_opengl/gl_shader_manager.h
@@ -97,16 +97,15 @@ class ShaderProgramManager {
     ShaderProgramManager(bool separable, bool is_amd);
     ~ShaderProgramManager();
 
-    bool UseProgrammableVertexShader(const PicaVSConfig& config,
-                                     const Pica::Shader::ShaderSetup setup);
+    bool UseProgrammableVertexShader(const Pica::Regs& regs, Pica::Shader::ShaderSetup& setup);
 
     void UseTrivialVertexShader();
 
-    void UseFixedGeometryShader(const PicaFixedGSConfig& config);
+    void UseFixedGeometryShader(const Pica::Regs& regs);
 
     void UseTrivialGeometryShader();
 
-    void UseFragmentShader(const PicaFSConfig& config);
+    void UseFragmentShader(const Pica::Regs& regs);
 
     void ApplyTo(OpenGLState& state);
 
diff --git a/src/video_core/renderer_opengl/gl_shader_util.cpp b/src/video_core/renderer_opengl/gl_shader_util.cpp
index a51ad443b09..8a9efcb0fe8 100644
--- a/src/video_core/renderer_opengl/gl_shader_util.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_util.cpp
@@ -6,7 +6,9 @@
 #include <string>
 #include <vector>
 #include <glad/glad.h>
+
 #include "common/assert.h"
+#include "common/file_util.h"
 #include "common/logging/log.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
 #include "video_core/renderer_opengl/gl_vars.h"
@@ -63,8 +65,18 @@ GLuint LoadShader(const char* source, GLenum type) {
             LOG_ERROR(Render_OpenGL, "Error compiling {} shader:\n{}", debug_type,
                       &shader_error[0]);
             LOG_ERROR(Render_OpenGL, "Shader source code:\n{}{}", src_arr[0], src_arr[1]);
+            // dump shader source code to file
+            static u32 file_id = 0;
+            const std::string& log_dir = FileUtil::GetUserPath(FileUtil::UserPath::LogDir);
+            const std::string filepath = fmt::format("{}{}_{}.txt", log_dir, debug_type, file_id++);
+            std::string shader(src_arr[0]);
+            shader.append(src_arr[1]);
+            shader.append("\n\n");
+            shader.append(shader_error.data(), shader_error.size());
+            FileUtil::WriteStringToFile(true, filepath, shader);
         }
     }
+
     return shader_id;
 }
 
diff --git a/src/video_core/renderer_opengl/gl_state.cpp b/src/video_core/renderer_opengl/gl_state.cpp
index 17bf2b2f755..5ab90d3c9e4 100644
--- a/src/video_core/renderer_opengl/gl_state.cpp
+++ b/src/video_core/renderer_opengl/gl_state.cpp
@@ -14,7 +14,7 @@ OpenGLState OpenGLState::cur_state;
 
 OpenGLState::OpenGLState() {
     // These all match default OpenGL values
-    cull.enabled = false;
+    cull.enabled = true;
     cull.mode = GL_BACK;
     cull.front_face = GL_CCW;
 
@@ -36,7 +36,7 @@ OpenGLState::OpenGLState() {
     stencil.action_depth_pass = GL_KEEP;
     stencil.action_stencil_fail = GL_KEEP;
 
-    blend.enabled = true;
+    blend.enabled = false;
     blend.rgb_equation = GL_FUNC_ADD;
     blend.a_equation = GL_FUNC_ADD;
     blend.src_rgb_func = GL_ONE;
@@ -236,39 +236,41 @@ void OpenGLState::Apply() const {
     }
 
     // Shadow Images
-    if (image_shadow_buffer != cur_state.image_shadow_buffer) {
-        glBindImageTexture(ImageUnits::ShadowBuffer, image_shadow_buffer, 0, GL_FALSE, 0,
-                           GL_READ_WRITE, GL_R32UI);
-    }
+    if (AllowShadow) {
+        if (image_shadow_buffer != cur_state.image_shadow_buffer) {
+            glBindImageTexture(ImageUnits::ShadowBuffer, image_shadow_buffer, 0, GL_FALSE, 0,
+                               GL_READ_WRITE, GL_R32UI);
+        }
 
-    if (image_shadow_texture_px != cur_state.image_shadow_texture_px) {
-        glBindImageTexture(ImageUnits::ShadowTexturePX, image_shadow_texture_px, 0, GL_FALSE, 0,
-                           GL_READ_ONLY, GL_R32UI);
-    }
+        if (image_shadow_texture_px != cur_state.image_shadow_texture_px) {
+            glBindImageTexture(ImageUnits::ShadowTexturePX, image_shadow_texture_px, 0, GL_FALSE, 0,
+                               GL_READ_ONLY, GL_R32UI);
+        }
 
-    if (image_shadow_texture_nx != cur_state.image_shadow_texture_nx) {
-        glBindImageTexture(ImageUnits::ShadowTextureNX, image_shadow_texture_nx, 0, GL_FALSE, 0,
-                           GL_READ_ONLY, GL_R32UI);
-    }
+        if (image_shadow_texture_nx != cur_state.image_shadow_texture_nx) {
+            glBindImageTexture(ImageUnits::ShadowTextureNX, image_shadow_texture_nx, 0, GL_FALSE, 0,
+                               GL_READ_ONLY, GL_R32UI);
+        }
 
-    if (image_shadow_texture_py != cur_state.image_shadow_texture_py) {
-        glBindImageTexture(ImageUnits::ShadowTexturePY, image_shadow_texture_py, 0, GL_FALSE, 0,
-                           GL_READ_ONLY, GL_R32UI);
-    }
+        if (image_shadow_texture_py != cur_state.image_shadow_texture_py) {
+            glBindImageTexture(ImageUnits::ShadowTexturePY, image_shadow_texture_py, 0, GL_FALSE, 0,
+                               GL_READ_ONLY, GL_R32UI);
+        }
 
-    if (image_shadow_texture_ny != cur_state.image_shadow_texture_ny) {
-        glBindImageTexture(ImageUnits::ShadowTextureNY, image_shadow_texture_ny, 0, GL_FALSE, 0,
-                           GL_READ_ONLY, GL_R32UI);
-    }
+        if (image_shadow_texture_ny != cur_state.image_shadow_texture_ny) {
+            glBindImageTexture(ImageUnits::ShadowTextureNY, image_shadow_texture_ny, 0, GL_FALSE, 0,
+                               GL_READ_ONLY, GL_R32UI);
+        }
 
-    if (image_shadow_texture_pz != cur_state.image_shadow_texture_pz) {
-        glBindImageTexture(ImageUnits::ShadowTexturePZ, image_shadow_texture_pz, 0, GL_FALSE, 0,
-                           GL_READ_ONLY, GL_R32UI);
-    }
+        if (image_shadow_texture_pz != cur_state.image_shadow_texture_pz) {
+            glBindImageTexture(ImageUnits::ShadowTexturePZ, image_shadow_texture_pz, 0, GL_FALSE, 0,
+                               GL_READ_ONLY, GL_R32UI);
+        }
 
-    if (image_shadow_texture_nz != cur_state.image_shadow_texture_nz) {
-        glBindImageTexture(ImageUnits::ShadowTextureNZ, image_shadow_texture_nz, 0, GL_FALSE, 0,
-                           GL_READ_ONLY, GL_R32UI);
+        if (image_shadow_texture_nz != cur_state.image_shadow_texture_nz) {
+            glBindImageTexture(ImageUnits::ShadowTextureNZ, image_shadow_texture_nz, 0, GL_FALSE, 0,
+                               GL_READ_ONLY, GL_R32UI);
+        }
     }
 
     // Framebuffer
@@ -340,86 +342,182 @@ void OpenGLState::Apply() const {
     cur_state = *this;
 }
 
-OpenGLState& OpenGLState::ResetTexture(GLuint handle) {
-    for (auto& unit : texture_units) {
-        if (unit.texture_2d == handle) {
-            unit.texture_2d = 0;
+GLuint OpenGLState::BindVertexArray(GLuint array) {
+    GLuint previous_array = cur_state.draw.vertex_array;
+    glBindVertexArray(array);
+    cur_state.draw.vertex_array = array;
+    return previous_array;
+}
+
+GLuint OpenGLState::BindVertexBuffer(GLuint buffer) {
+    GLuint previous_buffer = cur_state.draw.vertex_buffer;
+    glBindBuffer(GL_ARRAY_BUFFER, buffer);
+    cur_state.draw.vertex_buffer = buffer;
+    return previous_buffer;
+}
+
+GLuint OpenGLState::BindUniformBuffer(GLuint buffer) {
+    GLuint previous_buffer = cur_state.draw.uniform_buffer;
+    glBindBuffer(GL_UNIFORM_BUFFER, buffer);
+    cur_state.draw.uniform_buffer = buffer;
+    return previous_buffer;
+}
+
+GLuint OpenGLState::BindTexture2D(int index, GLuint texture) {
+    GLuint previous_texture = cur_state.texture_units[index].texture_2d;
+    glActiveTexture(TextureUnits::PicaTexture(index).Enum());
+    glBindTexture(GL_TEXTURE_2D, texture);
+    cur_state.texture_units[index].texture_2d = texture;
+    return previous_texture;
+}
+
+GLuint OpenGLState::BindTextureCube(GLuint texture_cube) {
+    GLuint previous_texture = cur_state.texture_cube_unit.texture_cube;
+    glActiveTexture(TextureUnits::TextureCube.Enum());
+    glBindTexture(GL_TEXTURE_CUBE_MAP, texture_cube);
+    cur_state.texture_cube_unit.texture_cube = texture_cube;
+    return previous_texture;
+}
+
+GLuint OpenGLState::BindReadFramebuffer(GLuint framebuffer) {
+    GLuint previous_framebuffer = cur_state.draw.read_framebuffer;
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
+    cur_state.draw.read_framebuffer = framebuffer;
+    return previous_framebuffer;
+}
+
+GLuint OpenGLState::BindDrawFramebuffer(GLuint framebuffer) {
+    GLuint previous_framebuffer = cur_state.draw.draw_framebuffer;
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer);
+    cur_state.draw.draw_framebuffer = framebuffer;
+    return previous_framebuffer;
+}
+
+GLuint OpenGLState::BindShaderProgram(GLuint shader) {
+    GLuint previous_shader = cur_state.draw.shader_program;
+    glUseProgram(shader);
+    cur_state.draw.shader_program = shader;
+    return previous_shader;
+}
+
+void OpenGLState::ResetTexture(GLuint handle) {
+    for (unsigned i = 0; i < ARRAY_SIZE(cur_state.texture_units); ++i) {
+        if (cur_state.texture_units[i].texture_2d == handle) {
+            cur_state.texture_units[i].texture_2d = 0;
+            glActiveTexture(TextureUnits::PicaTexture(i).Enum());
+            glBindTexture(GL_TEXTURE_2D, 0);
+        }
+    }
+
+    if (cur_state.texture_cube_unit.texture_cube == handle) {
+        cur_state.texture_cube_unit.texture_cube = 0;
+        glActiveTexture(TextureUnits::TextureCube.Enum());
+        glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
+    }
+    if (cur_state.texture_buffer_lut_rg.texture_buffer == handle) {
+        cur_state.texture_buffer_lut_rg.texture_buffer = 0;
+        glActiveTexture(TextureUnits::TextureBufferLUT_RG.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, 0);
+    }
+    if (cur_state.texture_buffer_lut_rgba.texture_buffer == handle) {
+        cur_state.texture_buffer_lut_rgba.texture_buffer = 0;
+        glActiveTexture(TextureUnits::TextureBufferLUT_RGBA.Enum());
+        glBindTexture(GL_TEXTURE_BUFFER, 0);
+    }
+
+    if (AllowShadow) {
+        if (cur_state.image_shadow_buffer == handle) {
+            cur_state.image_shadow_buffer = 0;
+            glBindImageTexture(ImageUnits::ShadowBuffer, 0, 0, GL_FALSE, 0, GL_READ_WRITE,
+                               GL_R32UI);
+        }
+        if (cur_state.image_shadow_texture_px == handle) {
+            cur_state.image_shadow_texture_px = 0;
+            glBindImageTexture(ImageUnits::ShadowTexturePX, 0, 0, GL_FALSE, 0, GL_READ_ONLY,
+                               GL_R32UI);
+        }
+        if (cur_state.image_shadow_texture_nx == handle) {
+            cur_state.image_shadow_texture_nx = 0;
+            glBindImageTexture(ImageUnits::ShadowTextureNX, 0, 0, GL_FALSE, 0, GL_READ_ONLY,
+                               GL_R32UI);
+        }
+        if (cur_state.image_shadow_texture_py == handle) {
+            cur_state.image_shadow_texture_py = 0;
+            glBindImageTexture(ImageUnits::ShadowTexturePY, 0, 0, GL_FALSE, 0, GL_READ_ONLY,
+                               GL_R32UI);
+        }
+        if (cur_state.image_shadow_texture_ny == handle) {
+            cur_state.image_shadow_texture_ny = 0;
+            glBindImageTexture(ImageUnits::ShadowTextureNY, 0, 0, GL_FALSE, 0, GL_READ_ONLY,
+                               GL_R32UI);
+        }
+        if (cur_state.image_shadow_texture_pz == handle) {
+            cur_state.image_shadow_texture_pz = 0;
+            glBindImageTexture(ImageUnits::ShadowTexturePZ, 0, 0, GL_FALSE, 0, GL_READ_ONLY,
+                               GL_R32UI);
+        }
+        if (cur_state.image_shadow_texture_nz == handle) {
+            cur_state.image_shadow_texture_nz = 0;
+            glBindImageTexture(ImageUnits::ShadowTextureNZ, 0, 0, GL_FALSE, 0, GL_READ_ONLY,
+                               GL_R32UI);
         }
     }
-    if (texture_cube_unit.texture_cube == handle)
-        texture_cube_unit.texture_cube = 0;
-    if (texture_buffer_lut_rg.texture_buffer == handle)
-        texture_buffer_lut_rg.texture_buffer = 0;
-    if (texture_buffer_lut_rgba.texture_buffer == handle)
-        texture_buffer_lut_rgba.texture_buffer = 0;
-    if (image_shadow_buffer == handle)
-        image_shadow_buffer = 0;
-    if (image_shadow_texture_px == handle)
-        image_shadow_texture_px = 0;
-    if (image_shadow_texture_nx == handle)
-        image_shadow_texture_nx = 0;
-    if (image_shadow_texture_py == handle)
-        image_shadow_texture_py = 0;
-    if (image_shadow_texture_ny == handle)
-        image_shadow_texture_ny = 0;
-    if (image_shadow_texture_pz == handle)
-        image_shadow_texture_pz = 0;
-    if (image_shadow_texture_nz == handle)
-        image_shadow_texture_nz = 0;
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetSampler(GLuint handle) {
-    for (auto& unit : texture_units) {
-        if (unit.sampler == handle) {
-            unit.sampler = 0;
+void OpenGLState::ResetSampler(GLuint handle) {
+    for (unsigned i = 0; i < ARRAY_SIZE(cur_state.texture_units); ++i) {
+        if (cur_state.texture_units[i].sampler == handle) {
+            cur_state.texture_units[i].sampler = 0;
+            glBindSampler(i, 0);
         }
     }
-    if (texture_cube_unit.sampler == handle) {
-        texture_cube_unit.sampler = 0;
+    if (cur_state.texture_cube_unit.sampler == handle) {
+        cur_state.texture_cube_unit.sampler = 0;
+        glBindSampler(TextureUnits::TextureCube.id, 0);
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetProgram(GLuint handle) {
-    if (draw.shader_program == handle) {
-        draw.shader_program = 0;
+void OpenGLState::ResetProgram(GLuint handle) {
+    if (cur_state.draw.shader_program == handle) {
+        cur_state.draw.shader_program = 0;
+        glUseProgram(0);
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetPipeline(GLuint handle) {
-    if (draw.program_pipeline == handle) {
-        draw.program_pipeline = 0;
+void OpenGLState::ResetPipeline(GLuint handle) {
+    if (cur_state.draw.program_pipeline == handle) {
+        cur_state.draw.program_pipeline = 0;
+        glBindProgramPipeline(0);
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetBuffer(GLuint handle) {
-    if (draw.vertex_buffer == handle) {
-        draw.vertex_buffer = 0;
+void OpenGLState::ResetBuffer(GLuint handle) {
+    if (cur_state.draw.vertex_buffer == handle) {
+        cur_state.draw.vertex_buffer = 0;
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
     }
-    if (draw.uniform_buffer == handle) {
-        draw.uniform_buffer = 0;
+    if (cur_state.draw.uniform_buffer == handle) {
+        cur_state.draw.uniform_buffer = 0;
+        glBindBuffer(GL_UNIFORM_BUFFER, 0);
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetVertexArray(GLuint handle) {
-    if (draw.vertex_array == handle) {
-        draw.vertex_array = 0;
+void OpenGLState::ResetVertexArray(GLuint handle) {
+    if (cur_state.draw.vertex_array == handle) {
+        cur_state.draw.vertex_array = 0;
+        glBindVertexArray(0);
     }
-    return *this;
 }
 
-OpenGLState& OpenGLState::ResetFramebuffer(GLuint handle) {
-    if (draw.read_framebuffer == handle) {
-        draw.read_framebuffer = 0;
+void OpenGLState::ResetFramebuffer(GLuint handle) {
+    if (cur_state.draw.read_framebuffer == handle) {
+        cur_state.draw.read_framebuffer = 0;
+        glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
     }
-    if (draw.draw_framebuffer == handle) {
-        draw.draw_framebuffer = 0;
+    if (cur_state.draw.draw_framebuffer == handle) {
+        cur_state.draw.draw_framebuffer = 0;
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
     }
-    return *this;
 }
 
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/gl_state.h b/src/video_core/renderer_opengl/gl_state.h
index b1842a820eb..7214eea4de2 100644
--- a/src/video_core/renderer_opengl/gl_state.h
+++ b/src/video_core/renderer_opengl/gl_state.h
@@ -154,14 +154,24 @@ class OpenGLState {
     /// Apply this state as the current OpenGL state
     void Apply() const;
 
+    /// apply directly
+    static GLuint BindVertexArray(GLuint array);
+    static GLuint BindVertexBuffer(GLuint buffer);
+    static GLuint BindUniformBuffer(GLuint buffer);
+    static GLuint BindTexture2D(int index, GLuint texture);
+    static GLuint BindTextureCube(GLuint texture_cube);
+    static GLuint BindReadFramebuffer(GLuint framebuffer);
+    static GLuint BindDrawFramebuffer(GLuint framebuffer);
+    static GLuint BindShaderProgram(GLuint shader);
+
     /// Resets any references to the given resource
-    OpenGLState& ResetTexture(GLuint handle);
-    OpenGLState& ResetSampler(GLuint handle);
-    OpenGLState& ResetProgram(GLuint handle);
-    OpenGLState& ResetPipeline(GLuint handle);
-    OpenGLState& ResetBuffer(GLuint handle);
-    OpenGLState& ResetVertexArray(GLuint handle);
-    OpenGLState& ResetFramebuffer(GLuint handle);
+    static void ResetTexture(GLuint handle);
+    static void ResetSampler(GLuint handle);
+    static void ResetProgram(GLuint handle);
+    static void ResetPipeline(GLuint handle);
+    static void ResetBuffer(GLuint handle);
+    static void ResetVertexArray(GLuint handle);
+    static void ResetFramebuffer(GLuint handle);
 
 private:
     static OpenGLState cur_state;
diff --git a/src/video_core/renderer_opengl/gl_vars.cpp b/src/video_core/renderer_opengl/gl_vars.cpp
index 7eb0f11520d..49a95440e63 100644
--- a/src/video_core/renderer_opengl/gl_vars.cpp
+++ b/src/video_core/renderer_opengl/gl_vars.cpp
@@ -4,6 +4,239 @@
 
 #include "video_core/renderer_opengl/gl_vars.h"
 
+#include <cstring>
+
+#include "common/logging/log.h"
+
 namespace OpenGL {
 bool GLES;
+bool AllowShadow;
+
+void CheckGLError(const char* file, int line) {
+    GLenum err = glGetError();
+    if (err != GL_NO_ERROR) {
+        LOG_DEBUG(Render_OpenGL, "GL error {} on {}:{}", GLEnumToString(err), file, line);
+    }
+}
+
+const char* GLEnumToString(GLenum type) {
+    switch (type) {
+    // logic ops
+    case GL_CLEAR:
+        return "GL_CLEAR";
+    case GL_AND:
+        return "GL_AND";
+    case GL_AND_REVERSE:
+        return "GL_AND_REVERSE";
+    case GL_COPY:
+        return "GL_COPY";
+    case GL_SET:
+        return "GL_SET";
+    case GL_COPY_INVERTED:
+        return "GL_COPY_INVERTED";
+    case GL_NOOP:
+        return "GL_NOOP";
+    case GL_INVERT:
+        return "GL_INVERT";
+    case GL_NAND:
+        return "GL_NAND";
+    case GL_OR:
+        return "GL_OR";
+    case GL_NOR:
+        return "GL_NOR";
+    case GL_XOR:
+        return "GL_XOR";
+    case GL_EQUIV:
+        return "GL_EQUIV";
+    case GL_AND_INVERTED:
+        return "GL_AND_INVERTED";
+    case GL_OR_REVERSE:
+        return "GL_OR_REVERSE";
+    case GL_OR_INVERTED:
+        return "GL_OR_INVERTED";
+        // format
+    case GL_RGBA8:
+        return "GL_RGBA8";
+    case GL_RGB8:
+        return "GL_RGB8";
+    case GL_RGB5_A1:
+        return "GL_RGB5_A1";
+    case GL_RGB565:
+        return "GL_RGB565";
+    case GL_RGBA4:
+        return "GL_RGBA4";
+    case GL_DEPTH24_STENCIL8:
+        return "GL_DEPTH24_STENCIL8";
+    // format
+    case GL_RGBA:
+        return "GL_RGBA";
+    case GL_BGR:
+        return "GL_BGR";
+    case GL_RGB:
+        return "GL_RGB";
+    case GL_DEPTH_STENCIL:
+        return "GL_DEPTH_STENCIL";
+    // type
+    case GL_UNSIGNED_BYTE:
+        return "GL_UNSIGNED_BYTE";
+    case GL_UNSIGNED_SHORT_4_4_4_4:
+        return "GL_UNSIGNED_SHORT_4_4_4_4";
+    case GL_UNSIGNED_SHORT_5_6_5:
+        return "GL_UNSIGNED_SHORT_5_6_5";
+    case GL_UNSIGNED_SHORT_5_5_5_1:
+        return "GL_UNSIGNED_SHORT_5_5_5_1";
+    case GL_UNSIGNED_INT_8_8_8_8:
+        return "GL_UNSIGNED_INT_8_8_8_8";
+    case GL_UNSIGNED_INT_24_8:
+        return "GL_UNSIGNED_INT_24_8";
+    // error
+    case GL_OUT_OF_MEMORY:
+        return "GL_OUT_OF_MEMORY";
+    case GL_PACK_ALIGNMENT:
+        return "GL_PACK_ALIGNMENT";
+    case GL_INVALID_ENUM:
+        return "GL_INVALID_ENUM";
+    case GL_INVALID_VALUE:
+        return "GL_INVALID_VALUE";
+    case GL_INVALID_OPERATION:
+        return "GL_INVALID_OPERATION";
+    default: {
+        static char str[16];
+        snprintf(str, sizeof(str), "0x%04X", type);
+        return str;
+    }
+    }
+}
+
+inline u8 Convert5To8(u8 v) {
+    // Swizzle bits: 00012345 -> 12345123
+    return (v << 3) | (v >> 2);
+}
+
+inline u8 Convert6To8(u8 v) {
+    // Swizzle bits: 00123456 -> 12345612
+    return (v << 2) | (v >> 4);
+}
+
+inline u32 RGBA4444ToRGBA8888(u16 src) {
+    const u32 r = (src & 0x000F) << 0;
+    const u32 g = (src & 0x00F0) << 4;
+    const u32 b = (src & 0x0F00) << 8;
+    const u32 a = (src & 0xF000) << 12;
+
+    const u32 c = r | g | b | a;
+    return c | (c << 4);
 }
+
+inline u32 RGBA5551ToRGBA8888(u16 src) {
+    u8 r = Convert5To8((src >> 0) & 0x1F);
+    u8 g = Convert5To8((src >> 5) & 0x1F);
+    u8 b = Convert5To8((src >> 10) & 0x1F);
+    u8 a = (src >> 15) & 0x1;
+    a = (a) ? 0xff : 0;
+    return (a << 24) | (b << 16) | (g << 8) | r;
+}
+
+inline u32 RGB565ToRGBA8888(u16 src) {
+    u8 r = Convert5To8((src >> 0) & 0x1F);
+    u8 g = Convert6To8((src >> 5) & 0x3F);
+    u8 b = Convert5To8((src >> 11) & 0x1F);
+    u8 a = 0xFF;
+    return (a << 24) | (b << 16) | (g << 8) | r;
+}
+
+inline u32 BGRA8888ToRGBA8888(u32 src) {
+    u32 b = src & 0xFF;
+    u32 g = (src >> 8) & 0xFF;
+    u32 r = (src >> 16) & 0xFF;
+    u32 a = (src >> 24) & 0xFF;
+    return (a << 24) | (b << 16) | (g << 8) | r;
+}
+
+void ConvertToRGBA8888(u32* dst, const u8* src, u32 num_pixels, GLenum format, GLenum type) {
+    switch (format) {
+    case GL_RGBA:
+        switch (type) {
+        case GL_UNSIGNED_INT_8_8_8_8:
+        case GL_UNSIGNED_BYTE:
+            memcpy(dst, src, num_pixels * 4);
+            break;
+        case GL_UNSIGNED_SHORT_5_5_5_1: {
+            const u16* src16 = reinterpret_cast<const u16*>(src);
+            for (u32 i = 0; i < num_pixels; ++i) {
+                dst[i] = RGBA5551ToRGBA8888(src16[i]);
+            }
+        } break;
+        case GL_UNSIGNED_SHORT_4_4_4_4: {
+            const u16* src16 = reinterpret_cast<const u16*>(src);
+            for (u32 i = 0; i < num_pixels; ++i) {
+                dst[i] = RGBA4444ToRGBA8888(src16[i]);
+            }
+        } break;
+        default:
+            break;
+        }
+        break;
+    case GL_BGR:
+        switch (type) {
+        case GL_UNSIGNED_BYTE: {
+            for (u32 i = 0; i < num_pixels; ++i) {
+                const u32 r = src[i * 3 + 2];
+                const u32 g = src[i * 3 + 1];
+                const u32 b = src[i * 3 + 0];
+                const u32 a = 0xFF;
+                dst[i] = (a << 24) | (b << 16) | (g << 8) | r;
+            }
+        } break;
+        default:
+            break;
+        }
+        break;
+    case GL_RGB:
+        switch (type) {
+        case GL_UNSIGNED_SHORT_5_6_5: {
+            const u16* src16 = reinterpret_cast<const u16*>(src);
+            for (u32 i = 0; i < num_pixels; ++i) {
+                dst[i] = RGB565ToRGBA8888(src16[i]);
+            }
+        } break;
+        case GL_UNSIGNED_BYTE:
+            for (u32 i = 0; i < num_pixels; ++i) {
+                const u32 r = src[i * 3 + 0];
+                const u32 g = src[i * 3 + 1];
+                const u32 b = src[i * 3 + 2];
+                const u32 a = 0xFF;
+                dst[i] = (a << 24) | (b << 16) | (g << 8) | r;
+            }
+            break;
+        default:
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+void FlipPixels(u32* pixels, u32 width, u32 height) {
+    for (u32 y = 0; y < height; ++y) {
+        for (u32 x = 0; x < width; ++x) {
+            u32 from = width * y + x;
+            u32 to = width * (height - y - 1) + x;
+            if (from == to) {
+                u32 from_value = BGRA8888ToRGBA8888(pixels[from]);
+                pixels[from] = from_value;
+                return;
+            } else if (from < to) {
+                u32 from_value = BGRA8888ToRGBA8888(pixels[from]);
+                u32 to_value = BGRA8888ToRGBA8888(pixels[to]);
+                pixels[from] = to_value;
+                pixels[to] = from_value;
+            } else {
+                return;
+            }
+        }
+    }
+}
+
+} // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/gl_vars.h b/src/video_core/renderer_opengl/gl_vars.h
index 3a6d494cab3..23cba673dbd 100644
--- a/src/video_core/renderer_opengl/gl_vars.h
+++ b/src/video_core/renderer_opengl/gl_vars.h
@@ -4,6 +4,23 @@
 
 #pragma once
 
+#include <glad/glad.h>
+#include "common/common_types.h"
+
 namespace OpenGL {
 extern bool GLES;
-}
+extern bool AllowShadow;
+
+// #define DEBUG_OPENGL
+#if defined(DEBUG_OPENGL)
+void CheckGLError(const char* file, int line);
+#define CHECK_GL_ERROR() CheckGLError(__FILE__, __LINE__)
+#else
+#define CHECK_GL_ERROR() (void(0))
+#endif
+
+const char* GLEnumToString(GLenum type);
+void ConvertToRGBA8888(u32* dst, const u8* src, u32 num_pixels, GLenum format, GLenum type);
+void FlipPixels(u32* pixels, u32 width, u32 height);
+
+} // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/on_screen_display.cpp b/src/video_core/renderer_opengl/on_screen_display.cpp
new file mode 100644
index 00000000000..73e42b652cb
--- /dev/null
+++ b/src/video_core/renderer_opengl/on_screen_display.cpp
@@ -0,0 +1,436 @@
+#include "video_core/renderer_opengl/on_screen_display.h"
+
+#include <memory>
+
+#include "common/timer.h"
+#include "core/core.h"
+#include "core/frontend/framebuffer_layout.h"
+#include "core/settings.h"
+#include "video_core/renderer_opengl/gl_resource_manager.h"
+#include "video_core/renderer_opengl/gl_state.h"
+#include "video_core/renderer_opengl/gl_vars.h"
+
+namespace OSD {
+
+class RasterFont {
+public:
+    bool Initialize(float scale);
+    void AddMessage(const std::string& message, MessageType type, u32 duration, u32 color);
+    void Draw(const Layout::FramebufferLayout& layout);
+
+private:
+    void UpdateDebugInfo();
+    void DrawText(std::string_view text, u32 color);
+
+    GLint uniform_texture_id;
+    GLint uniform_color_id;
+    GLint uniform_offset_id;
+
+    OpenGL::OGLVertexArray vertex_array;
+    OpenGL::OGLBuffer vertex_buffer;
+    GLsizeiptr vertex_buffer_size;
+    OpenGL::OGLTexture texture;
+    OpenGL::OGLProgram shader;
+
+    struct Message {
+        std::string text;
+        MessageType type;
+        u64 timestamp;
+        u32 color;
+    };
+    std::vector<Message> messages;
+
+    struct DrawInfo {
+        float scaled_density;
+        float font_width;
+        float font_height;
+        float border_x;
+        float border_y;
+        float shadow_x;
+        float shadow_y;
+        float screen_width;
+        float screen_height;
+        float start_x;
+        float start_y;
+    } draw_info;
+
+    u64 debug_timestamp;
+};
+
+static const int CHARACTER_WIDTH = 8;
+static const int CHARACTER_HEIGHT = 13;
+static const int CHARACTER_OFFSET = 32;
+static const int CHARACTER_COUNT = 95;
+
+static const u8 rasters[CHARACTER_COUNT][CHARACTER_HEIGHT] = {
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36},
+    {0x00, 0x00, 0x00, 0x66, 0x66, 0xff, 0x66, 0x66, 0xff, 0x66, 0x66, 0x00, 0x00},
+    {0x00, 0x00, 0x18, 0x7e, 0xff, 0x1b, 0x1f, 0x7e, 0xf8, 0xd8, 0xff, 0x7e, 0x18},
+    {0x00, 0x00, 0x0e, 0x1b, 0xdb, 0x6e, 0x30, 0x18, 0x0c, 0x76, 0xdb, 0xd8, 0x70},
+    {0x00, 0x00, 0x7f, 0xc6, 0xcf, 0xd8, 0x70, 0x70, 0xd8, 0xcc, 0xcc, 0x6c, 0x38},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x1c, 0x0c, 0x0e},
+    {0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c},
+    {0x00, 0x00, 0x30, 0x18, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30},
+    {0x00, 0x00, 0x00, 0x00, 0x99, 0x5a, 0x3c, 0xff, 0x3c, 0x5a, 0x99, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0xff, 0xff, 0x18, 0x18, 0x18, 0x00, 0x00},
+    {0x00, 0x00, 0x30, 0x18, 0x1c, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x60, 0x60, 0x30, 0x30, 0x18, 0x18, 0x0c, 0x0c, 0x06, 0x06, 0x03, 0x03},
+    {0x00, 0x00, 0x3c, 0x66, 0xc3, 0xe3, 0xf3, 0xdb, 0xcf, 0xc7, 0xc3, 0x66, 0x3c},
+    {0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x38, 0x18},
+    {0x00, 0x00, 0xff, 0xc0, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0xe7, 0x7e},
+    {0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0x7e, 0x07, 0x03, 0x03, 0xe7, 0x7e},
+    {0x00, 0x00, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0xff, 0xcc, 0x6c, 0x3c, 0x1c, 0x0c},
+    {0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0xff},
+    {0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc7, 0xfe, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
+    {0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x03, 0x03, 0xff},
+    {0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e},
+    {0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x03, 0x7f, 0xe7, 0xc3, 0xc3, 0xe7, 0x7e},
+    {0x00, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x30, 0x18, 0x1c, 0x1c, 0x00, 0x00, 0x1c, 0x1c, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06},
+    {0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60},
+    {0x00, 0x00, 0x18, 0x00, 0x00, 0x18, 0x18, 0x0c, 0x06, 0x03, 0xc3, 0xc3, 0x7e},
+    {0x00, 0x00, 0x3f, 0x60, 0xcf, 0xdb, 0xd3, 0xdd, 0xc3, 0x7e, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xc3, 0xc3, 0xc3, 0x66, 0x3c, 0x18},
+    {0x00, 0x00, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
+    {0x00, 0x00, 0x7e, 0xe7, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
+    {0x00, 0x00, 0xfc, 0xce, 0xc7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc7, 0xce, 0xfc},
+    {0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xc0, 0xff},
+    {0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0xff},
+    {0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xcf, 0xc0, 0xc0, 0xc0, 0xc0, 0xe7, 0x7e},
+    {0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xff, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
+    {0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e},
+    {0x00, 0x00, 0x7c, 0xee, 0xc6, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06},
+    {0x00, 0x00, 0xc3, 0xc6, 0xcc, 0xd8, 0xf0, 0xe0, 0xf0, 0xd8, 0xcc, 0xc6, 0xc3},
+    {0x00, 0x00, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0},
+    {0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xdb, 0xff, 0xff, 0xe7, 0xc3},
+    {0x00, 0x00, 0xc7, 0xc7, 0xcf, 0xcf, 0xdf, 0xdb, 0xfb, 0xf3, 0xf3, 0xe3, 0xe3},
+    {0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xe7, 0x7e},
+    {0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
+    {0x00, 0x00, 0x3f, 0x6e, 0xdf, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x66, 0x3c},
+    {0x00, 0x00, 0xc3, 0xc6, 0xcc, 0xd8, 0xf0, 0xfe, 0xc7, 0xc3, 0xc3, 0xc7, 0xfe},
+    {0x00, 0x00, 0x7e, 0xe7, 0x03, 0x03, 0x07, 0x7e, 0xe0, 0xc0, 0xc0, 0xe7, 0x7e},
+    {0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff},
+    {0x00, 0x00, 0x7e, 0xe7, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
+    {0x00, 0x00, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
+    {0x00, 0x00, 0xc3, 0xe7, 0xff, 0xff, 0xdb, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3},
+    {0x00, 0x00, 0xc3, 0x66, 0x66, 0x3c, 0x3c, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3},
+    {0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3},
+    {0x00, 0x00, 0xff, 0xc0, 0xc0, 0x60, 0x30, 0x7e, 0x0c, 0x06, 0x03, 0x03, 0xff},
+    {0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3c},
+    {0x00, 0x03, 0x03, 0x06, 0x06, 0x0c, 0x0c, 0x18, 0x18, 0x30, 0x30, 0x60, 0x60},
+    {0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18},
+    {0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x30, 0x70},
+    {0x00, 0x00, 0x7f, 0xc3, 0xc3, 0x7f, 0x03, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xfe, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0},
+    {0x00, 0x00, 0x7e, 0xc3, 0xc0, 0xc0, 0xc0, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x7f, 0xc3, 0xc3, 0xc3, 0xc3, 0x7f, 0x03, 0x03, 0x03, 0x03, 0x03},
+    {0x00, 0x00, 0x7f, 0xc0, 0xc0, 0xfe, 0xc3, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x30, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x33, 0x1e},
+    {0x7e, 0xc3, 0x03, 0x03, 0x7f, 0xc3, 0xc3, 0xc3, 0x7e, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0xc0, 0xc0, 0xc0, 0xc0},
+    {0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x18, 0x00},
+    {0x38, 0x6c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x0c, 0x00},
+    {0x00, 0x00, 0xc6, 0xcc, 0xf8, 0xf0, 0xd8, 0xcc, 0xc6, 0xc0, 0xc0, 0xc0, 0xc0},
+    {0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78},
+    {0x00, 0x00, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xfe, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xfc, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00},
+    {0xc0, 0xc0, 0xc0, 0xfe, 0xc3, 0xc3, 0xc3, 0xc3, 0xfe, 0x00, 0x00, 0x00, 0x00},
+    {0x03, 0x03, 0x03, 0x7f, 0xc3, 0xc3, 0xc3, 0xc3, 0x7f, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xe0, 0xfe, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xfe, 0x03, 0x03, 0x7e, 0xc0, 0xc0, 0x7f, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x1c, 0x36, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x30, 0x00},
+    {0x00, 0x00, 0x7e, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x18, 0x3c, 0x3c, 0x66, 0x66, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xc3, 0xe7, 0xff, 0xdb, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0xc3, 0x00, 0x00, 0x00, 0x00},
+    {0xc0, 0x60, 0x60, 0x30, 0x18, 0x3c, 0x66, 0x66, 0xc3, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0xff, 0x60, 0x30, 0x18, 0x0c, 0x06, 0xff, 0x00, 0x00, 0x00, 0x00},
+    {0x00, 0x00, 0x0f, 0x18, 0x18, 0x18, 0x38, 0xf0, 0x38, 0x18, 0x18, 0x18, 0x0f},
+    {0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18},
+    {0x00, 0x00, 0xf0, 0x18, 0x18, 0x18, 0x1c, 0x0f, 0x1c, 0x18, 0x18, 0x18, 0xf0},
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x8f, 0xf1, 0x60, 0x00, 0x00, 0x00}};
+
+static const char* s_vertexShaderSrc = R"(uniform vec2 charSize;
+uniform vec2 offset;
+in vec2 rawpos;
+in vec2 rawtex0;
+out vec2 uv0;
+void main() {
+    gl_Position = vec4(rawpos + offset, 0, 1);
+    uv0 = rawtex0 * charSize;
+})";
+
+static const char* s_fragmentShaderSrc = R"(uniform sampler2D samp0;
+uniform vec4 color;
+in vec2 uv0;
+out vec4 ocol0;
+void main() {
+    ocol0 = texture(samp0, uv0) * color;
+})";
+
+bool RasterFont::Initialize(float scale) {
+    debug_timestamp = 0;
+
+    // A scaling factor for fonts displayed on the display.
+    draw_info.scaled_density = scale;
+
+    // Generate the texture
+    texture.Create();
+
+    // Generate VBO handle for drawing
+    vertex_buffer.Create();
+    vertex_buffer_size = 0;
+
+    // Generate VAO
+    vertex_array.Create();
+
+    // generate shader
+    std::string frag_source;
+    if (OpenGL::GLES) {
+        frag_source = OpenGL::fragment_shader_precision_OES;
+        frag_source += s_fragmentShaderSrc;
+    } else {
+        frag_source = s_fragmentShaderSrc;
+    }
+    shader.Create(s_vertexShaderSrc, frag_source.c_str());
+
+    // apply
+    OpenGL::OpenGLState state = OpenGL::OpenGLState::GetCurState();
+    OpenGL::OpenGLState prev_state = state;
+    state.draw.shader_program = shader.handle;
+    state.draw.vertex_array = vertex_array.handle;
+    state.draw.vertex_buffer = vertex_buffer.handle;
+    state.texture_units[0].texture_2d = texture.handle;
+    state.Apply();
+
+    // init texture
+    std::vector<u32> texture_data(CHARACTER_WIDTH * CHARACTER_COUNT * CHARACTER_HEIGHT);
+    for (int y = 0; y < CHARACTER_HEIGHT; y++) {
+        for (int c = 0; c < CHARACTER_COUNT; c++) {
+            for (int x = 0; x < CHARACTER_WIDTH; x++) {
+                bool pixel = (0 != (rasters[c][y] & (1 << (CHARACTER_WIDTH - x - 1))));
+                texture_data[CHARACTER_WIDTH * CHARACTER_COUNT * y + CHARACTER_WIDTH * c + x] =
+                    pixel ? -1 : 0;
+            }
+        }
+    }
+    glActiveTexture(GL_TEXTURE0);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, CHARACTER_WIDTH * CHARACTER_COUNT, CHARACTER_HEIGHT, 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, texture_data.data());
+
+    // bound uniforms
+    uniform_texture_id = glGetUniformLocation(shader.handle, "samp0");
+    uniform_color_id = glGetUniformLocation(shader.handle, "color");
+    uniform_offset_id = glGetUniformLocation(shader.handle, "offset");
+    glUniform1i(uniform_texture_id, 0);
+    glUniform2f(glGetUniformLocation(shader.handle, "charSize"), 1.0F / GLfloat(CHARACTER_COUNT),
+                1.0F);
+
+    // generate VBO & VAO
+    GLuint attrib_position = glGetAttribLocation(shader.handle, "rawpos");
+    GLuint attrib_tex_coord = glGetAttribLocation(shader.handle, "rawtex0");
+    glEnableVertexAttribArray(attrib_position);
+    glVertexAttribPointer(attrib_position, 2, GL_FLOAT, 0, sizeof(GLfloat) * 4, nullptr);
+    glEnableVertexAttribArray(attrib_tex_coord);
+    glVertexAttribPointer(attrib_tex_coord, 2, GL_FLOAT, 0, sizeof(GLfloat) * 4,
+                          (GLfloat*)nullptr + 2);
+
+    prev_state.Apply();
+
+    return true;
+}
+
+void RasterFont::DrawText(std::string_view text, u32 color) {
+    int usage = 0;
+    GLfloat x = draw_info.start_x;
+    GLfloat y = draw_info.start_y;
+    std::vector<GLfloat> vertices(text.length() * 6 * 4);
+
+    for (const char& c : text) {
+        if (c == '\n') {
+            x = draw_info.start_x;
+            y -= draw_info.font_height + draw_info.border_y;
+            continue;
+        }
+
+        // do not print spaces, they can be skipped easily
+        if (c == ' ') {
+            x += draw_info.font_width + draw_info.border_x;
+            continue;
+        }
+
+        if (c < CHARACTER_OFFSET || c >= CHARACTER_COUNT + CHARACTER_OFFSET)
+            continue;
+
+        vertices[usage++] = x;
+        vertices[usage++] = y;
+        vertices[usage++] = GLfloat(c - CHARACTER_OFFSET);
+        vertices[usage++] = 0.0f;
+
+        vertices[usage++] = x + draw_info.font_width;
+        vertices[usage++] = y;
+        vertices[usage++] = GLfloat(c - CHARACTER_OFFSET + 1);
+        vertices[usage++] = 0.0f;
+
+        vertices[usage++] = x + draw_info.font_width;
+        vertices[usage++] = y + draw_info.font_height;
+        vertices[usage++] = GLfloat(c - CHARACTER_OFFSET + 1);
+        vertices[usage++] = 1.0f;
+
+        vertices[usage++] = x;
+        vertices[usage++] = y;
+        vertices[usage++] = GLfloat(c - CHARACTER_OFFSET);
+        vertices[usage++] = 0.0f;
+
+        vertices[usage++] = x + draw_info.font_width;
+        vertices[usage++] = y + draw_info.font_height;
+        vertices[usage++] = GLfloat(c - CHARACTER_OFFSET + 1);
+        vertices[usage++] = 1.0f;
+
+        vertices[usage++] = x;
+        vertices[usage++] = y + draw_info.font_height;
+        vertices[usage++] = GLfloat(c - CHARACTER_OFFSET);
+        vertices[usage++] = 1.0f;
+
+        x += draw_info.font_width + draw_info.border_x;
+    }
+    draw_info.start_y = y - draw_info.font_height - draw_info.border_y;
+
+    if (!usage) {
+        return;
+    }
+
+    GLsizeiptr need_size = usage * sizeof(GLfloat);
+    if (need_size > vertex_buffer_size) {
+        glBufferData(GL_ARRAY_BUFFER, need_size, vertices.data(), GL_STREAM_DRAW);
+        vertex_buffer_size = need_size;
+    } else {
+        glBufferSubData(GL_ARRAY_BUFFER, 0, need_size, vertices.data());
+    }
+
+    // text shadow
+    glUniform2f(uniform_offset_id, draw_info.shadow_x, draw_info.shadow_y);
+    glUniform4f(uniform_color_id, 0.0f, 0.0f, 0.0f, GLfloat((color >> 24) & 0xff) / 255.f);
+    glDrawArrays(GL_TRIANGLES, 0, usage / 4);
+
+    // text
+    glUniform2f(uniform_offset_id, 0.0f, 0.0f);
+    glUniform4f(uniform_color_id, GLfloat((color >> 16) & 0xff) / 255.f,
+                GLfloat((color >> 8) & 0xff) / 255.f, GLfloat((color >> 0) & 0xff) / 255.f,
+                GLfloat((color >> 24) & 0xff) / 255.f);
+    glDrawArrays(GL_TRIANGLES, 0, usage / 4);
+}
+
+void RasterFont::AddMessage(const std::string& message, MessageType type, u32 duration, u32 color) {
+    u64 now = static_cast<u64>(Common::Timer::GetTimeMs().count());
+    if (type != MessageType::Typeless) {
+        auto iter = messages.begin();
+        while (iter != messages.end()) {
+            if (iter->type == type) {
+                iter->text = message;
+                iter->timestamp = now + duration;
+                iter->color = color;
+                return;
+            }
+            ++iter;
+        }
+    }
+    messages.emplace_back(Message{message, type, now + duration, color});
+}
+
+void RasterFont::UpdateDebugInfo() {
+    Core::PerfStats::Results stats = Core::System::GetInstance().GetAndResetPerfStats();
+    std::string text = fmt::format(
+        "FPS:{:>2} - VPS:{:>2} - SPD:{:>2}", static_cast<int>(stats.game_fps),
+        static_cast<int>(stats.system_fps), static_cast<int>(stats.emulation_speed * 100.0));
+
+    AddMessage(text, MessageType::FPS, Duration::FOREVER, Color::BLUE);
+}
+
+void RasterFont::Draw(const Layout::FramebufferLayout& layout) {
+    draw_info.screen_width = static_cast<float>(layout.width);
+    draw_info.screen_height = static_cast<float>(layout.height);
+    draw_info.font_width =
+        draw_info.scaled_density * CHARACTER_WIDTH / draw_info.screen_width * 2.0f;
+    draw_info.font_height =
+        draw_info.scaled_density * CHARACTER_HEIGHT / draw_info.screen_height * 2.0f;
+    draw_info.border_x = draw_info.font_width / 2.0f;
+    draw_info.border_y = draw_info.font_height / 2.0f;
+    draw_info.shadow_x = draw_info.font_width / 4.0f;
+    draw_info.shadow_y = -draw_info.font_height / 6.0f;
+    draw_info.start_x = draw_info.font_width - 1.0f;
+    if (draw_info.screen_width < draw_info.screen_height) {
+        draw_info.start_y = 1.0f - draw_info.font_height * 6.0f;
+    } else {
+        draw_info.start_y = 1.0f - draw_info.font_height * 2.0f;
+    }
+
+    OpenGL::OpenGLState state = OpenGL::OpenGLState::GetCurState();
+    state.draw.shader_program = shader.handle;
+    state.draw.vertex_array = vertex_array.handle;
+    state.draw.vertex_buffer = vertex_buffer.handle;
+    state.texture_units[0].texture_2d = texture.handle;
+    state.blend.enabled = true;
+    state.blend.src_rgb_func = GL_SRC_COLOR;
+    state.blend.src_a_func = GL_ZERO;
+    state.blend.dst_rgb_func = GL_ONE_MINUS_SRC_ALPHA;
+    state.blend.dst_a_func = GL_ONE;
+    state.Apply();
+
+    glActiveTexture(GL_TEXTURE0);
+
+    u64 now = static_cast<u64>(Common::Timer::GetTimeMs().count());
+
+    if (now - debug_timestamp > 500) {
+        UpdateDebugInfo();
+        debug_timestamp = now;
+    }
+
+    auto iter = messages.begin();
+    while (iter != messages.end()) {
+        if (iter->timestamp < now) {
+            iter = messages.erase(iter);
+        } else {
+            DrawText(iter->text, iter->color);
+            ++iter;
+        }
+    }
+}
+
+static std::unique_ptr<RasterFont> s_raster_font;
+
+void Initialize() {
+    s_raster_font = std::make_unique<RasterFont>();
+    s_raster_font->Initialize(2.0f);
+    // fps placeholder
+    AddMessage("", MessageType::FPS, Duration::FOREVER, Color::BLUE);
+}
+
+void AddMessage(const std::string& message, MessageType type, u32 duration, u32 color) {
+    if (Settings::values.show_fps) {
+        s_raster_font->AddMessage(message, type, duration, color);
+    }
+}
+
+void DrawMessage(const Layout::FramebufferLayout& layout) {
+    if (Settings::values.show_fps) {
+        s_raster_font->Draw(layout);
+    }
+}
+
+void Shutdown() {
+    s_raster_font.reset();
+}
+
+} // namespace OSD
diff --git a/src/video_core/renderer_opengl/on_screen_display.h b/src/video_core/renderer_opengl/on_screen_display.h
new file mode 100644
index 00000000000..1fe48f8f9de
--- /dev/null
+++ b/src/video_core/renderer_opengl/on_screen_display.h
@@ -0,0 +1,44 @@
+
+#pragma once
+
+#include <string>
+
+#include "common/common_types.h"
+
+namespace Layout {
+struct FramebufferLayout;
+}
+
+namespace OSD {
+
+enum class MessageType {
+    FPS,
+    LOGIC_OP,
+    D24S8,
+    Typeless,
+};
+
+namespace Color {
+constexpr u32 CYAN = 0xFF00FFFF;
+constexpr u32 GREEN = 0xFF00FF00;
+constexpr u32 RED = 0xFFFF0000;
+constexpr u32 BLUE = 0xFF00FFFF;
+constexpr u32 YELLOW = 0xFFFFFF30;
+}; // namespace Color
+
+namespace Duration {
+constexpr u32 SHORT = 2000;
+constexpr u32 NORMAL = 5000;
+constexpr u32 VERY_LONG = 10000;
+constexpr u32 FOREVER = -1;
+}; // namespace Duration
+
+void Initialize();
+
+void AddMessage(const std::string& message, MessageType type, u32 duration, u32 color);
+
+void DrawMessage(const Layout::FramebufferLayout& layout);
+
+void Shutdown();
+
+} // namespace OSD
diff --git a/src/video_core/renderer_opengl/renderer_opengl.cpp b/src/video_core/renderer_opengl/renderer_opengl.cpp
index 51d5272d21b..0b521059f35 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.cpp
+++ b/src/video_core/renderer_opengl/renderer_opengl.cpp
@@ -23,6 +23,7 @@
 #include "video_core/debug_utils/debug_utils.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_opengl/gl_vars.h"
+#include "video_core/renderer_opengl/on_screen_display.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
 #include "video_core/video_core.h"
 
@@ -53,10 +54,6 @@ static const char fragment_shader[] = R"(
 in vec2 frag_tex_coord;
 out vec4 color;
 
-uniform vec4 i_resolution;
-uniform vec4 o_resolution;
-uniform int layer;
-
 uniform sampler2D color_texture;
 
 void main() {
@@ -64,34 +61,30 @@ void main() {
 }
 )";
 
-static const char fragment_shader_anaglyph[] = R"(
-
-// Anaglyph Red-Cyan shader based on Dubois algorithm
-// Constants taken from the paper:
-// "Conversion of a Stereo Pair to Anaglyph with
-// the Least-Squares Projection Method"
-// Eric Dubois, March 2009
-const mat3 l = mat3( 0.437, 0.449, 0.164,
-              -0.062,-0.062,-0.024,
-              -0.048,-0.050,-0.017);
-const mat3 r = mat3(-0.011,-0.032,-0.007,
-               0.377, 0.761, 0.009,
-              -0.026,-0.093, 1.234);
-
-in vec2 frag_tex_coord;
-out vec4 color;
-
-uniform vec4 resolution;
-uniform int layer;
-
+static const char post_processing_header[] = R"(
+// hlsl to glsl types
+#define float2 vec2
+#define float3 vec3
+#define float4 vec4
+#define uint2 uvec2
+#define uint3 uvec3
+#define uint4 uvec4
+#define int2 ivec2
+#define int3 ivec3
+#define int4 ivec4
+
+in float2 frag_tex_coord;
+out float4 output_color;
+
+uniform float4 resolution;
 uniform sampler2D color_texture;
-uniform sampler2D color_texture_r;
 
-void main() {
-    vec4 color_tex_l = texture(color_texture, frag_tex_coord);
-    vec4 color_tex_r = texture(color_texture_r, frag_tex_coord);
-    color = vec4(color_tex_l.rgb*l+color_tex_r.rgb*r, color_tex_l.a);
-}
+float4 Sample() { return texture(color_texture, frag_tex_coord); }
+float4 SampleLocation(float2 location) { return texture(color_texture, location); }
+float2 GetResolution() { return resolution.xy; }
+float2 GetInvResolution() { return resolution.zw; }
+float2 GetCoordinates() { return frag_tex_coord; }
+void SetOutput(float4 color) { output_color = color; }
 )";
 
 /**
@@ -109,6 +102,16 @@ struct ScreenRectVertex {
     GLfloat tex_coord[2];
 };
 
+// Indirect Command
+typedef struct {
+    uint count;        // Specifies the number of indices to be rendered.
+    uint primCount;    // Specifies the number of instances of the specified range of indices to be
+                       // rendered.
+    uint first;        // Specifies the starting index in the enabled arrays.
+    uint baseInstance; // Specifies the base instance for use in fetching instanced vertex
+                       // attributes.
+} DrawArraysIndirectCommand;
+
 /**
  * Defines a 1:1 pixel ortographic projection matrix with (0,0) on the top-left
  * corner and (width, height) on the lower-bottom.
@@ -173,7 +176,38 @@ void RendererOpenGL::SwapBuffers() {
     }
 
     if (VideoCore::g_renderer_screenshot_requested) {
+        static u32 screenshot_id = 0;
         // Draw this frame to the screenshot framebuffer
+        OGLFramebuffer screenshot_framebuffer;
+        screenshot_framebuffer.Create();
+        GLuint old_read_fb = OpenGLState::BindReadFramebuffer(screenshot_framebuffer.handle);
+        GLuint old_draw_fb = OpenGLState::BindDrawFramebuffer(screenshot_framebuffer.handle);
+        // color attachment
+        OGLTexture color_tex;
+        color_tex.Create();
+        GLuint old_tex = OpenGLState::BindTexture2D(0, color_tex.handle);
+        u16 res_scale = VideoCore::GetResolutionScaleFactor();
+        const Layout::FramebufferLayout layout{Layout::FrameLayoutFromResolutionScale(res_scale)};
+        std::vector<u32> pixels(layout.width * layout.height);
+        auto path =
+            fmt::format("{}screenshot_{}.png", FileUtil::GetUserPath(FileUtil::UserPath::UserDir),
+                        screenshot_id++);
+
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, layout.width, layout.height, 0, GL_RGBA,
+                     GL_UNSIGNED_BYTE, nullptr);
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                               color_tex.handle, 0);
+
+        DrawScreens(layout);
+
+        glReadPixels(0, 0, layout.width, layout.height, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
+        FlipPixels(pixels.data(), layout.width, layout.height);
+
+        OpenGLState::BindTexture2D(0, old_tex);
+        OpenGLState::BindReadFramebuffer(old_read_fb);
+        OpenGLState::BindDrawFramebuffer(old_draw_fb);
+
+        VideoCore::g_dump_texture_callback(pixels.data(), layout.width, layout.height, path);
         VideoCore::g_renderer_screenshot_requested = false;
     }
 
@@ -182,6 +216,9 @@ void RendererOpenGL::SwapBuffers() {
 
     Core::System::GetInstance().perf_stats->EndSystemFrame();
 
+    // draw on screen display
+    OSD::DrawMessage(render_window.GetFramebufferLayout());
+
     // Swap buffers
     render_window.PollEvents();
     render_window.SwapBuffers();
@@ -192,10 +229,11 @@ void RendererOpenGL::SwapBuffers() {
 
     prev_state.Apply();
     RefreshRasterizerSetting();
-
+#ifdef DEBUG_CONTEXT
     if (Pica::g_debug_context && Pica::g_debug_context->recorder) {
         Pica::g_debug_context->recorder->FrameFinished();
     }
+#endif
 }
 
 /**
@@ -236,10 +274,8 @@ void RendererOpenGL::LoadFBToScreenInfo(const GPU::Regs::FramebufferConfig& fram
 
         const u8* framebuffer_data = VideoCore::g_memory->GetPhysicalPointer(framebuffer_addr);
 
-        state.texture_units[0].texture_2d = screen_info.texture.resource.handle;
-        state.Apply();
+        GLuint old_tex = OpenGLState::BindTexture2D(0, screen_info.texture.resource.handle);
 
-        glActiveTexture(GL_TEXTURE0);
         glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint)pixel_stride);
 
         // Update existing texture
@@ -247,14 +283,28 @@ void RendererOpenGL::LoadFBToScreenInfo(const GPU::Regs::FramebufferConfig& fram
         //       they differ from the LCD resolution.
         // TODO: Applications could theoretically crash Citra here by specifying too large
         //       framebuffer sizes. We should make sure that this cannot happen.
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, framebuffer.width, framebuffer.height,
-                        screen_info.texture.gl_format, screen_info.texture.gl_type,
-                        framebuffer_data);
+        if (GLES) {
+            u32 bytes_per_pixel = screen_info.texture.gl_format == GL_RGB ? 3 : 4;
+            std::vector<u8> pixels(framebuffer.width * framebuffer.height * 4);
+            u32 offsets[] = {2, 1, 0, 3};
+            for (u32 i = 0; i < framebuffer.width * framebuffer.height * bytes_per_pixel;
+                 i += bytes_per_pixel) {
+                for (u32 j = 0; j < bytes_per_pixel; ++j) {
+                    pixels[i + j] = framebuffer_data[i + offsets[j]];
+                }
+            }
+            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, framebuffer.width, framebuffer.height,
+                            screen_info.texture.gl_format, screen_info.texture.gl_type,
+                            pixels.data());
+        } else {
+            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, framebuffer.width, framebuffer.height,
+                            screen_info.texture.gl_format, screen_info.texture.gl_type,
+                            framebuffer_data);
+        }
 
         glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 
-        state.texture_units[0].texture_2d = 0;
-        state.Apply();
+        OpenGLState::BindTexture2D(0, old_tex);
     }
 }
 
@@ -264,17 +314,13 @@ void RendererOpenGL::LoadFBToScreenInfo(const GPU::Regs::FramebufferConfig& fram
  */
 void RendererOpenGL::LoadColorToActiveGLTexture(u8 color_r, u8 color_g, u8 color_b,
                                                 const TextureInfo& texture) {
-    state.texture_units[0].texture_2d = texture.resource.handle;
-    state.Apply();
-
-    glActiveTexture(GL_TEXTURE0);
+    GLuint old_tex = OpenGLState::BindTexture2D(0, texture.resource.handle);
     u8 framebuffer_data[3] = {color_r, color_g, color_b};
 
     // Update existing texture
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, framebuffer_data);
 
-    state.texture_units[0].texture_2d = 0;
-    state.Apply();
+    OpenGLState::BindTexture2D(0, old_tex);
 }
 
 /**
@@ -284,19 +330,50 @@ void RendererOpenGL::InitOpenGLObjects() {
     glClearColor(Settings::values.bg_red, Settings::values.bg_green, Settings::values.bg_blue,
                  0.0f);
 
-    filter_sampler.Create();
-
     // Generate VBO handle for drawing
     vertex_buffer.Create();
 
     // Generate VAO
     vertex_array.Create();
 
+    // Generate Indirect Buffer
+    indirect_buffer.Create();
+    DrawArraysIndirectCommand command{4, 1, 0, 0};
+    glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirect_buffer.handle);
+    glBufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(command), &command, GL_STREAM_DRAW);
+
+    // Link shaders and get variable locations
+    std::string frag_source;
+    if (GLES) {
+        frag_source += fragment_shader_precision_OES;
+    }
+    if (!Settings::values.pp_shader_name.empty()) {
+        std::string pp_shader = FileUtil::GetUserPath(FileUtil::UserPath::ShaderDir) +
+                                Settings::values.pp_shader_name + ".glsl";
+        std::size_t size = FileUtil::ReadFileToString(true, pp_shader, pp_shader);
+        if (size > 0 && size == pp_shader.size()) {
+            frag_source += post_processing_header;
+            frag_source += pp_shader;
+        } else {
+            frag_source += fragment_shader;
+        }
+    } else {
+        frag_source += fragment_shader;
+    }
+    shader.Create(vertex_shader, frag_source.data());
+
+    // apply
+    state.draw.shader_program = shader.handle;
     state.draw.vertex_array = vertex_array.handle;
     state.draw.vertex_buffer = vertex_buffer.handle;
-    state.draw.uniform_buffer = 0;
     state.Apply();
 
+    uniform_modelview_matrix = glGetUniformLocation(shader.handle, "modelview_matrix");
+    uniform_color_texture = glGetUniformLocation(shader.handle, "color_texture");
+    uniform_resolution = glGetUniformLocation(shader.handle, "resolution");
+    attrib_position = glGetAttribLocation(shader.handle, "vert_position");
+    attrib_tex_coord = glGetAttribLocation(shader.handle, "vert_tex_coord");
+
     // Attach vertex data to VAO
     glBufferData(GL_ARRAY_BUFFER, sizeof(ScreenRectVertex) * 4, nullptr, GL_STREAM_DRAW);
     glVertexAttribPointer(attrib_position, 2, GL_FLOAT, GL_FALSE, sizeof(ScreenRectVertex),
@@ -313,10 +390,8 @@ void RendererOpenGL::InitOpenGLObjects() {
         // Allocation of storage is deferred until the first frame, when we
         // know the framebuffer size.
 
-        state.texture_units[0].texture_2d = screen_info.texture.resource.handle;
-        state.Apply();
+        OpenGLState::BindTexture2D(0, screen_info.texture.resource.handle);
 
-        glActiveTexture(GL_TEXTURE0);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -326,8 +401,10 @@ void RendererOpenGL::InitOpenGLObjects() {
         screen_info.display_texture = screen_info.texture.resource.handle;
     }
 
-    state.texture_units[0].texture_2d = 0;
-    state.Apply();
+    // init
+    OSD::Initialize();
+
+    OpenGLState::BindTexture2D(0, 0);
 }
 
 void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
@@ -380,15 +457,12 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
         UNIMPLEMENTED();
     }
 
-    state.texture_units[0].texture_2d = texture.resource.handle;
-    state.Apply();
+    GLuint old_tex = OpenGLState::BindTexture2D(0, texture.resource.handle);
 
-    glActiveTexture(GL_TEXTURE0);
     glTexImage2D(GL_TEXTURE_2D, 0, internal_format, texture.width, texture.height, 0,
                  texture.gl_format, texture.gl_type, nullptr);
 
-    state.texture_units[0].texture_2d = 0;
-    state.Apply();
+    OpenGLState::BindTexture2D(0, old_tex);
 }
 
 /**
@@ -401,30 +475,19 @@ void RendererOpenGL::DrawSingleScreenRotated(const ScreenInfo& screen_info, floa
 
     const std::array<ScreenRectVertex, 4> vertices = {{
         ScreenRectVertex(x, y, texcoords.bottom, texcoords.left),
-        ScreenRectVertex(x + w, y, texcoords.bottom, texcoords.right),
         ScreenRectVertex(x, y + h, texcoords.top, texcoords.left),
+        ScreenRectVertex(x + w, y, texcoords.bottom, texcoords.right),
         ScreenRectVertex(x + w, y + h, texcoords.top, texcoords.right),
     }};
 
-    // As this is the "DrawSingleScreenRotated" function, the output resolution dimensions have been
-    // swapped. If a non-rotated draw-screen function were to be added for book-mode games, those
-    // should probably be set to the standard (w, h, 1.0 / w, 1.0 / h) ordering.
-    u16 scale_factor = VideoCore::GetResolutionScaleFactor();
-    glUniform4f(uniform_i_resolution, screen_info.texture.width * scale_factor,
-                screen_info.texture.height * scale_factor,
-                1.0 / (screen_info.texture.width * scale_factor),
-                1.0 / (screen_info.texture.height * scale_factor));
-    glUniform4f(uniform_o_resolution, h, w, 1.0f / h, 1.0f / w);
-    state.texture_units[0].texture_2d = screen_info.display_texture;
-    state.texture_units[0].sampler = filter_sampler.handle;
-    state.Apply();
+    OpenGLState::BindTexture2D(0, screen_info.display_texture);
 
-    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices.data());
-    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    float src_width = screen_info.texture.width;
+    float src_height = screen_info.texture.height;
+    glUniform4f(uniform_resolution, src_width, src_height, 1.0F / src_width, 1.0F / src_height);
 
-    state.texture_units[0].texture_2d = 0;
-    state.texture_units[0].sampler = 0;
-    state.Apply();
+    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices.data());
+    glDrawArraysIndirect(GL_TRIANGLE_STRIP, (const void*)nullptr);
 }
 
 /**
@@ -451,12 +514,10 @@ void RendererOpenGL::DrawScreens(const Layout::FramebufferLayout& layout) {
     // Bind texture in Texture Unit 0
     glUniform1i(uniform_color_texture, 0);
 
-    glUniform1i(uniform_layer, 0);
     if (layout.top_screen_enabled) {
         DrawSingleScreenRotated(screen_infos[0], (float)top_screen.left, (float)top_screen.top,
                                 (float)top_screen.GetWidth(), (float)top_screen.GetHeight());
     }
-    glUniform1i(uniform_layer, 0);
     if (layout.bottom_screen_enabled) {
         DrawSingleScreenRotated(screen_infos[2], (float)bottom_screen.left,
                                 (float)bottom_screen.top, (float)bottom_screen.GetWidth(),
@@ -561,6 +622,8 @@ Core::System::ResultStatus RendererOpenGL::Init() {
 }
 
 /// Shutdown the renderer
-void RendererOpenGL::ShutDown() {}
+void RendererOpenGL::ShutDown() {
+    OSD::Shutdown();
+}
 
 } // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/renderer_opengl.h b/src/video_core/renderer_opengl/renderer_opengl.h
index 11f2f237001..cbd1ecd1441 100644
--- a/src/video_core/renderer_opengl/renderer_opengl.h
+++ b/src/video_core/renderer_opengl/renderer_opengl.h
@@ -69,9 +69,8 @@ class RendererOpenGL : public RendererBase {
     // OpenGL object IDs
     OGLVertexArray vertex_array;
     OGLBuffer vertex_buffer;
+    OGLBuffer indirect_buffer;
     OGLProgram shader;
-    OGLFramebuffer screenshot_framebuffer;
-    OGLSampler filter_sampler;
 
     /// Display information for top and bottom screens respectively
     std::array<ScreenInfo, 3> screen_infos;
@@ -79,12 +78,7 @@ class RendererOpenGL : public RendererBase {
     // Shader uniform location indices
     GLuint uniform_modelview_matrix;
     GLuint uniform_color_texture;
-    GLuint uniform_color_texture_r;
-
-    // Shader uniform for Dolphin compatibility
-    GLuint uniform_i_resolution;
-    GLuint uniform_o_resolution;
-    GLuint uniform_layer;
+    GLuint uniform_resolution;
 
     // Shader attribute input indices
     GLuint attrib_position;