21 files changed, 1294 insertions, 355 deletions

diff --git a/src/Config.cpp b/src/Config.cpp
index fdb5e4a..3832c83 100644
--- a/src/Config.cpp
+++ b/src/Config.cpp
@@ -15,6 +15,8 @@
 #define FORMAT_U32 "%" PRIu32
 
 namespace gsr {
+    static const std::string_view add_audio_track_tag = "[add_audio_track]";
+
     static std::vector<mgl::Keyboard::Key> hotkey_modifiers_to_mgl_keys(uint32_t modifiers) {
         std::vector<mgl::Keyboard::Key> result;
         if(modifiers & HOTKEY_MOD_LCTRL)
@@ -101,6 +103,14 @@ namespace gsr {
         return result;
     }
 
+    bool AudioTrack::operator==(const AudioTrack &other) const {
+        return audio_inputs == other.audio_inputs && application_audio_invert == other.application_audio_invert;
+    }
+
+    bool AudioTrack::operator!=(const AudioTrack &other) const {
+        return !operator==(other);
+    }
+
     Config::Config(const SupportedCaptureOptions &capture_options) {
         const std::string default_videos_save_directory = get_videos_dir();
         const std::string default_pictures_save_directory = get_pictures_dir();
@@ -108,25 +118,25 @@ namespace gsr {
         set_hotkeys_to_default();
 
         streaming_config.record_options.video_quality = "custom";
-        streaming_config.record_options.audio_tracks.push_back("default_output");
+        streaming_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
         streaming_config.record_options.video_bitrate = 15000;
 
         record_config.save_directory = default_videos_save_directory;
-        record_config.record_options.audio_tracks.push_back("default_output");
+        record_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
         record_config.record_options.video_bitrate = 45000;
 
         replay_config.record_options.video_quality = "custom";
         replay_config.save_directory = default_videos_save_directory;
-        replay_config.record_options.audio_tracks.push_back("default_output");
+        replay_config.record_options.audio_tracks_list.push_back({std::vector<std::string>{"default_output"}, false});
         replay_config.record_options.video_bitrate = 45000;
 
         screenshot_config.save_directory = default_pictures_save_directory;
 
         if(!capture_options.monitors.empty()) {
-            streaming_config.record_options.record_area_option = capture_options.monitors.front().name;
-            record_config.record_options.record_area_option = capture_options.monitors.front().name;
-            replay_config.record_options.record_area_option = capture_options.monitors.front().name;
-            screenshot_config.record_area_option = capture_options.monitors.front().name;
+            streaming_config.record_options.record_area_option = "focused_monitor";
+            record_config.record_options.record_area_option = "focused_monitor";
+            replay_config.record_options.record_area_option = "focused_monitor";
+            screenshot_config.record_area_option = "focused_monitor";
         }
     }
 
@@ -152,7 +162,7 @@ namespace gsr {
         return KeyValue{line.substr(0, space_index), line.substr(space_index + 1)};
     }
 
-    using ConfigValue = std::variant<bool*, std::string*, int32_t*, ConfigHotkey*, std::vector<std::string>*>;
+    using ConfigValue = std::variant<bool*, std::string*, int32_t*, ConfigHotkey*, std::vector<std::string>*, std::vector<AudioTrack>*>;
 
     static std::map<std::string_view, ConfigValue> get_config_options(Config &config) {
         return {
@@ -174,6 +184,7 @@ namespace gsr {
             {"streaming.record_options.application_audio_invert", &config.streaming_config.record_options.application_audio_invert},
             {"streaming.record_options.change_video_resolution", &config.streaming_config.record_options.change_video_resolution},
             {"streaming.record_options.audio_track", &config.streaming_config.record_options.audio_tracks},
+            {"streaming.record_options.audio_track_item", &config.streaming_config.record_options.audio_tracks_list},
             {"streaming.record_options.color_range", &config.streaming_config.record_options.color_range},
             {"streaming.record_options.video_quality", &config.streaming_config.record_options.video_quality},
             {"streaming.record_options.codec", &config.streaming_config.record_options.video_codec},
@@ -203,6 +214,7 @@ namespace gsr {
             {"record.record_options.application_audio_invert", &config.record_config.record_options.application_audio_invert},
             {"record.record_options.change_video_resolution", &config.record_config.record_options.change_video_resolution},
             {"record.record_options.audio_track", &config.record_config.record_options.audio_tracks},
+            {"record.record_options.audio_track_item", &config.record_config.record_options.audio_tracks_list},
             {"record.record_options.color_range", &config.record_config.record_options.color_range},
             {"record.record_options.video_quality", &config.record_config.record_options.video_quality},
             {"record.record_options.codec", &config.record_config.record_options.video_codec},
@@ -231,6 +243,7 @@ namespace gsr {
             {"replay.record_options.application_audio_invert", &config.replay_config.record_options.application_audio_invert},
             {"replay.record_options.change_video_resolution", &config.replay_config.record_options.change_video_resolution},
             {"replay.record_options.audio_track", &config.replay_config.record_options.audio_tracks},
+            {"replay.record_options.audio_track_item", &config.replay_config.record_options.audio_tracks_list},
             {"replay.record_options.color_range", &config.replay_config.record_options.color_range},
             {"replay.record_options.video_quality", &config.replay_config.record_options.video_quality},
             {"replay.record_options.codec", &config.replay_config.record_options.video_codec},
@@ -291,6 +304,9 @@ namespace gsr {
             } else if(std::holds_alternative<std::vector<std::string>*>(it.second)) {
                 if(*std::get<std::vector<std::string>*>(it.second) != *std::get<std::vector<std::string>*>(it_other->second))
                     return false;
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it.second)) {
+                if(*std::get<std::vector<AudioTrack>*>(it.second) != *std::get<std::vector<AudioTrack>*>(it_other->second))
+                    return false;
             } else {
                 assert(false);
             }
@@ -302,6 +318,17 @@ namespace gsr {
         return !operator==(other);
     }
 
+    static void populate_new_audio_track_from_old(RecordOptions &record_options) {
+        if(record_options.merge_audio_tracks) {
+            record_options.audio_tracks_list.push_back({std::move(record_options.audio_tracks), record_options.application_audio_invert});
+        } else {
+            for(const std::string &audio_input : record_options.audio_tracks) {
+                record_options.audio_tracks_list.push_back({std::vector<std::string>{audio_input}, record_options.application_audio_invert});
+            }
+        }
+        record_options.audio_tracks.clear();
+    }
+
     std::optional<Config> read_config(const SupportedCaptureOptions &capture_options) {
         std::optional<Config> config;
 
@@ -313,10 +340,15 @@ namespace gsr {
         }
 
         config = Config(capture_options);
+
         config->streaming_config.record_options.audio_tracks.clear();
         config->record_config.record_options.audio_tracks.clear();
         config->replay_config.record_options.audio_tracks.clear();
 
+        config->streaming_config.record_options.audio_tracks_list.clear();
+        config->record_config.record_options.audio_tracks_list.clear();
+        config->replay_config.record_options.audio_tracks_list.clear();
+
         auto config_options = get_config_options(config.value());
 
         string_split_char(file_content, '\n', [&](std::string_view line) {
@@ -355,6 +387,23 @@ namespace gsr {
             } else if(std::holds_alternative<std::vector<std::string>*>(it->second)) {
                 std::string array_value(key_value->value);
                 std::get<std::vector<std::string>*>(it->second)->push_back(std::move(array_value));
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it->second)) {
+                const size_t space_index = key_value->value.find(' ');
+                if(space_index == std::string_view::npos) {
+                    fprintf(stderr, "Warning: Invalid config option value for %.*s\n", (int)key_value->key.size(), key_value->key.data());
+                    return true;
+                }
+
+                const bool application_audio_invert = key_value->value.substr(0, space_index) == "true";
+                const std::string_view audio_input = key_value->value.substr(space_index + 1);
+                std::vector<AudioTrack> &audio_tracks = *std::get<std::vector<AudioTrack>*>(it->second);
+
+                if(audio_input == add_audio_track_tag) {
+                    audio_tracks.push_back({std::vector<std::string>{}, application_audio_invert});
+                } else if(!audio_tracks.empty()) {
+                    audio_tracks.back().application_audio_invert = application_audio_invert;
+                    audio_tracks.back().audio_inputs.emplace_back(audio_input);
+                }
             } else {
                 assert(false);
             }
@@ -362,11 +411,16 @@ namespace gsr {
             return true;
         });
 
-        if(config->main_config.config_file_version != GSR_CONFIG_FILE_VERSION) {
-            fprintf(stderr, "Info: the config file is outdated, resetting it\n");
-            config = std::nullopt;
+        if(config->main_config.config_file_version == 1) {
+            populate_new_audio_track_from_old(config->streaming_config.record_options);
+            populate_new_audio_track_from_old(config->record_config.record_options);
+            populate_new_audio_track_from_old(config->replay_config.record_options);
         }
 
+        config->streaming_config.record_options.audio_tracks.clear();
+        config->record_config.record_options.audio_tracks.clear();
+        config->replay_config.record_options.audio_tracks.clear();
+
         return config;
     }
 
@@ -402,9 +456,17 @@ namespace gsr {
                 const ConfigHotkey *config_hotkey = std::get<ConfigHotkey*>(it.second);
                     fprintf(file, "%.*s " FORMAT_I64 " " FORMAT_U32 "\n", (int)it.first.size(), it.first.data(), config_hotkey->key, config_hotkey->modifiers);
             } else if(std::holds_alternative<std::vector<std::string>*>(it.second)) {
-                std::vector<std::string> *array = std::get<std::vector<std::string>*>(it.second);
-                for(const std::string &value : *array) {
-                    fprintf(file, "%.*s %s\n", (int)it.first.size(), it.first.data(), value.c_str());
+                std::vector<std::string> *audio_inputs = std::get<std::vector<std::string>*>(it.second);
+                for(const std::string &audio_input : *audio_inputs) {
+                    fprintf(file, "%.*s %s\n", (int)it.first.size(), it.first.data(), audio_input.c_str());
+                }
+            } else if(std::holds_alternative<std::vector<AudioTrack>*>(it.second)) {
+                std::vector<AudioTrack> *audio_tracks = std::get<std::vector<AudioTrack>*>(it.second);
+                for(const AudioTrack &audio_track : *audio_tracks) {
+                    fprintf(file, "%.*s %s %.*s\n", (int)it.first.size(), it.first.data(), audio_track.application_audio_invert ? "true" : "false", (int)add_audio_track_tag.size(), add_audio_track_tag.data());
+                    for(const std::string &audio_input : audio_track.audio_inputs) {
+                        fprintf(file, "%.*s %s %s\n", (int)it.first.size(), it.first.data(), audio_track.application_audio_invert ? "true" : "false", audio_input.c_str());
+                    }
                 }
             } else {
                 assert(false);
diff --git a/src/CursorTrackerWayland.cpp b/src/CursorTrackerWayland.cpp
new file mode 100644
index 0000000..5f37d0a
--- /dev/null
+++ b/src/CursorTrackerWayland.cpp
@@ -0,0 +1,510 @@
+#include "../include/CursorTrackerWayland.hpp"
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <wayland-client.h>
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+namespace gsr {
+    static const int MAX_CONNECTORS = 32;
+    static const int CONNECTOR_TYPE_COUNTS = 32;
+    static const uint32_t plane_property_all = 0xF;
+
+    typedef struct {
+        int type;
+        int count;
+    } drm_connector_type_count;
+
+    typedef enum {
+        PLANE_PROPERTY_CRTC_X      = 1 << 0,
+        PLANE_PROPERTY_CRTC_Y      = 1 << 1,
+        PLANE_PROPERTY_CRTC_ID     = 1 << 2,
+        PLANE_PROPERTY_TYPE_CURSOR = 1 << 3,
+    } plane_property_mask;
+
+    typedef struct {
+        uint64_t crtc_id;
+        mgl::vec2i size;
+    } drm_connector;
+
+    typedef struct {
+        drm_connector connectors[MAX_CONNECTORS];
+        int num_connectors;
+    } drm_connectors;
+
+    /* Returns plane_property_mask */
+    static uint32_t plane_get_properties(int drm_fd, uint32_t plane_id, int *crtc_x, int *crtc_y, int *crtc_id, bool *is_cursor) {
+        *crtc_x = 0;
+        *crtc_y = 0;
+        *crtc_id = 0;
+        *is_cursor = false;
+
+        uint32_t property_mask = 0;
+
+        drmModeObjectPropertiesPtr props = drmModeObjectGetProperties(drm_fd, plane_id, DRM_MODE_OBJECT_PLANE);
+        if(!props)
+            return property_mask;
+
+        for(uint32_t i = 0; i < props->count_props; ++i) {
+            drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]);
+            if(!prop)
+                continue;
+
+            // SRC_* values are fixed 16.16 points
+            const uint32_t type = prop->flags & (DRM_MODE_PROP_LEGACY_TYPE | DRM_MODE_PROP_EXTENDED_TYPE);
+            if((type & DRM_MODE_PROP_SIGNED_RANGE) && strcmp(prop->name, "CRTC_X") == 0) {
+                *crtc_x = (int)props->prop_values[i];
+                property_mask |= PLANE_PROPERTY_CRTC_X;
+            } else if((type & DRM_MODE_PROP_SIGNED_RANGE) && strcmp(prop->name, "CRTC_Y") == 0) {
+                *crtc_y = (int)props->prop_values[i];
+                property_mask |= PLANE_PROPERTY_CRTC_Y;
+            } else if((type & DRM_MODE_PROP_OBJECT) && strcmp(prop->name, "CRTC_ID") == 0) {
+                *crtc_id = (int)props->prop_values[i];
+                property_mask |= PLANE_PROPERTY_CRTC_ID;
+            } else if((type & DRM_MODE_PROP_ENUM) && strcmp(prop->name, "type") == 0) {
+                const uint64_t current_enum_value = props->prop_values[i];
+                for(int j = 0; j < prop->count_enums; ++j) {
+                    if(prop->enums[j].value == current_enum_value && strcmp(prop->enums[j].name, "Cursor") == 0) {
+                        property_mask |= PLANE_PROPERTY_TYPE_CURSOR;
+                        break;
+                    }
+                }
+            }
+
+            drmModeFreeProperty(prop);
+        }
+
+        drmModeFreeObjectProperties(props);
+        return property_mask;
+    }
+
+    static bool connector_get_property_by_name(int drm_fd, drmModeConnectorPtr props, const char *name, uint64_t *result) {
+        for(int i = 0; i < props->count_props; ++i) {
+            drmModePropertyPtr prop = drmModeGetProperty(drm_fd, props->props[i]);
+            if(!prop)
+                continue;
+
+            if(strcmp(name, prop->name) == 0) {
+                *result = props->prop_values[i];
+                drmModeFreeProperty(prop);
+                return true;
+            }
+            drmModeFreeProperty(prop);
+        }
+        return false;
+    }
+
+    static drm_connector_type_count* drm_connector_types_get_index(drm_connector_type_count *type_counts, int *num_type_counts, int connector_type) {
+        for(int i = 0; i < *num_type_counts; ++i) {
+            if(type_counts[i].type == connector_type)
+                return &type_counts[i];
+        }
+
+        if(*num_type_counts == CONNECTOR_TYPE_COUNTS)
+            return NULL;
+
+        const int index = *num_type_counts;
+        type_counts[index].type = connector_type;
+        type_counts[index].count = 0;
+        ++*num_type_counts;
+        return &type_counts[index];
+    }
+
+    // Note: this monitor name logic is kept in sync with gpu screen recorder
+    static std::string get_monitor_name_from_crtc_id(int drm_fd, uint32_t crtc_id) {
+        std::string result;
+        drmModeResPtr resources = drmModeGetResources(drm_fd);
+        if(!resources)
+            return result;
+
+        drm_connector_type_count type_counts[CONNECTOR_TYPE_COUNTS];
+        int num_type_counts = 0;
+
+        for(int i = 0; i < resources->count_connectors; ++i) {
+            uint64_t connector_crtc_id = 0;
+            drmModeConnectorPtr connector = drmModeGetConnectorCurrent(drm_fd, resources->connectors[i]);
+            if(!connector)
+                continue;
+
+            drm_connector_type_count *connector_type = drm_connector_types_get_index(type_counts, &num_type_counts, connector->connector_type);
+            const char *connection_name = drmModeGetConnectorTypeName(connector->connector_type);
+            if(connector_type)
+                ++connector_type->count;
+
+            if(connector->connection != DRM_MODE_CONNECTED)
+                goto next;
+
+            if(connector_type && connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &connector_crtc_id) && connector_crtc_id == crtc_id) {
+                result = connection_name;
+                result += "-";
+                result += std::to_string(connector_type->count);
+                drmModeFreeConnector(connector);
+                break;
+            }
+
+            next:
+            drmModeFreeConnector(connector);
+        }
+
+        drmModeFreeResources(resources);
+        return result;
+    }
+
+    // Name is the crtc name. TODO: verify if this works on all wayland compositors
+    static const WaylandOutput* get_wayland_monitor_by_name(const std::vector<WaylandOutput> &monitors, const std::string &name) {
+        for(const WaylandOutput &monitor : monitors) {
+            if(monitor.name == name)
+                return &monitor;
+        }
+        return nullptr;
+    }
+
+    static WaylandOutput* get_wayland_monitor_by_output(CursorTrackerWayland &cursor_tracker_wayland, struct wl_output *output) {
+        for(WaylandOutput &monitor : cursor_tracker_wayland.monitors) {
+            if(monitor.output == output)
+                return &monitor;
+        }
+        return nullptr;
+    }
+
+    static void output_handle_geometry(void *data, struct wl_output *wl_output,
+        int32_t x, int32_t y, int32_t phys_width, int32_t phys_height,
+        int32_t subpixel, const char *make, const char *model,
+        int32_t transform) {
+        (void)wl_output;
+        (void)phys_width;
+        (void)phys_height;
+        (void)subpixel;
+        (void)make;
+        (void)model;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        WaylandOutput *monitor = get_wayland_monitor_by_output(*cursor_tracker_wayland, wl_output);
+        if(!monitor)
+            return;
+
+        monitor->pos.x = x;
+        monitor->pos.y = y;
+        monitor->transform = transform;
+    }
+
+    static void output_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
+        (void)wl_output;
+        (void)flags;
+        (void)refresh;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        WaylandOutput *monitor = get_wayland_monitor_by_output(*cursor_tracker_wayland, wl_output);
+        if(!monitor)
+            return;
+
+        monitor->size.x = width;
+        monitor->size.y = height;
+    }
+
+    static void output_handle_done(void *data, struct wl_output *wl_output) {
+        (void)data;
+        (void)wl_output;
+    }
+
+    static void output_handle_scale(void* data, struct wl_output *wl_output, int32_t factor) {
+        (void)data;
+        (void)wl_output;
+        (void)factor;
+    }
+
+    static void output_handle_name(void *data, struct wl_output *wl_output, const char *name) {
+        (void)wl_output;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        WaylandOutput *monitor = get_wayland_monitor_by_output(*cursor_tracker_wayland, wl_output);
+        if(!monitor)
+            return;
+
+        monitor->name = name;
+    }
+
+    static void output_handle_description(void *data, struct wl_output *wl_output, const char *description) {
+        (void)data;
+        (void)wl_output;
+        (void)description;
+    }
+
+    static const struct wl_output_listener output_listener = {
+        output_handle_geometry,
+        output_handle_mode,
+        output_handle_done,
+        output_handle_scale,
+        output_handle_name,
+        output_handle_description,
+    };
+
+    static void registry_add_object(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
+        (void)version;
+        CursorTrackerWayland *cursor_tracker_wayland = (CursorTrackerWayland*)data;
+        if(strcmp(interface, wl_output_interface.name) == 0) {
+            if(version < 4) {
+                fprintf(stderr, "Warning: wl output interface version is < 4, expected >= 4\n");
+                return;
+            }
+
+            struct wl_output *output = (struct wl_output*)wl_registry_bind(registry, name, &wl_output_interface, 4);
+            cursor_tracker_wayland->monitors.push_back(
+                WaylandOutput{
+                    name,
+                    output,
+                    nullptr,
+                    mgl::vec2i{0, 0},
+                    mgl::vec2i{0, 0},
+                    0,
+                    ""
+                });
+            wl_output_add_listener(output, &output_listener, cursor_tracker_wayland);
+        } else if(strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) {
+            if(version < 1) {
+                fprintf(stderr, "Warning: xdg output interface version is < 1, expected >= 1\n");
+                return;
+            }
+
+            if(cursor_tracker_wayland->xdg_output_manager) {
+                zxdg_output_manager_v1_destroy(cursor_tracker_wayland->xdg_output_manager);
+                cursor_tracker_wayland->xdg_output_manager = NULL;
+            }
+            cursor_tracker_wayland->xdg_output_manager = (struct zxdg_output_manager_v1*)wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface, 1);
+        }
+    }
+
+    static void registry_remove_object(void *data, struct wl_registry *registry, uint32_t name) {
+        (void)data;
+        (void)registry;
+        (void)name;
+        // TODO: Remove output
+    }
+
+    static struct wl_registry_listener registry_listener = {
+        registry_add_object,
+        registry_remove_object,
+    };
+
+    static void xdg_output_logical_position(void *data, struct zxdg_output_v1 *zxdg_output_v1, int32_t x, int32_t y) {
+        (void)zxdg_output_v1;
+        WaylandOutput *monitor = (WaylandOutput*)data;
+        monitor->pos.x = x;
+        monitor->pos.y = y;
+    }
+
+    static void xdg_output_handle_logical_size(void *data, struct zxdg_output_v1 *xdg_output, int32_t width, int32_t height) {
+        (void)data;
+        (void)xdg_output;
+        (void)width;
+        (void)height;
+    }
+
+    static void xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output) {
+        (void)data;
+        (void)xdg_output;
+    }
+
+    static void xdg_output_handle_name(void *data, struct zxdg_output_v1 *xdg_output, const char *name) {
+        (void)data;
+        (void)xdg_output;
+        (void)name;
+    }
+
+    static void xdg_output_handle_description(void *data, struct zxdg_output_v1 *xdg_output, const char *description) {
+        (void)data;
+        (void)xdg_output;
+        (void)description;
+    }
+
+    static const struct zxdg_output_v1_listener xdg_output_listener = {
+        xdg_output_logical_position,
+        xdg_output_handle_logical_size,
+        xdg_output_handle_done,
+        xdg_output_handle_name,
+        xdg_output_handle_description,
+    };
+
+    /* Returns nullptr if not found */
+    static const drm_connector* get_drm_connector_by_crtc_id(const drm_connectors *connectors, uint32_t crtc_id) {
+        for(int i = 0; i < connectors->num_connectors; ++i) {
+            if(connectors->connectors[i].crtc_id == crtc_id)
+                return &connectors->connectors[i];
+        }
+        return nullptr;
+    }
+
+    static void get_drm_connectors(int drm_fd, drm_connectors *drm_connectors) {
+        drm_connectors->num_connectors = 0;
+        drmModeResPtr resources = drmModeGetResources(drm_fd);
+        if(!resources)
+            return;
+
+        for(int i = 0; i < resources->count_connectors && drm_connectors->num_connectors < MAX_CONNECTORS; ++i) {
+            drmModeConnectorPtr connector = nullptr;
+            drmModeCrtcPtr crtc = nullptr;
+
+            connector = drmModeGetConnectorCurrent(drm_fd, resources->connectors[i]);
+            if(!connector)
+                continue;
+
+            uint64_t crtc_id = 0;
+            connector_get_property_by_name(drm_fd, connector, "CRTC_ID", &crtc_id);
+            if(crtc_id == 0)
+                goto next;
+
+            crtc = drmModeGetCrtc(drm_fd, crtc_id);
+            if(!crtc)
+                goto next;
+
+            drm_connectors->connectors[drm_connectors->num_connectors].crtc_id = crtc_id;
+            drm_connectors->connectors[drm_connectors->num_connectors].size = mgl::vec2i{(int)crtc->width, (int)crtc->height};
+            ++drm_connectors->num_connectors;
+
+            next:
+            if(crtc)
+                drmModeFreeCrtc(crtc);
+
+            if(connector)
+                drmModeFreeConnector(connector);
+        }
+        drmModeFreeResources(resources);
+    }
+
+    CursorTrackerWayland::CursorTrackerWayland(const char *card_path) {
+        drm_fd = open(card_path, O_RDONLY);
+        if(drm_fd <= 0) {
+            fprintf(stderr, "Error: CursorTrackerWayland: failed to open %s\n", card_path);
+            return;
+        }
+
+        drmSetClientCap(drm_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
+        drmSetClientCap(drm_fd, DRM_CLIENT_CAP_ATOMIC, 1);
+    }
+
+    CursorTrackerWayland::~CursorTrackerWayland() {
+        if(drm_fd > 0)
+            close(drm_fd);
+    }
+
+    void CursorTrackerWayland::update() {
+        if(drm_fd <= 0)
+            return;
+
+        drm_connectors connectors;
+        connectors.num_connectors = 0;
+        get_drm_connectors(drm_fd, &connectors);
+
+        drmModePlaneResPtr planes = drmModeGetPlaneResources(drm_fd);
+        if(!planes)
+            return;
+
+        for(uint32_t i = 0; i < planes->count_planes; ++i) {
+            drmModePlanePtr plane = nullptr;
+            const drm_connector *connector = nullptr;
+            int crtc_x = 0;
+            int crtc_y = 0;
+            int crtc_id = 0;
+            bool is_cursor = false;
+            uint32_t property_mask = 0;
+
+            plane = drmModeGetPlane(drm_fd, planes->planes[i]);
+            if(!plane)
+                goto next;
+
+            if(!plane->fb_id)
+                goto next;
+
+            property_mask = plane_get_properties(drm_fd, planes->planes[i], &crtc_x, &crtc_y, &crtc_id, &is_cursor);
+            if(property_mask != plane_property_all || crtc_id <= 0)
+                goto next;
+
+            connector = get_drm_connector_by_crtc_id(&connectors, crtc_id);
+            if(!connector)
+                goto next;
+
+            if(crtc_x >= 0 && crtc_x <= connector->size.x && crtc_y >= 0 && crtc_y <= connector->size.y) {
+                latest_cursor_position.x = crtc_x;
+                latest_cursor_position.y = crtc_y;
+                latest_crtc_id = crtc_id;
+                drmModeFreePlane(plane);
+                break;
+            }
+
+            next:
+            drmModeFreePlane(plane);
+        }
+
+        drmModeFreePlaneResources(planes);
+    }
+
+    void CursorTrackerWayland::set_monitor_outputs_from_xdg_output(struct wl_display *dpy) {
+        if(!xdg_output_manager) {
+            fprintf(stderr, "Warning: CursorTrackerWayland::set_monitor_outputs_from_xdg_output: zxdg_output_manager not found. Registered monitor positions might be incorrect\n");
+            return;
+        }
+
+        for(WaylandOutput &monitor : monitors) {
+            monitor.xdg_output = zxdg_output_manager_v1_get_xdg_output(xdg_output_manager, monitor.output);
+            zxdg_output_v1_add_listener(monitor.xdg_output, &xdg_output_listener, &monitor);
+        }
+
+        // Fetch xdg_output
+        wl_display_roundtrip(dpy);
+    }
+
+    std::optional<CursorInfo> CursorTrackerWayland::get_latest_cursor_info() {
+        if(drm_fd <= 0 || latest_crtc_id == -1)
+            return std::nullopt;
+
+        std::string monitor_name = get_monitor_name_from_crtc_id(drm_fd, latest_crtc_id);
+        if(monitor_name.empty())
+            return std::nullopt;
+
+        struct wl_display *dpy = wl_display_connect(nullptr);
+        if(!dpy) {
+            fprintf(stderr, "Error: CursorTrackerWayland::get_latest_cursor_info: failed to connect to the wayland server\n");
+            return std::nullopt;
+        }
+
+        monitors.clear();
+        struct wl_registry *registry = wl_display_get_registry(dpy);
+        wl_registry_add_listener(registry, &registry_listener, this);
+
+        // Fetch globals
+        wl_display_roundtrip(dpy);
+
+        // Fetch wl_output
+        wl_display_roundtrip(dpy);
+
+        set_monitor_outputs_from_xdg_output(dpy);
+
+        mgl::vec2i cursor_position = latest_cursor_position;
+        const WaylandOutput *wayland_monitor = get_wayland_monitor_by_name(monitors, monitor_name);
+        if(!wayland_monitor)
+            return std::nullopt;
+
+        cursor_position = wayland_monitor->pos + latest_cursor_position;
+        for(WaylandOutput &monitor : monitors) {
+            if(monitor.output) {
+                wl_output_destroy(monitor.output);
+                monitor.output = nullptr;
+            }
+
+            if(monitor.xdg_output) {
+                zxdg_output_v1_destroy(monitor.xdg_output);
+                monitor.xdg_output = nullptr;
+            }
+        }
+        monitors.clear();
+
+        if(xdg_output_manager) {
+            zxdg_output_manager_v1_destroy(xdg_output_manager);
+            xdg_output_manager = nullptr;
+        }
+
+        wl_registry_destroy(registry);
+        wl_display_disconnect(dpy);
+
+        return CursorInfo{ cursor_position, std::move(monitor_name) };
+    }
+}
\ No newline at end of file
diff --git a/src/CursorTrackerX11.cpp b/src/CursorTrackerX11.cpp
new file mode 100644
index 0000000..7c40cea
--- /dev/null
+++ b/src/CursorTrackerX11.cpp
@@ -0,0 +1,29 @@
+#include "../include/CursorTrackerX11.hpp"
+#include "../include/WindowUtils.hpp"
+
+namespace gsr {
+    CursorTrackerX11::CursorTrackerX11(Display *dpy) : dpy(dpy) {
+        
+    }
+
+    std::optional<CursorInfo> CursorTrackerX11::get_latest_cursor_info() {
+        Window window = None;
+        const auto cursor_pos = get_cursor_position(dpy, &window);
+        const auto monitors = get_monitors(dpy);
+        std::string monitor_name;
+
+        for(const auto &monitor : monitors) {
+            if(cursor_pos.x >= monitor.position.x && cursor_pos.x <= monitor.position.x + monitor.size.x
+                && cursor_pos.y >= monitor.position.y && cursor_pos.y <= monitor.position.y + monitor.size.y)
+            {
+                monitor_name = monitor.name;
+                break;
+            }
+        }
+
+        if(monitor_name.empty())
+            return std::nullopt;
+
+        return CursorInfo{ cursor_pos, std::move(monitor_name) };
+    }
+}
\ No newline at end of file
diff --git a/src/GlobalHotkeysLinux.cpp b/src/GlobalHotkeysLinux.cpp
index fbba0ea..d780916 100644
--- a/src/GlobalHotkeysLinux.cpp
+++ b/src/GlobalHotkeysLinux.cpp
@@ -1,5 +1,4 @@
 #include "../include/GlobalHotkeysLinux.hpp"
-#include <signal.h>
 #include <sys/wait.h>
 #include <fcntl.h>
 #include <limits.h>
@@ -71,21 +70,41 @@ namespace gsr {
     }
 
     GlobalHotkeysLinux::~GlobalHotkeysLinux() {
+        if(write_pipes[PIPE_WRITE] > 0) {
+            char command[32];
+            const int command_size = snprintf(command, sizeof(command), "exit\n");
+            if(write(write_pipes[PIPE_WRITE], command, command_size) != command_size) {
+                fprintf(stderr, "Error: GlobalHotkeysLinux::~GlobalHotkeysLinux: failed to write command to gsr-global-hotkeys, error: %s\n", strerror(errno));
+                close_fds();
+            }
+        } else {
+            close_fds();
+        }
+
+        if(process_id > 0) {
+            int status;
+            waitpid(process_id, &status, 0);
+        }
+
+        close_fds();
+    }
+
+    void GlobalHotkeysLinux::close_fds() {
         for(int i = 0; i < 2; ++i) {
-            if(read_pipes[i] > 0)
+            if(read_pipes[i] > 0) {
                 close(read_pipes[i]);
+                read_pipes[i] = -1;
+            }
 
-            if(write_pipes[i] > 0)
+            if(write_pipes[i] > 0) {
                 close(write_pipes[i]);
+                write_pipes[i] = -1;
+            }
         }
 
-        if(read_file)
+        if(read_file) {
             fclose(read_file);
-
-        if(process_id > 0) {
-            kill(process_id, SIGKILL);
-            int status;
-            waitpid(process_id, &status, 0);
+            read_file = nullptr;
         }
     }
 
diff --git a/src/GsrInfo.cpp b/src/GsrInfo.cpp
index 5af6397..d7212d7 100644
--- a/src/GsrInfo.cpp
+++ b/src/GsrInfo.cpp
@@ -175,11 +175,6 @@ namespace gsr {
         CAPTURE_OPTIONS
     };
 
-    static bool starts_with(std::string_view str, const char *substr) {
-        size_t len = strlen(substr);
-        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
-    }
-
     GsrInfoExitStatus get_gpu_screen_recorder_info(GsrInfo *gsr_info) {
         *gsr_info = GsrInfo{};
 
diff --git a/src/Overlay.cpp b/src/Overlay.cpp
index 4eb8844..53f9eae 100644
--- a/src/Overlay.cpp
+++ b/src/Overlay.cpp
@@ -14,6 +14,8 @@
 #include "../include/WindowUtils.hpp"
 #include "../include/GlobalHotkeys.hpp"
 #include "../include/GlobalHotkeysLinux.hpp"
+#include "../include/CursorTrackerX11.hpp"
+#include "../include/CursorTrackerWayland.hpp"
 
 #include <string.h>
 #include <assert.h>
@@ -47,6 +49,7 @@ namespace gsr {
     static const double replay_saving_notification_timeout_seconds = 0.5;
     static const double notification_timeout_seconds = 2.0;
     static const double notification_error_timeout_seconds = 5.0;
+    static const double cursor_tracker_update_timeout_sec = 0.1;
 
     static mgl::Texture texture_from_ximage(XImage *img) {
         uint8_t *texture_data = (uint8_t*)malloc(img->width * img->height * 3);
@@ -214,6 +217,16 @@ namespace gsr {
         return &monitors.front();
     }
 
+    // Returns the first monitor if not found. Assumes there is at least one monitor connected.
+    static const Monitor* find_monitor_by_name(const std::vector<Monitor> &monitors, const std::string &name) {
+        assert(!monitors.empty());
+        for(const Monitor &monitor : monitors) {
+            if(monitor.name == name)
+                return &monitor;
+        }
+        return &monitors.front();
+    }
+
     static std::string get_power_supply_online_filepath() {
         std::string result;
         const char *paths[] = {
@@ -325,6 +338,13 @@ namespace gsr {
                 fprintf(stderr, "pressed %s\n", id.c_str());
                 overlay->take_screenshot_region();
             });
+
+        global_hotkeys->bind_key_press(
+            config_hotkey_to_hotkey(ConfigHotkey{ mgl::Keyboard::Key::Escape, HOTKEY_MOD_LCTRL | HOTKEY_MOD_LSHIFT | HOTKEY_MOD_LALT }),
+            "exit", [overlay](const std::string &id) {
+                fprintf(stderr, "pressed %s\n", id.c_str());
+                overlay->go_back_to_old_ui();
+            });
     }
 
     static std::unique_ptr<GlobalHotkeysLinux> register_linux_hotkeys(Overlay *overlay, GlobalHotkeysLinux::GrabType grab_type) {
@@ -411,6 +431,11 @@ namespace gsr {
             XKeysymToKeycode(x11_mapping_display, XK_F1); // If we dont call we will never get a MappingNotify
         else
             fprintf(stderr, "Warning: XOpenDisplay failed to mapping notify\n");
+
+        if(this->gsr_info.system_info.display_server == DisplayServer::X11)
+            cursor_tracker = std::make_unique<CursorTrackerX11>((Display*)mgl_get_context()->connection);
+        else if(this->gsr_info.system_info.display_server == DisplayServer::WAYLAND && !this->gsr_info.gpu_info.card_path.empty())
+            cursor_tracker = std::make_unique<CursorTrackerWayland>(this->gsr_info.gpu_info.card_path.c_str());
     }
 
     Overlay::~Overlay() {
@@ -531,8 +556,8 @@ namespace gsr {
                     memset(xi_output_xev, 0, sizeof(*xi_output_xev));
                     xi_output_xev->type = MotionNotify;
                     xi_output_xev->xmotion.display = display;
-                    xi_output_xev->xmotion.window = window->get_system_handle();
-                    xi_output_xev->xmotion.subwindow = window->get_system_handle();
+                    xi_output_xev->xmotion.window = (Window)window->get_system_handle();
+                    xi_output_xev->xmotion.subwindow = (Window)window->get_system_handle();
                     xi_output_xev->xmotion.x = de->root_x - window_pos.x;
                     xi_output_xev->xmotion.y = de->root_y - window_pos.y;
                     xi_output_xev->xmotion.x_root = de->root_x;
@@ -544,8 +569,8 @@ namespace gsr {
                     memset(xi_output_xev, 0, sizeof(*xi_output_xev));
                     xi_output_xev->type = cookie->evtype == XI_ButtonPress ? ButtonPress : ButtonRelease;
                     xi_output_xev->xbutton.display = display;
-                    xi_output_xev->xbutton.window = window->get_system_handle();
-                    xi_output_xev->xbutton.subwindow = window->get_system_handle();
+                    xi_output_xev->xbutton.window = (Window)window->get_system_handle();
+                    xi_output_xev->xbutton.subwindow = (Window)window->get_system_handle();
                     xi_output_xev->xbutton.x = de->root_x - window_pos.x;
                     xi_output_xev->xbutton.y = de->root_y - window_pos.y;
                     xi_output_xev->xbutton.x_root = de->root_x;
@@ -558,8 +583,8 @@ namespace gsr {
                     memset(xi_output_xev, 0, sizeof(*xi_output_xev));
                     xi_output_xev->type = cookie->evtype == XI_KeyPress ? KeyPress : KeyRelease;
                     xi_output_xev->xkey.display = display;
-                    xi_output_xev->xkey.window = window->get_system_handle();
-                    xi_output_xev->xkey.subwindow = window->get_system_handle();
+                    xi_output_xev->xkey.window = (Window)window->get_system_handle();
+                    xi_output_xev->xkey.subwindow = (Window)window->get_system_handle();
                     xi_output_xev->xkey.x = de->root_x - window_pos.x;
                     xi_output_xev->xkey.y = de->root_y - window_pos.y;
                     xi_output_xev->xkey.x_root = de->root_x;
@@ -617,6 +642,12 @@ namespace gsr {
         if(global_hotkeys_js)
             global_hotkeys_js->poll_events();
 
+        if(cursor_tracker_update_clock.get_elapsed_time_seconds() >= cursor_tracker_update_timeout_sec) {
+            cursor_tracker_update_clock.restart();
+            if(cursor_tracker)
+                cursor_tracker->update();
+        }
+
         handle_keyboard_mapping_event();
         region_selector.poll_events();
         if(region_selector.take_canceled()) {
@@ -654,6 +685,8 @@ namespace gsr {
     }
 
     bool Overlay::draw() {
+        remove_widgets_to_be_removed();
+
         update_notification_process_status();
         update_gsr_replay_save();
         update_gsr_process_status();
@@ -734,13 +767,13 @@ namespace gsr {
         // There should be a debug mode to not use these
         mgl_context *context = mgl_get_context();
         Display *display = (Display*)context->connection;
-        XGrabPointer(display, window->get_system_handle(), True,
+        XGrabPointer(display, (Window)window->get_system_handle(), True,
             ButtonPressMask | ButtonReleaseMask | PointerMotionMask |
             Button1MotionMask | Button2MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask |
             ButtonMotionMask,
             GrabModeAsync, GrabModeAsync, None, default_cursor, CurrentTime);
         // TODO: This breaks global hotkeys (when using x11 global hotkeys)
-        XGrabKeyboard(display, window->get_system_handle(), True, GrabModeAsync, GrabModeAsync, CurrentTime);
+        XGrabKeyboard(display, (Window)window->get_system_handle(), True, GrabModeAsync, GrabModeAsync, CurrentTime);
         XFlush(display);
     }
 
@@ -825,12 +858,23 @@ namespace gsr {
         const bool is_kwin = wm_name == "KWin";
         const bool is_wlroots = wm_name.find("wlroots") != std::string::npos;
 
+        std::optional<CursorInfo> cursor_info;
+        if(cursor_tracker) {
+            cursor_tracker->update();
+            cursor_info = cursor_tracker->get_latest_cursor_info();
+        }
+
         // The cursor position is wrong on wayland if an x11 window is not focused. On wayland we instead create a window and get the position where the wayland compositor puts it
         Window x11_cursor_window = None;
-        const mgl::vec2i cursor_position = get_cursor_position(display, &x11_cursor_window);
-        const mgl::vec2i monitor_position_query_value = (x11_cursor_window || gsr_info.system_info.display_server != DisplayServer::WAYLAND) ? cursor_position : create_window_get_center_position(display);
-
-        const Monitor *focused_monitor = find_monitor_at_position(monitors, monitor_position_query_value);
+        mgl::vec2i cursor_position = get_cursor_position(display, &x11_cursor_window);
+        const Monitor *focused_monitor = nullptr;
+        if(cursor_info) {
+            focused_monitor = find_monitor_by_name(monitors, cursor_info->monitor_name);
+            cursor_position = cursor_info->position;
+        } else {
+            const mgl::vec2i monitor_position_query_value = (x11_cursor_window || gsr_info.system_info.display_server != DisplayServer::WAYLAND) ? cursor_position : create_window_get_center_position(display);
+            focused_monitor = find_monitor_at_position(monitors, monitor_position_query_value);
+        }
 
         // Wayland doesn't allow XGrabPointer/XGrabKeyboard when a wayland application is focused.
         // If the focused window is a wayland application then don't use override redirect and instead create
@@ -863,7 +907,7 @@ namespace gsr {
         // Nvidia + Wayland + Egl doesn't work on some systems properly and it instead falls back to software rendering.
         // Use Glx on Wayland to workaround this issue. This is fine since Egl is only needed for x11 to reliably get the texture of the fullscreen window on Nvidia
         // when a compositor isn't running.
-        window_create_params.render_api = gsr_info.system_info.display_server == DisplayServer::WAYLAND ? MGL_RENDER_API_GLX : MGL_RENDER_API_EGL;
+        window_create_params.graphics_api = gsr_info.system_info.display_server == DisplayServer::WAYLAND ? MGL_GRAPHICS_API_GLX : MGL_GRAPHICS_API_EGL;
 
         if(!window->create("gsr ui", window_create_params))
             fprintf(stderr, "error: failed to create window\n");
@@ -871,10 +915,10 @@ namespace gsr {
         //window->set_low_latency(true);
 
         unsigned char data = 2; // Prefer being composed to allow transparency
-        XChangeProperty(display, window->get_system_handle(), XInternAtom(display, "_NET_WM_BYPASS_COMPOSITOR", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
+        XChangeProperty(display, (Window)window->get_system_handle(), XInternAtom(display, "_NET_WM_BYPASS_COMPOSITOR", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
 
         data = 1;
-        XChangeProperty(display, window->get_system_handle(), XInternAtom(display, "GAMESCOPE_EXTERNAL_OVERLAY", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
+        XChangeProperty(display, (Window)window->get_system_handle(), XInternAtom(display, "GAMESCOPE_EXTERNAL_OVERLAY", False), XA_CARDINAL, 32, PropModeReplace, &data, 1);
 
         const auto original_window_size = window_size;
         window_pos = focused_monitor->position;
@@ -908,12 +952,12 @@ namespace gsr {
 
         //window->set_fullscreen(true);
         if(gsr_info.system_info.display_server == DisplayServer::X11)
-            make_window_click_through(display, window->get_system_handle());
+            make_window_click_through(display, (Window)window->get_system_handle());
 
         window->set_visible(true);
 
-        make_window_sticky(display, window->get_system_handle());
-        hide_window_from_taskbar(display, window->get_system_handle());
+        make_window_sticky(display, (Window)window->get_system_handle());
+        hide_window_from_taskbar(display, (Window)window->get_system_handle());
 
         if(default_cursor) {
             XFreeCursor(display, default_cursor);
@@ -925,7 +969,12 @@ namespace gsr {
         grab_mouse_and_keyboard();
 
         // The real cursor doesn't move when all devices are grabbed, so we create our own cursor and diplay that while grabbed
+        cursor_hotspot = {0, 0};
         xi_setup_fake_cursor();
+        if(cursor_info && gsr_info.system_info.display_server == DisplayServer::WAYLAND) {
+            win->cursor_position.x += cursor_hotspot.x;
+            win->cursor_position.y += cursor_hotspot.y;
+        }
 
         // We want to grab all devices to prevent any other application below the UI from receiving events.
         // Owlboy seems to use xi events and XGrabPointer doesn't prevent owlboy from receiving events.
@@ -1202,6 +1251,7 @@ namespace gsr {
         while(!page_stack.empty()) {
             page_stack.pop();
         }
+        remove_widgets_to_be_removed();
 
         if(default_cursor) {
             XFreeCursor(display, default_cursor);
@@ -1337,26 +1387,73 @@ namespace gsr {
         return nullptr;
     }
 
-    void Overlay::show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type) {
+    static bool is_hex_num(char c) {
+        return (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') || (c >= '0' && c <= '9');
+    }
+
+    static bool contains_non_hex_number(const char *str) {
+        bool hex_start = false;
+        size_t len = strlen(str);
+        if(len >= 2 && memcmp(str, "0x", 2) == 0) {
+            str += 2;
+            len -= 2;
+            hex_start = true;
+        }
+
+        bool is_hex = false;
+        for(size_t i = 0; i < len; ++i) {
+            char c = str[i];
+            if(c == '\0')
+                return false;
+            if(!is_hex_num(c))
+                return true;
+            if((c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'))
+                is_hex = true;
+        }
+
+        return is_hex && !hex_start;
+    }
+
+    static bool is_capture_target_monitor(const char *capture_target) {
+        return strcmp(capture_target, "focused") != 0 && strcmp(capture_target, "region") != 0 && strcmp(capture_target, "portal") != 0 && contains_non_hex_number(capture_target);
+    }
+
+    void Overlay::show_notification(const char *str, double timeout_seconds, mgl::Color icon_color, mgl::Color bg_color, NotificationType notification_type, const char *capture_target) {
         char timeout_seconds_str[32];
         snprintf(timeout_seconds_str, sizeof(timeout_seconds_str), "%f", timeout_seconds);
 
         const std::string icon_color_str = color_to_hex_str(icon_color);
         const std::string bg_color_str = color_to_hex_str(bg_color);
-        const char *notification_args[12] = {
+        const char *notification_args[14] = {
             "gsr-notify", "--text", str, "--timeout", timeout_seconds_str,
             "--icon-color", icon_color_str.c_str(), "--bg-color", bg_color_str.c_str(),
         };
 
+        int arg_index = 9;
         const char *notification_type_str = notification_type_to_string(notification_type);
         if(notification_type_str) {
-            notification_args[9] = "--icon";
-            notification_args[10] = notification_type_str;
-            notification_args[11] = nullptr;
+            notification_args[arg_index++] = "--icon";
+            notification_args[arg_index++] = notification_type_str;
+        }
+
+        if(capture_target && is_capture_target_monitor(capture_target)) {
+            notification_args[arg_index++] = "--monitor";
+            notification_args[arg_index++] = capture_target;
         } else {
-            notification_args[9] = nullptr;
+            std::optional<CursorInfo> cursor_info;
+            if(cursor_tracker) {
+                cursor_tracker->update();
+                cursor_info = cursor_tracker->get_latest_cursor_info();
+            }
+
+            if(cursor_info) {
+                notification_args[arg_index++] = "--monitor";
+                notification_args[arg_index++] = cursor_info->monitor_name.c_str();
+            }
         }
 
+        notification_args[arg_index++] = nullptr;
+
         if(notification_process > 0) {
             kill(notification_process, SIGKILL);
             int status = 0;
@@ -1381,6 +1478,19 @@ namespace gsr {
         do_exit = true;
     }
 
+    void Overlay::go_back_to_old_ui() {
+        const bool inside_flatpak = getenv("FLATPAK_ID") != NULL;
+        if(inside_flatpak)
+            exit_reason = "back-to-old-ui";
+        else
+            exit_reason = "exit";
+
+        const char *args[] = { "systemctl", "disable", "--user", "gpu-screen-recorder-ui", nullptr };
+        std::string stdout_str;
+        exec_program_on_host_get_stdout(args, stdout_str);
+        exit();
+    }
+
     const Config& Overlay::get_config() const {
         return config;
     }
@@ -1447,7 +1557,7 @@ namespace gsr {
         Display *display = (Display*)context->connection;
         const std::string video_filename = filepath_get_filename(video_filepath);
 
-        const Window gsr_ui_window = window ? window->get_system_handle() : None;
+        const Window gsr_ui_window = window ? (Window)window->get_system_handle() : None;
         std::string focused_window_name = get_window_name_at_cursor_position(display, gsr_ui_window);
         if(focused_window_name.empty())
             focused_window_name = get_focused_window_name(display, WindowCaptureType::FOCUSED);
@@ -1463,31 +1573,52 @@ namespace gsr {
         rename(video_filepath, new_video_filepath.c_str());
 
         truncate_string(focused_window_name, 20);
-        std::string text;
+        const char *capture_target = nullptr;
+        char msg[512];
+        const std::string filename = focused_window_name + "/" + video_filename;
+
         switch(notification_type) {
             case NotificationType::RECORD: {
                 if(!config.record_config.show_video_saved_notifications)
                     return;
-                text = "Saved recording to '" + focused_window_name + "/" + video_filename + "'";
+
+                if(is_capture_target_monitor(recording_capture_target.c_str()))
+                    snprintf(msg, sizeof(msg), "Saved a recording of this monitor to '%s'", filename.c_str());
+                else
+                    snprintf(msg, sizeof(msg), "Saved a recording of %s to '%s'", recording_capture_target.c_str(), filename.c_str());
+
+                capture_target = recording_capture_target.c_str();
                 break;
             }
             case NotificationType::REPLAY: {
                 if(!config.replay_config.show_replay_saved_notifications)
                     return;
-                text = "Saved replay to '" + focused_window_name + "/" + video_filename + "'";
+
+                if(is_capture_target_monitor(replay_capture_target.c_str()))
+                    snprintf(msg, sizeof(msg), "Saved a replay of this monitor to '%s'", filename.c_str());
+                else
+                    snprintf(msg, sizeof(msg), "Saved a replay of %s to '%s'", replay_capture_target.c_str(), filename.c_str());
+
+                capture_target = replay_capture_target.c_str();
                 break;
             }
             case NotificationType::SCREENSHOT: {
                 if(!config.screenshot_config.show_screenshot_saved_notifications)
                     return;
-                text = "Saved screenshot to '" + focused_window_name + "/" + video_filename + "'";
+
+                if(is_capture_target_monitor(screenshot_capture_target.c_str()))
+                    snprintf(msg, sizeof(msg), "Saved a screenshot of this monitor to '%s'", filename.c_str());
+                else
+                    snprintf(msg, sizeof(msg), "Saved a screenshot of %s to '%s'", screenshot_capture_target.c_str(), filename.c_str());
+
+                capture_target = screenshot_capture_target.c_str();
                 break;
             }
             case NotificationType::NONE:
             case NotificationType::STREAM:
                 break;
         }
-        show_notification(text.c_str(), notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, notification_type);
+        show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, notification_type, capture_target);
     }
 
     void Overlay::on_replay_saved(const char *replay_saved_filepath) {
@@ -1495,8 +1626,13 @@ namespace gsr {
         if(config.replay_config.save_video_in_game_folder) {
             save_video_in_current_game_directory(replay_saved_filepath, NotificationType::REPLAY);
         } else {
-            const std::string text = "Saved replay to '" + filepath_get_filename(replay_saved_filepath) + "'";
-            show_notification(text.c_str(), notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::REPLAY);
+            const std::string filename = filepath_get_filename(replay_saved_filepath);
+            char msg[512];
+            if(is_capture_target_monitor(replay_capture_target.c_str()))
+                snprintf(msg, sizeof(msg), "Saved a replay of this monitor to '%s'", filename.c_str());
+            else
+                snprintf(msg, sizeof(msg), "Saved a replay of %s to '%s'", replay_capture_target.c_str(), filename.c_str());
+            show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::REPLAY, replay_capture_target.c_str());
         }
     }
 
@@ -1593,8 +1729,13 @@ namespace gsr {
             if(config.screenshot_config.save_screenshot_in_game_folder) {
                 save_video_in_current_game_directory(screenshot_filepath.c_str(), NotificationType::SCREENSHOT);
             } else {
-                const std::string text = "Saved screenshot to '" + filepath_get_filename(screenshot_filepath.c_str()) + "'";
-                show_notification(text.c_str(), notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::SCREENSHOT);
+                const std::string filename = filepath_get_filename(screenshot_filepath.c_str());
+                char msg[512];
+                if(is_capture_target_monitor(screenshot_capture_target.c_str()))
+                    snprintf(msg, sizeof(msg), "Saved a screenshot of this monitor to '%s'", filename.c_str());
+                else
+                    snprintf(msg, sizeof(msg), "Saved a screenshot of %s to '%s'", screenshot_capture_target.c_str(), filename.c_str());
+                show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::SCREENSHOT, screenshot_capture_target.c_str());
             }
         } else {
             fprintf(stderr, "Warning: gpu-screen-recorder (%d) exited with exit status %d\n", (int)gpu_screen_recorder_screenshot_process, exit_code);
@@ -1604,28 +1745,25 @@ namespace gsr {
         gpu_screen_recorder_screenshot_process = -1;
     }
 
-    static bool starts_with(std::string_view str, const char *substr) {
-        size_t len = strlen(substr);
-        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
-    }
-
-    static bool are_all_audio_tracks_available_to_capture(const std::vector<std::string> &audio_tracks) {
+    static bool are_all_audio_tracks_available_to_capture(const std::vector<AudioTrack> &audio_tracks) {
         const auto audio_devices = get_audio_devices();
-        for(const std::string &audio_track : audio_tracks) {
-            std::string_view audio_track_name(audio_track.c_str());
-            const bool is_app_audio = starts_with(audio_track_name, "app:");
-            if(is_app_audio)
-                continue;
+        for(const AudioTrack &audio_track : audio_tracks) {
+            for(const std::string &audio_input : audio_track.audio_inputs) {
+                std::string_view audio_track_name(audio_input.c_str());
+                const bool is_app_audio = starts_with(audio_track_name, "app:");
+                if(is_app_audio)
+                    continue;
 
-            if(starts_with(audio_track_name, "device:"))
-                audio_track_name.remove_prefix(7);
+                if(starts_with(audio_track_name, "device:"))
+                    audio_track_name.remove_prefix(7);
 
-            auto it = std::find_if(audio_devices.begin(), audio_devices.end(), [&](const auto &audio_device) {
-                return audio_device.name == audio_track_name;
-            });
-            if(it == audio_devices.end()) {
-                //fprintf(stderr, "Audio not ready\n");
-                return false;
+                auto it = std::find_if(audio_devices.begin(), audio_devices.end(), [&](const auto &audio_device) {
+                    return audio_device.name == audio_track_name;
+                });
+                if(it == audio_devices.end()) {
+                    //fprintf(stderr, "Audio not ready\n");
+                    return false;
+                }
             }
         }
         return true;
@@ -1649,14 +1787,14 @@ namespace gsr {
         Display *display = (Display*)context->connection;
 
         const Window focused_window = get_focused_window(display, WindowCaptureType::FOCUSED);
-        if(window && focused_window == window->get_system_handle())
+        if(window && focused_window == (Window)window->get_system_handle())
             return;
 
         const bool prev_focused_window_is_fullscreen = focused_window_is_fullscreen;
         focused_window_is_fullscreen = focused_window != 0 && window_is_fullscreen(display, focused_window);
         if(focused_window_is_fullscreen != prev_focused_window_is_fullscreen) {
             if(recording_status == RecordingStatus::NONE && focused_window_is_fullscreen) {
-                if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks))
+                if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks_list))
                     on_press_start_replay(false, false);
             } else if(recording_status == RecordingStatus::REPLAY && !focused_window_is_fullscreen) {
                 on_press_start_replay(true, false);
@@ -1673,7 +1811,7 @@ namespace gsr {
         power_supply_connected = power_supply_online_filepath.empty() || power_supply_is_connected(power_supply_online_filepath.c_str());
         if(power_supply_connected != prev_power_supply_status) {
             if(recording_status == RecordingStatus::NONE && power_supply_connected) {
-                if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks))
+                if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks_list))
                     on_press_start_replay(false, false);
             } else if(recording_status == RecordingStatus::REPLAY && !power_supply_connected) {
                 on_press_start_replay(false, false);
@@ -1685,7 +1823,7 @@ namespace gsr {
         if(replay_startup_mode != ReplayStartupMode::TURN_ON_AT_SYSTEM_STARTUP || recording_status != RecordingStatus::NONE || !try_replay_startup)
             return;
 
-        if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks))
+        if(are_all_audio_tracks_available_to_capture(config.replay_config.record_options.audio_tracks_list))
             on_press_start_replay(true, false);
     }
 
@@ -1694,8 +1832,13 @@ namespace gsr {
             if(config.record_config.save_video_in_game_folder) {
                 save_video_in_current_game_directory(record_filepath.c_str(), NotificationType::RECORD);
             } else {
-                const std::string text = "Saved recording to '" + filepath_get_filename(record_filepath.c_str()) + "'";
-                show_notification(text.c_str(), notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD);
+                const std::string filename = filepath_get_filename(record_filepath.c_str());
+                char msg[512];
+                if(is_capture_target_monitor(recording_capture_target.c_str()))
+                    snprintf(msg, sizeof(msg), "Saved a recording of this monitor to '%s'", filename.c_str());
+                else
+                    snprintf(msg, sizeof(msg), "Saved a recording of %s to '%s'", recording_capture_target.c_str(), filename.c_str());
+                show_notification(msg, notification_timeout_seconds, mgl::Color(255, 255, 255), get_color_theme().tint_color, NotificationType::RECORD, recording_capture_target.c_str());
             }
         } else {
             fprintf(stderr, "Warning: gpu-screen-recorder (%d) exited with exit status %d\n", (int)gpu_screen_recorder_process, exit_code);
@@ -1804,29 +1947,31 @@ namespace gsr {
             return container;
     }
 
-    static std::vector<std::string> create_audio_tracks_real_names(const std::vector<std::string> &audio_tracks, bool application_audio_invert, const GsrInfo &gsr_info) {
+    static std::vector<std::string> create_audio_tracks_cli_args(const std::vector<AudioTrack> &audio_tracks, const GsrInfo &gsr_info) {
         std::vector<std::string> result;
-        for(const std::string &audio_track : audio_tracks) {
-            std::string audio_track_name = audio_track;
-            const bool is_app_audio = starts_with(audio_track_name, "app:");
-            if(is_app_audio && !gsr_info.system_info.supports_app_audio)
-                continue;
+        result.reserve(audio_tracks.size());
+
+        for(const AudioTrack &audio_track : audio_tracks) {
+            std::string audio_track_merged;
+            for(const std::string &audio_input_name : audio_track.audio_inputs) {
+                std::string new_audio_input_name = audio_input_name;
+                const bool is_app_audio = starts_with(new_audio_input_name, "app:");
+                if(is_app_audio && !gsr_info.system_info.supports_app_audio)
+                    continue;
 
-            if(is_app_audio && application_audio_invert)
-                audio_track_name.replace(0, 4, "app-inverse:");
+                if(is_app_audio && audio_track.application_audio_invert)
+                    new_audio_input_name.replace(0, 4, "app-inverse:");
 
-            result.push_back(std::move(audio_track_name));
-        }
-        return result;
-    }
+                if(!audio_track_merged.empty())
+                    audio_track_merged += "|";
 
-    static std::string merge_audio_tracks(const std::vector<std::string> &audio_tracks) {
-        std::string result;
-        for(size_t i = 0; i < audio_tracks.size(); ++i) {
-            if(i > 0)
-                result += "|";
-            result += audio_tracks[i];
+                audio_track_merged += new_audio_input_name;
+            }
+
+            if(!audio_track_merged.empty())
+                result.push_back(std::move(audio_track_merged));
         }
+
         return result;
     }
 
@@ -1841,7 +1986,7 @@ namespace gsr {
         args.push_back(region_str);
     }
 
-    static void add_common_gpu_screen_recorder_args(std::vector<const char*> &args, const RecordOptions &record_options, const std::vector<std::string> &audio_tracks, const std::string &video_bitrate, const char *region, const std::string &audio_devices_merged, char *region_str, int region_str_size, const RegionSelector &region_selector) {
+    static void add_common_gpu_screen_recorder_args(std::vector<const char*> &args, const RecordOptions &record_options, const std::vector<std::string> &audio_tracks, const std::string &video_bitrate, const char *region, char *region_str, int region_str_size, const RegionSelector &region_selector) {
         if(record_options.video_quality == "custom") {
             args.push_back("-bm");
             args.push_back("cbr");
@@ -1857,16 +2002,9 @@ namespace gsr {
             args.push_back(region);
         }
 
-        if(record_options.merge_audio_tracks) {
-            if(!audio_devices_merged.empty()) {
-                args.push_back("-a");
-                args.push_back(audio_devices_merged.c_str());
-            }
-        } else {
-            for(const std::string &audio_track : audio_tracks) {
-                args.push_back("-a");
-                args.push_back(audio_track.c_str());
-            }
+        for(const std::string &audio_track : audio_tracks) {
+            args.push_back("-a");
+            args.push_back(audio_track.c_str());
         }
 
         if(record_options.restore_portal_session) {
@@ -1878,8 +2016,7 @@ namespace gsr {
             add_region_command(args, region_str, region_str_size, region_selector);
     }
 
-    static bool validate_capture_target(const GsrInfo &gsr_info, const std::string &capture_target) {
-        const SupportedCaptureOptions capture_options = get_supported_capture_options(gsr_info);
+    static bool validate_capture_target(const std::string &capture_target, const SupportedCaptureOptions &capture_options) {
         // TODO: Also check x11 window when enabled (check if capture_target is a decminal/hex number)
         if(capture_target == "region") {
             return capture_options.region;
@@ -1887,6 +2024,8 @@ namespace gsr {
             return capture_options.focused;
         } else if(capture_target == "portal") {
             return capture_options.portal;
+        } else if(capture_target == "focused_monitor") {
+            return !capture_options.monitors.empty();
         } else {
             for(const GsrMonitor &monitor : capture_options.monitors) {
                 if(capture_target == monitor.name)
@@ -1896,6 +2035,25 @@ namespace gsr {
         }
     }
 
+    std::string Overlay::get_capture_target(const std::string &capture_target, const SupportedCaptureOptions &capture_options) {
+        if(capture_target == "focused_monitor") {
+            std::optional<CursorInfo> cursor_info;
+            if(cursor_tracker) {
+                cursor_tracker->update();
+                cursor_info = cursor_tracker->get_latest_cursor_info();
+            }
+
+            if(cursor_info)
+                return cursor_info->monitor_name;
+            else if(!capture_options.monitors.empty())
+                return capture_options.monitors.front().name;
+            else
+                return "";
+        } else {
+            return capture_target;
+        }
+    }
+
     void Overlay::on_press_save_replay() {
         if(recording_status != RecordingStatus::REPLAY || gpu_screen_recorder_process <= 0)
             return;
@@ -1949,9 +2107,11 @@ namespace gsr {
             return true;
         }
 
-        if(!validate_capture_target(gsr_info, config.replay_config.record_options.record_area_option)) {
+        const SupportedCaptureOptions capture_options = get_supported_capture_options(gsr_info);
+        replay_capture_target = get_capture_target(config.replay_config.record_options.record_area_option, capture_options);
+        if(!validate_capture_target(replay_capture_target, capture_options)) {
             char err_msg[256];
-            snprintf(err_msg, sizeof(err_msg), "Failed to start replay, capture target \"%s\" is invalid. Please change capture target in settings", config.replay_config.record_options.record_area_option.c_str());
+            snprintf(err_msg, sizeof(err_msg), "Failed to start replay, capture target \"%s\" is invalid. Please change capture target in settings", replay_capture_target.c_str());
             show_notification(err_msg, notification_error_timeout_seconds, mgl::Color(255, 0, 0, 0), mgl::Color(255, 0, 0, 0), NotificationType::REPLAY);
             return false;
         }
@@ -1968,8 +2128,7 @@ namespace gsr {
         const std::string fps = std::to_string(config.replay_config.record_options.fps);
         const std::string video_bitrate = std::to_string(config.replay_config.record_options.video_bitrate);
         const std::string output_directory = config.replay_config.save_directory;
-        const std::vector<std::string> audio_tracks = create_audio_tracks_real_names(config.replay_config.record_options.audio_tracks, config.replay_config.record_options.application_audio_invert, gsr_info);
-        const std::string audio_tracks_merged = merge_audio_tracks(audio_tracks);
+        const std::vector<std::string> audio_tracks = create_audio_tracks_cli_args(config.replay_config.record_options.audio_tracks_list, gsr_info);
         const std::string framerate_mode = config.replay_config.record_options.framerate_mode == "auto" ? "vfr" : config.replay_config.record_options.framerate_mode;
         const std::string replay_time = std::to_string(config.replay_config.replay_time);
         const char *video_codec = config.replay_config.record_options.video_codec.c_str();
@@ -1988,7 +2147,7 @@ namespace gsr {
             snprintf(size, sizeof(size), "%dx%d", (int)config.replay_config.record_options.video_width, (int)config.replay_config.record_options.video_height);
 
         std::vector<const char*> args = {
-            "gpu-screen-recorder", "-w", config.replay_config.record_options.record_area_option.c_str(),
+            "gpu-screen-recorder", "-w", replay_capture_target.c_str(),
             "-c", config.replay_config.container.c_str(),
             "-ac", config.replay_config.record_options.audio_codec.c_str(),
             "-cursor", config.replay_config.record_options.record_cursor ? "yes" : "no",
@@ -2008,7 +2167,7 @@ namespace gsr {
         }
 
         char region_str[128];
-        add_common_gpu_screen_recorder_args(args, config.replay_config.record_options, audio_tracks, video_bitrate, size, audio_tracks_merged, region_str, sizeof(region_str), region_selector);
+        add_common_gpu_screen_recorder_args(args, config.replay_config.record_options, audio_tracks, video_bitrate, size, region_str, sizeof(region_str), region_selector);
 
         args.push_back(nullptr);
 
@@ -2035,8 +2194,14 @@ namespace gsr {
         // TODO: Do not run this is a daemon. Instead get the pid and when launching another notification close the current notification
         // program and start another one. This can also be used to check when the notification has finished by checking with waitpid NOWAIT
         // to see when the program has exit.
-        if(!disable_notification && config.replay_config.show_replay_started_notifications)
-            show_notification("Replay has started", notification_timeout_seconds, get_color_theme().tint_color, get_color_theme().tint_color, NotificationType::REPLAY);
+        if(!disable_notification && config.replay_config.show_replay_started_notifications) {
+            char msg[256];
+            if(is_capture_target_monitor(replay_capture_target.c_str()))
+                snprintf(msg, sizeof(msg), "Started replaying this monitor");
+            else
+                snprintf(msg, sizeof(msg), "Started replaying %s", replay_capture_target.c_str());
+            show_notification(msg, notification_timeout_seconds, get_color_theme().tint_color, get_color_theme().tint_color, NotificationType::REPLAY, replay_capture_target.c_str());
+        }
 
         return true;
     }
@@ -2082,9 +2247,11 @@ namespace gsr {
             return;
         }
 
-        if(!validate_capture_target(gsr_info, config.record_config.record_options.record_area_option)) {
+        const SupportedCaptureOptions capture_options = get_supported_capture_options(gsr_info);
+        recording_capture_target = get_capture_target(config.record_config.record_options.record_area_option, capture_options);
+        if(!validate_capture_target(config.record_config.record_options.record_area_option, capture_options)) {
             char err_msg[256];
-            snprintf(err_msg, sizeof(err_msg), "Failed to start recording, capture target \"%s\" is invalid. Please change capture target in settings", config.record_config.record_options.record_area_option.c_str());
+            snprintf(err_msg, sizeof(err_msg), "Failed to start recording, capture target \"%s\" is invalid. Please change capture target in settings", recording_capture_target.c_str());
             show_notification(err_msg, notification_error_timeout_seconds, mgl::Color(255, 0, 0, 0), mgl::Color(255, 0, 0, 0), NotificationType::RECORD);
             return;
         }
@@ -2103,8 +2270,7 @@ namespace gsr {
         const std::string fps = std::to_string(config.record_config.record_options.fps);
         const std::string video_bitrate = std::to_string(config.record_config.record_options.video_bitrate);
         const std::string output_file = config.record_config.save_directory + "/Video_" + get_date_str() + "." + container_to_file_extension(config.record_config.container.c_str());
-        const std::vector<std::string> audio_tracks = create_audio_tracks_real_names(config.record_config.record_options.audio_tracks, config.record_config.record_options.application_audio_invert, gsr_info);
-        const std::string audio_tracks_merged = merge_audio_tracks(audio_tracks);
+        const std::vector<std::string> audio_tracks = create_audio_tracks_cli_args(config.record_config.record_options.audio_tracks_list, gsr_info);
         const std::string framerate_mode = config.record_config.record_options.framerate_mode == "auto" ? "vfr" : config.record_config.record_options.framerate_mode;
         const char *video_codec = config.record_config.record_options.video_codec.c_str();
         const char *encoder = "gpu";
@@ -2122,7 +2288,7 @@ namespace gsr {
             snprintf(size, sizeof(size), "%dx%d", (int)config.record_config.record_options.video_width, (int)config.record_config.record_options.video_height);
 
         std::vector<const char*> args = {
-            "gpu-screen-recorder", "-w", config.record_config.record_options.record_area_option.c_str(),
+            "gpu-screen-recorder", "-w", recording_capture_target.c_str(),
             "-c", config.record_config.container.c_str(),
             "-ac", config.record_config.record_options.audio_codec.c_str(),
             "-cursor", config.record_config.record_options.record_cursor ? "yes" : "no",
@@ -2136,7 +2302,7 @@ namespace gsr {
         };
 
         char region_str[128];
-        add_common_gpu_screen_recorder_args(args, config.record_config.record_options, audio_tracks, video_bitrate, size, audio_tracks_merged, region_str, sizeof(region_str), region_selector);
+        add_common_gpu_screen_recorder_args(args, config.record_config.record_options, audio_tracks, video_bitrate, size, region_str, sizeof(region_str), region_selector);
 
         args.push_back(nullptr);
 
@@ -2155,8 +2321,14 @@ namespace gsr {
         // Starting recording in 3...
         // 2...
         // 1...
-        if(config.record_config.show_recording_started_notifications)
-            show_notification("Recording has started", notification_timeout_seconds, get_color_theme().tint_color, get_color_theme().tint_color, NotificationType::RECORD);
+        if(config.record_config.show_recording_started_notifications) {
+            char msg[256];
+            if(is_capture_target_monitor(recording_capture_target.c_str()))
+                snprintf(msg, sizeof(msg), "Started recording this monitor");
+            else
+                snprintf(msg, sizeof(msg), "Started recording %s", recording_capture_target.c_str());
+            show_notification(msg, notification_timeout_seconds, get_color_theme().tint_color, get_color_theme().tint_color, NotificationType::RECORD, recording_capture_target.c_str());
+        }
     }
 
     static std::string streaming_get_url(const Config &config) {
@@ -2230,9 +2402,11 @@ namespace gsr {
             return;
         }
 
-        if(!validate_capture_target(gsr_info, config.streaming_config.record_options.record_area_option)) {
+        const SupportedCaptureOptions capture_options = get_supported_capture_options(gsr_info);
+        const std::string capture_target = get_capture_target(config.streaming_config.record_options.record_area_option, capture_options);
+        if(!validate_capture_target(config.streaming_config.record_options.record_area_option, capture_options)) {
             char err_msg[256];
-            snprintf(err_msg, sizeof(err_msg), "Failed to start streaming, capture target \"%s\" is invalid. Please change capture target in settings", config.streaming_config.record_options.record_area_option.c_str());
+            snprintf(err_msg, sizeof(err_msg), "Failed to start streaming, capture target \"%s\" is invalid. Please change capture target in settings", capture_target.c_str());
             show_notification(err_msg, notification_error_timeout_seconds, mgl::Color(255, 0, 0, 0), mgl::Color(255, 0, 0, 0), NotificationType::STREAM);
             return;
         }
@@ -2248,8 +2422,11 @@ namespace gsr {
         // TODO: Validate input, fallback to valid values
         const std::string fps = std::to_string(config.streaming_config.record_options.fps);
         const std::string video_bitrate = std::to_string(config.streaming_config.record_options.video_bitrate);
-        const std::vector<std::string> audio_tracks = create_audio_tracks_real_names(config.streaming_config.record_options.audio_tracks, config.streaming_config.record_options.application_audio_invert, gsr_info);
-        const std::string audio_tracks_merged = merge_audio_tracks(audio_tracks);
+        std::vector<std::string> audio_tracks = create_audio_tracks_cli_args(config.streaming_config.record_options.audio_tracks_list, gsr_info);
+        // This isn't possible unless the user modified the config file manually,
+        // But we check it anyways as streaming on some sites can fail if there is more than one audio track
+        if(audio_tracks.size() > 1)
+            audio_tracks.resize(1);
         const std::string framerate_mode = config.streaming_config.record_options.framerate_mode == "auto" ? "vfr" : config.streaming_config.record_options.framerate_mode;
         const char *video_codec = config.streaming_config.record_options.video_codec.c_str();
         const char *encoder = "gpu";
@@ -2273,7 +2450,7 @@ namespace gsr {
             snprintf(size, sizeof(size), "%dx%d", (int)config.streaming_config.record_options.video_width, (int)config.streaming_config.record_options.video_height);
 
         std::vector<const char*> args = {
-            "gpu-screen-recorder", "-w", config.streaming_config.record_options.record_area_option.c_str(),
+            "gpu-screen-recorder", "-w", capture_target.c_str(),
             "-c", container.c_str(),
             "-ac", config.streaming_config.record_options.audio_codec.c_str(),
             "-cursor", config.streaming_config.record_options.record_cursor ? "yes" : "no",
@@ -2285,9 +2462,8 @@ namespace gsr {
             "-o", url.c_str()
         };
 
-        config.streaming_config.record_options.merge_audio_tracks = true;
         char region_str[128];
-        add_common_gpu_screen_recorder_args(args, config.streaming_config.record_options, audio_tracks, video_bitrate, size, audio_tracks_merged, region_str, sizeof(region_str), region_selector);
+        add_common_gpu_screen_recorder_args(args, config.streaming_config.record_options, audio_tracks, video_bitrate, size, region_str, sizeof(region_str), region_selector);
 
         args.push_back(nullptr);
 
@@ -2308,8 +2484,14 @@ namespace gsr {
         // TODO: Do not run this is a daemon. Instead get the pid and when launching another notification close the current notification
         // program and start another one. This can also be used to check when the notification has finished by checking with waitpid NOWAIT
         // to see when the program has exit.
-        if(config.streaming_config.show_streaming_started_notifications)
-            show_notification("Streaming has started", notification_timeout_seconds, get_color_theme().tint_color, get_color_theme().tint_color, NotificationType::STREAM);
+        if(config.streaming_config.show_streaming_started_notifications) {
+            char msg[256];
+            if(is_capture_target_monitor(capture_target.c_str()))
+                snprintf(msg, sizeof(msg), "Started streaming this monitor");
+            else
+                snprintf(msg, sizeof(msg), "Started streaming %s", capture_target.c_str());
+            show_notification(msg, notification_timeout_seconds, get_color_theme().tint_color, get_color_theme().tint_color, NotificationType::STREAM, capture_target.c_str());
+        }
     }
 
     void Overlay::on_press_take_screenshot(bool finished_region_selection, bool force_region_capture) {
@@ -2323,9 +2505,11 @@ namespace gsr {
 
         const bool region_capture = config.screenshot_config.record_area_option == "region" || force_region_capture;
         const char *record_area_option = region_capture ? "region" : config.screenshot_config.record_area_option.c_str();
-        if(!validate_capture_target(gsr_info, record_area_option)) {
+        const SupportedCaptureOptions capture_options = get_supported_capture_options(gsr_info);
+        screenshot_capture_target = get_capture_target(record_area_option, capture_options);
+        if(!validate_capture_target(record_area_option, capture_options)) {
             char err_msg[256];
-            snprintf(err_msg, sizeof(err_msg), "Failed to take a screenshot, capture target \"%s\" is invalid. Please change capture target in settings", record_area_option);
+            snprintf(err_msg, sizeof(err_msg), "Failed to take a screenshot, capture target \"%s\" is invalid. Please change capture target in settings", screenshot_capture_target.c_str());
             show_notification(err_msg, notification_error_timeout_seconds, mgl::Color(255, 0, 0, 0), mgl::Color(255, 0, 0, 0), NotificationType::SCREENSHOT);
             return;
         }
@@ -2343,7 +2527,7 @@ namespace gsr {
         const std::string output_file = config.screenshot_config.save_directory + "/Screenshot_" + get_date_str() + "." + config.screenshot_config.image_format; // TODO: Validate image format
 
         std::vector<const char*> args = {
-            "gpu-screen-recorder", "-w", record_area_option,
+            "gpu-screen-recorder", "-w", screenshot_capture_target.c_str(),
             "-cursor", config.screenshot_config.record_cursor ? "yes" : "no",
             "-v", "no",
             "-q", config.screenshot_config.image_quality.c_str(),
@@ -2421,7 +2605,7 @@ namespace gsr {
 
             mgl_context *context = mgl_get_context();
             Display *display = (Display*)context->connection;
-            XRaiseWindow(display, window->get_system_handle());
+            XRaiseWindow(display, (Window)window->get_system_handle());
             XFlush(display);
         }
     }
diff --git a/src/Theme.cpp b/src/Theme.cpp
index 2001f7d..cafaf62 100644
--- a/src/Theme.cpp
+++ b/src/Theme.cpp
@@ -75,7 +75,7 @@ namespace gsr {
         if(!theme->folder_texture.load_from_file((resources_path + "images/folder.png").c_str()))
             goto error;
 
-        if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str()))
+        if(!theme->up_arrow_texture.load_from_file((resources_path + "images/up_arrow.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->replay_button_texture.load_from_file((resources_path + "images/replay.png").c_str()))
@@ -93,10 +93,10 @@ namespace gsr {
         if(!theme->logo_texture.load_from_file((resources_path + "images/gpu_screen_recorder_logo.png").c_str()))
             goto error;
 
-        if(!theme->checkbox_circle_texture.load_from_file((resources_path + "images/checkbox_circle.png").c_str()))
+        if(!theme->checkbox_circle_texture.load_from_file((resources_path + "images/checkbox_circle.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->checkbox_background_texture.load_from_file((resources_path + "images/checkbox_background.png").c_str()))
+        if(!theme->checkbox_background_texture.load_from_file((resources_path + "images/checkbox_background.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         if(!theme->play_texture.load_from_file((resources_path + "images/play.png").c_str()))
@@ -114,22 +114,25 @@ namespace gsr {
         if(!theme->screenshot_texture.load_from_file((resources_path + "images/screenshot.png").c_str()))
             goto error;
 
-        if(!theme->ps4_home_texture.load_from_file((resources_path + "images/ps4_home.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->trash_texture.load_from_file((resources_path + "images/trash.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_options_texture.load_from_file((resources_path + "images/ps4_options.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_home_texture.load_from_file((resources_path + "images/ps4_home.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_up_texture.load_from_file((resources_path + "images/ps4_dpad_up.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_options_texture.load_from_file((resources_path + "images/ps4_options.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_down_texture.load_from_file((resources_path + "images/ps4_dpad_down.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_up_texture.load_from_file((resources_path + "images/ps4_dpad_up.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
+            goto error;
+
+        if(!theme->ps4_dpad_down_texture.load_from_file((resources_path + "images/ps4_dpad_down.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
         
-        if(!theme->ps4_dpad_left_texture.load_from_file((resources_path + "images/ps4_dpad_left.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_left_texture.load_from_file((resources_path + "images/ps4_dpad_left.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
-        if(!theme->ps4_dpad_right_texture.load_from_file((resources_path + "images/ps4_dpad_right.png").c_str(), mgl::Texture::LoadOptions{false, false, true}))
+        if(!theme->ps4_dpad_right_texture.load_from_file((resources_path + "images/ps4_dpad_right.png").c_str(), mgl::Texture::LoadOptions{false, false, MGL_TEXTURE_SCALE_LINEAR_MIPMAP}))
             goto error;
 
         return true;
diff --git a/src/Utils.cpp b/src/Utils.cpp
index df6db2f..bc7b1f2 100644
--- a/src/Utils.cpp
+++ b/src/Utils.cpp
@@ -22,6 +22,11 @@ namespace gsr {
         }
     }
 
+    bool starts_with(std::string_view str, const char *substr) {
+        size_t len = strlen(substr);
+        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
+    }
+
     std::string get_home_dir() {
         const char *home_dir = getenv("HOME");
         if(!home_dir) {
diff --git a/src/WindowUtils.cpp b/src/WindowUtils.cpp
index 49fd65b..eb6080f 100644
--- a/src/WindowUtils.cpp
+++ b/src/WindowUtils.cpp
@@ -5,6 +5,7 @@
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/shapeconst.h>
+#include <X11/extensions/Xrandr.h>
 
 #include <mglpp/system/Utf8.hpp>
 
@@ -518,14 +519,21 @@ namespace gsr {
         return XGetSelectionOwner(dpy, prop_atom) != None;
     }
 
-    static void get_monitors_callback(const mgl_monitor *monitor, void *userdata) {
-        std::vector<Monitor> *monitors = (std::vector<Monitor>*)userdata;
-        monitors->push_back({mgl::vec2i(monitor->pos.x, monitor->pos.y), mgl::vec2i(monitor->size.x, monitor->size.y)});
-    }
-
     std::vector<Monitor> get_monitors(Display *dpy) {
         std::vector<Monitor> monitors;
-        mgl_for_each_active_monitor_output(dpy, get_monitors_callback, &monitors);
+        int nmonitors = 0;
+        XRRMonitorInfo *monitor_info = XRRGetMonitors(dpy, DefaultRootWindow(dpy), True, &nmonitors);
+        if(monitor_info) {
+            for(int i = 0; i < nmonitors; ++i) {
+                char *monitor_name = XGetAtomName(dpy, monitor_info[i].name);
+                if(!monitor_name)
+                    continue;
+
+                monitors.push_back({mgl::vec2i(monitor_info[i].x, monitor_info[i].y), mgl::vec2i(monitor_info[i].width, monitor_info[i].height), std::string(monitor_name)});
+                XFree(monitor_name);
+            }
+            XRRFreeMonitors(monitor_info);
+        }
         return monitors;
     }
 
diff --git a/src/gui/Button.cpp b/src/gui/Button.cpp
index d8cb85b..6e343c4 100644
--- a/src/gui/Button.cpp
+++ b/src/gui/Button.cpp
@@ -63,7 +63,7 @@ namespace gsr {
             window.draw(sprite);
 
             const int padding_icon_right = padding_right_icon_scale * get_button_height();
-            text.set_position((sprite.get_position() + mgl::vec2f(sprite.get_size().x + padding_icon_right, sprite.get_size().y * 0.5f - text.get_bounds().size.y * 0.5f)).floor());
+            text.set_position((sprite.get_position() + mgl::vec2f(sprite.get_size().x + padding_icon_right, sprite.get_size().y * 0.5f - text.get_bounds().size.y * 0.52f)).floor());
             window.draw(text);
         } else {
             text.set_position((draw_pos + item_size * 0.5f - text.get_bounds().size * 0.5f).floor());
diff --git a/src/gui/GlobalSettingsPage.cpp b/src/gui/GlobalSettingsPage.cpp
index 1e2a444..fd4b6b8 100644
--- a/src/gui/GlobalSettingsPage.cpp
+++ b/src/gui/GlobalSettingsPage.cpp
@@ -149,7 +149,7 @@ namespace gsr {
         tint_color_radio_button_ptr = tint_color_radio_button.get();
         tint_color_radio_button->add_item("Red", "amd");
         tint_color_radio_button->add_item("Green", "nvidia");
-        tint_color_radio_button->add_item("blue", "intel");
+        tint_color_radio_button->add_item("Blue", "intel");
         tint_color_radio_button->on_selection_changed = [](const std::string&, const std::string &id) {
             if(id == "amd")
                 get_color_theme().tint_color = mgl::Color(221, 0, 49);
diff --git a/src/gui/GsrPage.cpp b/src/gui/GsrPage.cpp
index 663187c..b4005f5 100644
--- a/src/gui/GsrPage.cpp
+++ b/src/gui/GsrPage.cpp
@@ -39,8 +39,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &window, &event, content_page_position](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, content_page_position))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, content_page_position))
                     return false;
             }
             return true;
diff --git a/src/gui/List.cpp b/src/gui/List.cpp
index 5294e36..57a6045 100644
--- a/src/gui/List.cpp
+++ b/src/gui/List.cpp
@@ -24,14 +24,23 @@ namespace gsr {
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &event, &window](std::unique_ptr<Widget> &widget) {
             // Ignore offset because widgets are positioned with offset in ::draw, this solution is simpler
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, mgl::vec2f(0.0f, 0.0f)))
                     return false;
             }
             return true;
         });
     }
 
+    List::~List() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
+
     void List::draw(mgl::Window &window, mgl::vec2f offset) {
         if(!visible)
             return;
@@ -104,15 +113,6 @@ namespace gsr {
             selected_widget->draw(window, mgl::vec2f(0.0f, 0.0f));
     }
 
-    // void List::remove_child_widget(Widget *widget) {
-    //     for(auto it = widgets.begin(), end = widgets.end(); it != end; ++it) {
-    //         if(it->get() == widget) {
-    //             widgets.erase(it);
-    //             return;
-    //         }
-    //     }
-    // }
-
     void List::add_widget(std::unique_ptr<Widget> widget) {
         widget->parent_widget = this;
         widgets.push_back(std::move(widget));
@@ -122,6 +122,10 @@ namespace gsr {
         widgets.remove(widget);
     }
 
+    void List::replace_widget(Widget *widget, std::unique_ptr<Widget> new_widget) {
+        widgets.replace_item(widget, std::move(new_widget));
+    }
+
     void List::clear() {
         widgets.clear();
     }
@@ -137,6 +141,10 @@ namespace gsr {
             return nullptr;
     }
 
+    size_t List::get_num_children() const {
+        return widgets.size();
+    }
+
     void List::set_spacing(float spacing) {
         spacing_scale = spacing;
     }
diff --git a/src/gui/Page.cpp b/src/gui/Page.cpp
index ae13d82..5f21b71 100644
--- a/src/gui/Page.cpp
+++ b/src/gui/Page.cpp
@@ -1,14 +1,13 @@
 #include "../../include/gui/Page.hpp"
 
 namespace gsr {
-    // void Page::remove_child_widget(Widget *widget) {
-    //     for(auto it = widgets.begin(), end = widgets.end(); it != end; ++it) {
-    //         if(it->get() == widget) {
-    //             widgets.erase(it);
-    //             return;
-    //         }
-    //     }
-    // }
+    Page::~Page() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
 
     void Page::add_widget(std::unique_ptr<Widget> widget) {
         widget->parent_widget = this;
diff --git a/src/gui/ScreenshotSettingsPage.cpp b/src/gui/ScreenshotSettingsPage.cpp
index fd75660..5b8efbd 100644
--- a/src/gui/ScreenshotSettingsPage.cpp
+++ b/src/gui/ScreenshotSettingsPage.cpp
@@ -40,6 +40,8 @@ namespace gsr {
         //    record_area_box->add_item("Window", "window");
         if(capture_options.region)
             record_area_box->add_item("Region", "region");
+        if(!capture_options.monitors.empty())
+            record_area_box->add_item(gsr_info->system_info.display_server == DisplayServer::WAYLAND ? "Focused monitor (Experimental on Wayland)" : "Focused monitor", "focused_monitor");
         for(const auto &monitor : capture_options.monitors) {
             char name[256];
             snprintf(name, sizeof(name), "Monitor %s (%dx%d)", monitor.name.c_str(), monitor.size.x, monitor.size.y);
@@ -255,8 +257,7 @@ namespace gsr {
     void ScreenshotSettingsPage::add_widgets() {
         content_page_ptr->add_widget(create_settings());
 
-        record_area_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        record_area_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool window_selected = id == "window";
             const bool portal_selected = id == "portal";
             select_window_list_ptr->set_visible(window_selected);
@@ -270,7 +271,7 @@ namespace gsr {
         };
 
         if(!capture_options.monitors.empty())
-            record_area_box_ptr->set_selected_item(capture_options.monitors.front().name);
+            record_area_box_ptr->set_selected_item("focused_monitor");
         else if(capture_options.portal)
             record_area_box_ptr->set_selected_item("portal");
         else if(capture_options.window)
diff --git a/src/gui/ScrollablePage.cpp b/src/gui/ScrollablePage.cpp
index d5e92d0..cec20d3 100644
--- a/src/gui/ScrollablePage.cpp
+++ b/src/gui/ScrollablePage.cpp
@@ -15,6 +15,14 @@ namespace gsr {
 
     ScrollablePage::ScrollablePage(mgl::vec2f size) : size(size) {}
 
+    ScrollablePage::~ScrollablePage() {
+        widgets.for_each([this](std::unique_ptr<Widget> &widget) {
+            if(widget->parent_widget == this)
+                widget->parent_widget = nullptr;
+            return true;
+        }, true);
+    }
+
     bool ScrollablePage::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f offset) {
         if(!visible)
             return true;
@@ -57,8 +65,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         const bool continue_events = widgets.for_each_reverse([selected_widget, &window, &event, offset](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, offset))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, offset))
                     return false;
             }
             return true;
diff --git a/src/gui/SettingsPage.cpp b/src/gui/SettingsPage.cpp
index 79b4525..9890d17 100644
--- a/src/gui/SettingsPage.cpp
+++ b/src/gui/SettingsPage.cpp
@@ -11,6 +11,8 @@
 #include <string.h>
 
 namespace gsr {
+    static const char *custom_app_audio_tag = "[custom]";
+
     enum class AudioTrackType {
         DEVICE,
         APPLICATION,
@@ -70,6 +72,8 @@ namespace gsr {
             record_area_box->add_item("Region", "region");
         if(capture_options.focused)
             record_area_box->add_item("Follow focused window", "focused");
+        if(!capture_options.monitors.empty())
+            record_area_box->add_item(gsr_info->system_info.display_server == DisplayServer::WAYLAND ? "Focused monitor (Experimental on Wayland)" : "Focused monitor", "focused_monitor");
         for(const auto &monitor : capture_options.monitors) {
             char name[256];
             snprintf(name, sizeof(name), "Monitor %s (%dx%d)", monitor.name.c_str(), monitor.size.x, monitor.size.y);
@@ -200,121 +204,201 @@ namespace gsr {
         return audio_device_box;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_device_list_ptr) {
-        auto remove_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Remove", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        remove_audio_track_button->on_click = [this, audio_device_list_ptr]() {
-            audio_track_list_ptr->remove_widget(audio_device_list_ptr);
+    static void set_application_audio_options_visible(Subsection *audio_track_subsection, bool visible, const GsrInfo &gsr_info) {
+        if(!gsr_info.system_info.supports_app_audio)
+            visible = false;
+
+        List *audio_track_items_list = dynamic_cast<List*>(audio_track_subsection->get_inner_widget());
+
+        List *buttons_list = dynamic_cast<List*>(audio_track_items_list->get_child_widget_by_index(1));
+        Button *add_application_audio_button = dynamic_cast<Button*>(buttons_list->get_child_widget_by_index(1));
+        add_application_audio_button->set_visible(visible);
+
+        CheckBox *invert_app_audio_checkbox = dynamic_cast<CheckBox*>(audio_track_items_list->get_child_widget_by_index(3));
+        invert_app_audio_checkbox->set_visible(visible);
+    }
+
+    static void set_application_audio_options_visible(List *audio_track_section_list_ptr, bool visible, const GsrInfo &gsr_info) {
+        audio_track_section_list_ptr->for_each_child_widget([visible, &gsr_info](std::unique_ptr<Widget> &widget) {
+            Subsection *audio_track_subsection = dynamic_cast<Subsection*>(widget.get());
+            set_application_audio_options_visible(audio_track_subsection, visible, gsr_info);
+            return true;
+        });
+    }
+
+    std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr) {
+        auto remove_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
+        remove_audio_track_button->set_icon(&get_theme().trash_texture);
+        remove_audio_track_button->set_icon_padding_scale(0.75f);
+        remove_audio_track_button->on_click = [audio_input_list_ptr, audio_device_list_ptr]() {
+            audio_input_list_ptr->remove_widget(audio_device_list_ptr);
         };
         return remove_audio_track_button;
     }
 
-    std::unique_ptr<List> SettingsPage::create_audio_device() {
+    std::unique_ptr<List> SettingsPage::create_audio_device(List *audio_input_list_ptr) {
         auto audio_device_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         audio_device_list->userdata = (void*)(uintptr_t)AudioTrackType::DEVICE;
         audio_device_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "Device:", get_color_theme().text_color));
         audio_device_list->add_widget(create_audio_device_selection_combobox());
-        audio_device_list->add_widget(create_remove_audio_device_button(audio_device_list.get()));
+        audio_device_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, audio_device_list.get()));
         return audio_device_list;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_audio_device_button() {
+    std::unique_ptr<Button> SettingsPage::create_add_audio_track_button() {
+        auto button = std::make_unique<Button>(&get_theme().body_font, "Add audio track", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
+        button->on_click = [this]() {
+            audio_track_section_list_ptr->add_widget(create_audio_track_section(audio_section_ptr));
+        };
+        button->set_visible(type != Type::STREAM);
+        return button;
+    }
+
+    std::unique_ptr<Button> SettingsPage::create_add_audio_device_button(List *audio_input_list_ptr) {
         auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add audio device", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_audio_track_button->on_click = [this]() {
+        add_audio_track_button->on_click = [this, audio_input_list_ptr]() {
             audio_devices = get_audio_devices();
-            audio_track_list_ptr->add_widget(create_audio_device());
+            audio_input_list_ptr->add_widget(create_audio_device(audio_input_list_ptr));
         };
         return add_audio_track_button;
     }
 
-    std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox() {
+    std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox(List *application_audio_row) {
         auto audio_device_box = std::make_unique<ComboBox>(&get_theme().body_font);
+        ComboBox *audio_device_box_ptr = audio_device_box.get();
         for(const auto &app_audio : application_audio) {
             audio_device_box->add_item(app_audio, app_audio);
         }
+        audio_device_box->add_item("Custom...", custom_app_audio_tag);
+
+        audio_device_box->on_selection_changed = [application_audio_row, audio_device_box_ptr](const std::string&, const std::string &id) {
+            if(id == custom_app_audio_tag) {
+                application_audio_row->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
+                auto custom_app_audio_entry = std::make_unique<Entry>(&get_theme().body_font, "", (int)(get_theme().body_font.get_character_size() * 10.0f));
+                application_audio_row->replace_widget(audio_device_box_ptr, std::move(custom_app_audio_entry));
+            }
+        };
+
         return audio_device_box;
     }
 
-    std::unique_ptr<List> SettingsPage::create_application_audio() {
+    std::unique_ptr<List> SettingsPage::create_application_audio(List *audio_input_list_ptr) {
         auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION;
         application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App:     ", get_color_theme().text_color));
-        application_audio_list->add_widget(create_application_audio_selection_combobox());
-        application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get()));
+        application_audio_list->add_widget(create_application_audio_selection_combobox(application_audio_list.get()));
+        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
         return application_audio_list;
     }
 
-    std::unique_ptr<List> SettingsPage::create_custom_application_audio() {
+    std::unique_ptr<List> SettingsPage::create_custom_application_audio(List *audio_input_list_ptr) {
         auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
         application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
         application_audio_list->add_widget(std::make_unique<Label>(&get_theme().body_font, "App:     ", get_color_theme().text_color));
         application_audio_list->add_widget(std::make_unique<Entry>(&get_theme().body_font, "", (int)(get_theme().body_font.get_character_size() * 10.0f)));
-        application_audio_list->add_widget(create_remove_audio_device_button(application_audio_list.get()));
+        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
         return application_audio_list;
     }
 
-    std::unique_ptr<Button> SettingsPage::create_add_application_audio_button() {
+    std::unique_ptr<Button> SettingsPage::create_add_application_audio_button(List *audio_input_list_ptr) {
         auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_application_audio_button_ptr = add_audio_track_button.get();
-        add_audio_track_button->on_click = [this]() {
+        add_audio_track_button->on_click = [this, audio_input_list_ptr]() {
             application_audio = get_application_audio();
-            audio_track_list_ptr->add_widget(create_application_audio());
-        };
-        return add_audio_track_button;
-    }
-
-    std::unique_ptr<Button> SettingsPage::create_add_custom_application_audio_button() {
-        auto add_audio_track_button = std::make_unique<Button>(&get_theme().body_font, "Add custom application audio", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
-        add_custom_application_audio_button_ptr = add_audio_track_button.get();
-        add_audio_track_button->on_click = [this]() {
-            audio_track_list_ptr->add_widget(create_custom_application_audio());
+            if(application_audio.empty())
+                audio_input_list_ptr->add_widget(create_custom_application_audio(audio_input_list_ptr));
+            else
+                audio_input_list_ptr->add_widget(create_application_audio(audio_input_list_ptr));
         };
         return add_audio_track_button;
     }
 
-    std::unique_ptr<List> SettingsPage::create_add_audio_buttons() {
+    std::unique_ptr<List> SettingsPage::create_add_audio_buttons(List *audio_input_list_ptr) {
         auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
-        list->add_widget(create_add_audio_device_button());
-        list->add_widget(create_add_application_audio_button());
-        list->add_widget(create_add_custom_application_audio_button());
+        list->add_widget(create_add_audio_device_button(audio_input_list_ptr));
+        list->add_widget(create_add_application_audio_button(audio_input_list_ptr));
         return list;
     }
 
-    std::unique_ptr<List> SettingsPage::create_audio_track_track_section() {
+    std::unique_ptr<List> SettingsPage::create_audio_input_section() {
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
-        audio_track_list_ptr = list.get();
-        audio_track_list_ptr->add_widget(create_audio_device()); // Add default_output by default
+        //list->add_widget(create_audio_device(list.get())); // Add default_output by default
         return list;
     }
 
-    std::unique_ptr<CheckBox> SettingsPage::create_split_audio_checkbox() {
-        auto split_audio_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Split each device/app audio into separate audio tracks");
-        split_audio_checkbox->set_checked(false);
-        split_audio_checkbox_ptr = split_audio_checkbox.get();
-        return split_audio_checkbox;
-    }
-
     std::unique_ptr<CheckBox> SettingsPage::create_application_audio_invert_checkbox() {
         auto application_audio_invert_checkbox = std::make_unique<CheckBox>(&get_theme().body_font, "Record audio from all applications except the selected ones");
         application_audio_invert_checkbox->set_checked(false);
-        application_audio_invert_checkbox_ptr = application_audio_invert_checkbox.get();
         return application_audio_invert_checkbox;
     }
 
-    std::unique_ptr<Widget> SettingsPage::create_audio_track_section() {
+    static void update_audio_track_titles(List *audio_track_section_list_ptr) {
+        int index = 0;
+        audio_track_section_list_ptr->for_each_child_widget([&index](std::unique_ptr<Widget> &widget) {
+            char audio_track_name[32];
+            snprintf(audio_track_name, sizeof(audio_track_name), "Audio track #%d", 1 + index);
+            ++index;
+
+            Subsection *subsection = dynamic_cast<Subsection*>(widget.get());
+            List *subesection_items = dynamic_cast<List*>(subsection->get_inner_widget());
+            Label *audio_track_title = dynamic_cast<Label*>(dynamic_cast<List*>(subesection_items->get_child_widget_by_index(0))->get_child_widget_by_index(0));
+            audio_track_title->set_text(audio_track_name);
+            return true;
+        });
+    }
+
+    std::unique_ptr<List> SettingsPage::create_audio_track_title_and_remove(Subsection *audio_track_subsection, const char *title) {
+        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
+        list->add_widget(std::make_unique<Label>(&get_theme().title_font, title, get_color_theme().text_color));
+
+        auto remove_track_button = std::make_unique<Button>(&get_theme().body_font, "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
+        remove_track_button->set_icon(&get_theme().trash_texture);
+        remove_track_button->set_icon_padding_scale(0.75f);
+        remove_track_button->on_click = [this, audio_track_subsection]() {
+            audio_track_section_list_ptr->remove_widget(audio_track_subsection);
+            update_audio_track_titles(audio_track_section_list_ptr);
+        };
+        list->add_widget(std::move(remove_track_button));
+        list->set_visible(type != Type::STREAM);
+        return list;
+    }
+
+    std::unique_ptr<Subsection> SettingsPage::create_audio_track_section(Widget *parent_widget) {
+        char audio_track_name[32];
+        snprintf(audio_track_name, sizeof(audio_track_name), "Audio track #%d", 1 + (int)audio_track_section_list_ptr->get_num_children());
+
+        auto audio_input_section = create_audio_input_section();
+        List *audio_input_section_ptr = audio_input_section.get();
+
         auto list = std::make_unique<List>(List::Orientation::VERTICAL);
-        list->add_widget(create_add_audio_buttons());
-        list->add_widget(create_audio_track_track_section());
+        List *list_ptr = list.get();
+        auto subsection = std::make_unique<Subsection>("", std::move(std::move(list)), mgl::vec2f(parent_widget->get_inner_size().x, 0.0f));
+        subsection->set_bg_color(mgl::Color(35, 40, 44));
+
+        list_ptr->add_widget(create_audio_track_title_and_remove(subsection.get(), audio_track_name));
+        list_ptr->add_widget(create_add_audio_buttons(audio_input_section_ptr));
+        list_ptr->add_widget(std::move(audio_input_section));
+        list_ptr->add_widget(create_application_audio_invert_checkbox());
+
+        set_application_audio_options_visible(subsection.get(), view_radio_button_ptr->get_selected_id() == "advanced", *gsr_info);
+        return subsection;
+    }
+
+    std::unique_ptr<List> SettingsPage::create_audio_track_section_list() {
+        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
+        audio_track_section_list_ptr = list.get();
         return list;
     }
 
     std::unique_ptr<Widget> SettingsPage::create_audio_section() {
         auto audio_device_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
-        audio_device_section_list->add_widget(create_audio_track_section());
-        if(type != Type::STREAM)
-            audio_device_section_list->add_widget(create_split_audio_checkbox());
-        audio_device_section_list->add_widget(create_application_audio_invert_checkbox());
-        audio_device_section_list->add_widget(create_audio_codec());
-        return std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+        List *audio_device_section_list_ptr = audio_device_section_list.get();
+
+        auto subsection = std::make_unique<Subsection>("Audio", std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
+        audio_section_ptr = subsection.get();
+        audio_device_section_list_ptr->add_widget(create_add_audio_track_button());
+        audio_device_section_list_ptr->add_widget(create_audio_track_section_list());
+        audio_device_section_list_ptr->add_widget(create_audio_codec());
+        return subsection;
     }
 
     std::unique_ptr<List> SettingsPage::create_video_quality_box() {
@@ -529,8 +613,7 @@ namespace gsr {
     void SettingsPage::add_widgets() {
         content_page_ptr->add_widget(create_settings());
 
-        record_area_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        record_area_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool window_selected = id == "window";
             const bool focused_selected = id == "focused";
             const bool portal_selected = id == "portal";
@@ -547,8 +630,7 @@ namespace gsr {
             video_resolution_list_ptr->set_visible(!focused_selected && checked);
         };
 
-        video_quality_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        video_quality_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool custom_selected = id == "custom";
             video_bitrate_list_ptr->set_visible(custom_selected);
 
@@ -560,19 +642,13 @@ namespace gsr {
         video_quality_box_ptr->on_selection_changed("", video_quality_box_ptr->get_selected_id());
 
         if(!capture_options.monitors.empty())
-            record_area_box_ptr->set_selected_item(capture_options.monitors.front().name);
+            record_area_box_ptr->set_selected_item("focused_monitor");
         else if(capture_options.portal)
             record_area_box_ptr->set_selected_item("portal");
         else if(capture_options.window)
             record_area_box_ptr->set_selected_item("window");
         else
             record_area_box_ptr->on_selection_changed("", "");
-
-        if(!gsr_info->system_info.supports_app_audio) {
-            add_application_audio_button_ptr->set_visible(false);
-            add_custom_application_audio_button_ptr->set_visible(false);
-            application_audio_invert_checkbox_ptr->set_visible(false);
-        }
     }
 
     void SettingsPage::add_page_specific_widgets() {
@@ -714,6 +790,16 @@ namespace gsr {
         replay_time_label_ptr->set_text(buffer);
     }
 
+    void SettingsPage::view_changed(bool advanced_view, Subsection *notifications_subsection_ptr) {
+        color_range_list_ptr->set_visible(advanced_view);
+        audio_codec_ptr->set_visible(advanced_view);
+        video_codec_ptr->set_visible(advanced_view);
+        framerate_mode_list_ptr->set_visible(advanced_view);
+        notifications_subsection_ptr->set_visible(advanced_view);
+        set_application_audio_options_visible(audio_track_section_list_ptr, advanced_view, *gsr_info);
+        settings_scrollable_page_ptr->reset_scroll();
+    }
+
     void SettingsPage::add_replay_widgets() {
         auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
         auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
@@ -752,16 +838,8 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            split_audio_checkbox_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -826,16 +904,8 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            split_audio_checkbox_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -931,8 +1001,7 @@ namespace gsr {
         Subsection *notifications_subsection_ptr = notifications_subsection.get();
         settings_list_ptr->add_widget(std::move(notifications_subsection));
 
-        streaming_service_box_ptr->on_selection_changed = [this](const std::string &text, const std::string &id) {
-            (void)text;
+        streaming_service_box_ptr->on_selection_changed = [this](const std::string&, const std::string &id) {
             const bool twitch_option = id == "twitch";
             const bool youtube_option = id == "youtube";
             const bool custom_option = id == "custom";
@@ -945,15 +1014,8 @@ namespace gsr {
         };
         streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");
 
-        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string &text, const std::string &id) {
-            (void)text;
-            const bool advanced_view = id == "advanced";
-            color_range_list_ptr->set_visible(advanced_view);
-            audio_codec_ptr->set_visible(advanced_view);
-            video_codec_ptr->set_visible(advanced_view);
-            framerate_mode_list_ptr->set_visible(advanced_view);
-            notifications_subsection_ptr->set_visible(advanced_view);
-            settings_scrollable_page_ptr->reset_scroll();
+        view_radio_button_ptr->on_selection_changed = [this, notifications_subsection_ptr](const std::string&, const std::string &id) {
+            view_changed(id == "advanced", notifications_subsection_ptr);
             return true;
         };
         view_radio_button_ptr->on_selection_changed("Simple", "simple");
@@ -1004,50 +1066,61 @@ namespace gsr {
         return nullptr;
     }
 
-    static bool starts_with(std::string_view str, const char *substr) {
-        size_t len = strlen(substr);
-        return str.size() >= len && memcmp(str.data(), substr, len) == 0;
-    }
-
     void SettingsPage::load_audio_tracks(const RecordOptions &record_options) {
-        audio_track_list_ptr->clear();
-        for(const std::string &audio_track : record_options.audio_tracks) {
-            if(starts_with(audio_track, "app:")) {
-                if(!gsr_info->system_info.supports_app_audio)
-                    continue;
-
-                std::string audio_track_name = audio_track.substr(4);
-                const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name);
-                if(app_audio) {
-                    std::unique_ptr<List> application_audio_widget = create_application_audio();
-                    ComboBox *application_audio_box = static_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1));
-                    application_audio_box->set_selected_item(*app_audio);
-                    audio_track_list_ptr->add_widget(std::move(application_audio_widget));
+        audio_track_section_list_ptr->clear();
+        for(const AudioTrack &audio_track : record_options.audio_tracks_list) {
+            auto audio_track_section = create_audio_track_section(audio_section_ptr);
+            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_track_section->get_inner_widget());
+            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
+            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
+            application_audio_invert_checkbox_ptr->set_checked(audio_track.application_audio_invert);
+
+            audio_input_list_ptr->clear();
+            for(const std::string &audio_input : audio_track.audio_inputs) {
+                if(starts_with(audio_input, "app:")) {
+                    if(!gsr_info->system_info.supports_app_audio)
+                        continue;
+
+                    std::string audio_track_name = audio_input.substr(4);
+                    const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name);
+                    if(app_audio) {
+                        std::unique_ptr<List> application_audio_widget = create_application_audio(audio_input_list_ptr);
+                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1));
+                        application_audio_box->set_selected_item(*app_audio);
+                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
+                    } else {
+                        std::unique_ptr<List> application_audio_widget = create_custom_application_audio(audio_input_list_ptr);
+                        Entry *application_audio_entry = dynamic_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1));
+                        application_audio_entry->set_text(std::move(audio_track_name));
+                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
+                    }
+                } else if(starts_with(audio_input, "device:")) {
+                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_input_list_ptr);
+                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
+                    audio_device_box->set_selected_item(audio_input.substr(7));
+                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                 } else {
-                    std::unique_ptr<List> application_audio_widget = create_custom_application_audio();
-                    Entry *application_audio_entry = static_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1));
-                    application_audio_entry->set_text(std::move(audio_track_name));
-                    audio_track_list_ptr->add_widget(std::move(application_audio_widget));
+                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_input_list_ptr);
+                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
+                    audio_device_box->set_selected_item(audio_input);
+                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                 }
-            } else if(starts_with(audio_track, "device:")) {
-                std::unique_ptr<List> audio_track_widget = create_audio_device();
-                ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
-                audio_device_box->set_selected_item(audio_track.substr(7));
-                audio_track_list_ptr->add_widget(std::move(audio_track_widget));
-            } else {
-                std::unique_ptr<List> audio_track_widget = create_audio_device();
-                ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
-                audio_device_box->set_selected_item(audio_track);
-                audio_track_list_ptr->add_widget(std::move(audio_track_widget));
             }
+
+            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));
+
+            if(type == Type::STREAM)
+                break;
+        }
+
+        if(type == Type::STREAM && audio_track_section_list_ptr->get_num_children() == 0) {
+            auto audio_track_section = create_audio_track_section(audio_section_ptr);
+            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));
         }
     }
 
     void SettingsPage::load_common(RecordOptions &record_options) {
         record_area_box_ptr->set_selected_item(record_options.record_area_option);
-        if(split_audio_checkbox_ptr)
-            split_audio_checkbox_ptr->set_checked(!record_options.merge_audio_tracks);
-        application_audio_invert_checkbox_ptr->set_checked(record_options.application_audio_invert);
         change_video_resolution_checkbox_ptr->set_checked(record_options.change_video_resolution);
         load_audio_tracks(record_options);
         color_range_box_ptr->set_selected_item(record_options.color_range);
@@ -1137,28 +1210,38 @@ namespace gsr {
         container_box_ptr->set_selected_item(config.streaming_config.custom.container);
     }
 
-    static void save_audio_tracks(std::vector<std::string> &audio_devices, List *audio_devices_list_ptr) {
-        audio_devices.clear();
-        audio_devices_list_ptr->for_each_child_widget([&audio_devices](std::unique_ptr<Widget> &child_widget) {
-            List *audio_track_line = static_cast<List*>(child_widget.get());
-            const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
-            switch(audio_track_type) {
-                case AudioTrackType::DEVICE: {
-                    ComboBox *audio_device_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("device:" + audio_device_box->get_selected_id());
-                    break;
-                }
-                case AudioTrackType::APPLICATION: {
-                    ComboBox *application_audio_box = static_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("app:" + application_audio_box->get_selected_id());
-                    break;
+    static void save_audio_tracks(std::vector<AudioTrack> &audio_tracks, List *audio_track_section_list_ptr) {
+        audio_tracks.clear();
+        audio_track_section_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget) {
+            Subsection *audio_subsection = dynamic_cast<Subsection*>(child_widget.get());
+            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_subsection->get_inner_widget());
+            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
+            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
+
+            audio_tracks.push_back({std::vector<std::string>{}, application_audio_invert_checkbox_ptr->is_checked()});
+            audio_input_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget){
+                List *audio_track_line = dynamic_cast<List*>(child_widget.get());
+                const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
+                switch(audio_track_type) {
+                    case AudioTrackType::DEVICE: {
+                        ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("device:" + audio_device_box->get_selected_id());
+                        break;
+                    }
+                    case AudioTrackType::APPLICATION: {
+                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("app:" + application_audio_box->get_selected_id());
+                        break;
+                    }
+                    case AudioTrackType::APPLICATION_CUSTOM: {
+                        Entry *application_audio_entry = dynamic_cast<Entry*>(audio_track_line->get_child_widget_by_index(1));
+                        audio_tracks.back().audio_inputs.push_back("app:" + application_audio_entry->get_text());
+                        break;
+                    }
                 }
-                case AudioTrackType::APPLICATION_CUSTOM: {
-                    Entry *application_audio_entry = static_cast<Entry*>(audio_track_line->get_child_widget_by_index(1));
-                    audio_devices.push_back("app:" + application_audio_entry->get_text());
-                    break;
-                }
-            }
+                return true;
+            });
+
             return true;
         });
     }
@@ -1171,11 +1254,8 @@ namespace gsr {
         record_options.video_height = atoi(video_height_entry_ptr->get_text().c_str());
         record_options.fps = atoi(framerate_entry_ptr->get_text().c_str());
         record_options.video_bitrate = atoi(video_bitrate_entry_ptr->get_text().c_str());
-        if(split_audio_checkbox_ptr)
-            record_options.merge_audio_tracks = !split_audio_checkbox_ptr->is_checked();
-        record_options.application_audio_invert = application_audio_invert_checkbox_ptr->is_checked();
         record_options.change_video_resolution = change_video_resolution_checkbox_ptr->is_checked();
-        save_audio_tracks(record_options.audio_tracks, audio_track_list_ptr);
+        save_audio_tracks(record_options.audio_tracks_list, audio_track_section_list_ptr);
         record_options.color_range = color_range_box_ptr->get_selected_id();
         record_options.video_quality = video_quality_box_ptr->get_selected_id();
         record_options.video_codec = video_codec_box_ptr->get_selected_id();
diff --git a/src/gui/StaticPage.cpp b/src/gui/StaticPage.cpp
index 182464c..5147819 100644
--- a/src/gui/StaticPage.cpp
+++ b/src/gui/StaticPage.cpp
@@ -20,8 +20,9 @@ namespace gsr {
 
         // Process widgets by visibility (backwards)
         return widgets.for_each_reverse([selected_widget, &window, &event, offset](std::unique_ptr<Widget> &widget) {
-            if(widget.get() != selected_widget) {
-                if(!widget->on_event(event, window, offset))
+            Widget *p = widget.get();
+            if(p != selected_widget) {
+                if(!p->on_event(event, window, offset))
                     return false;
             }
             return true;
diff --git a/src/gui/Subsection.cpp b/src/gui/Subsection.cpp
index c97460e..bc75a9c 100644
--- a/src/gui/Subsection.cpp
+++ b/src/gui/Subsection.cpp
@@ -12,12 +12,17 @@ namespace gsr {
     static const float title_spacing_scale = 0.010f;
 
     Subsection::Subsection(const char *title, std::unique_ptr<Widget> inner_widget, mgl::vec2f size) :
-        label(&get_theme().title_font, title, get_color_theme().text_color),
+        label(&get_theme().title_font, title ? title : "", get_color_theme().text_color),
         inner_widget(std::move(inner_widget)),
         size(size)
     {
         this->inner_widget->parent_widget = this;
     }
+
+    Subsection::~Subsection() {
+        if(inner_widget->parent_widget == this)
+            inner_widget->parent_widget = nullptr;
+    }
     
     bool Subsection::on_event(mgl::Event &event, mgl::Window &window, mgl::vec2f) {
         if(!visible)
@@ -32,7 +37,7 @@ namespace gsr {
 
         mgl::vec2f draw_pos = position + offset;
         mgl::Rectangle background(draw_pos.floor(), get_size().floor());
-        background.set_color(mgl::Color(25, 30, 34));
+        background.set_color(bg_color);
         window.draw(background);
 
         draw_pos += mgl::vec2f(margin_left_scale, margin_top_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
@@ -69,4 +74,12 @@ namespace gsr {
         const mgl::vec2f margin_size = mgl::vec2f(margin_left_scale + margin_right_scale, margin_top_scale + margin_bottom_scale) * mgl::vec2f(get_theme().window_height, get_theme().window_height);
         return get_size() - margin_size;
     }
+
+    Widget* Subsection::get_inner_widget() {
+        return inner_widget.get();
+    }
+
+    void Subsection::set_bg_color(mgl::Color color) {
+        bg_color = color;
+    }
 }
\ No newline at end of file
diff --git a/src/gui/Widget.cpp b/src/gui/Widget.cpp
index 8732bd7..66cf193 100644
--- a/src/gui/Widget.cpp
+++ b/src/gui/Widget.cpp
@@ -1,14 +1,15 @@
 #include "../../include/gui/Widget.hpp"
+#include <vector>
 
 namespace gsr {
+    static std::vector<std::unique_ptr<Widget>> widgets_to_remove;
+
     Widget::Widget() {
         
     }
 
     Widget::~Widget() {
         remove_widget_as_selected_in_parent();
-        // if(parent_widget)
-        //     parent_widget->remove_child_widget(this);
     }
 
     void Widget::set_position(mgl::vec2f position) {
@@ -62,4 +63,15 @@ namespace gsr {
     void Widget::set_visible(bool visible) {
         this->visible = visible;
     }
+
+    void add_widget_to_remove(std::unique_ptr<Widget> widget) {
+        widgets_to_remove.push_back(std::move(widget));
+    }
+
+    void remove_widgets_to_be_removed() {
+        for(size_t i = 0; i < widgets_to_remove.size(); ++i) {
+            widgets_to_remove[i].reset();
+        }
+        widgets_to_remove.clear();
+    }
 }
\ No newline at end of file
diff --git a/src/main.cpp b/src/main.cpp
index 7c10a6e..9cb0ede 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -235,7 +235,7 @@ int main(int argc, char **argv) {
         disable_prime_run();
     }
 
-    if(mgl_init() != 0) {
+    if(mgl_init(MGL_WINDOW_SYSTEM_X11) != 0) {
         fprintf(stderr, "Error: failed to initialize mgl. Failed to either connect to the X11 server or setup opengl\n");
         exit(1);
     }
@@ -303,10 +303,10 @@ int main(int argc, char **argv) {
     if(exit_reason == "back-to-old-ui") {
         const char *args[] = { "gpu-screen-recorder-gtk", "use-old-ui", nullptr };
         execvp(args[0], (char* const*)args);
-    } else if(exit_reason == "restart") {
-        const char *args[] = { "gsr-ui", "launch-show", nullptr };
-        execvp(args[0], (char* const*)args);
+        return 0;
+    } else if(exit_reason == "exit") {
+        return 0;
     }
 
-    return 0;
+    return mgl_is_connected_to_display_server() ? 0 : 1;
 }