Replace sfml with mgl

1 files changed, 675 insertions, 740 deletions

diff --git a/src/QuickMedia.cpp b/src/QuickMedia.cpp
index 69252fa..1a7f67a 100644
--- a/src/QuickMedia.cpp
+++ b/src/QuickMedia.cpp
@@ -29,7 +29,6 @@
 #include "../external/cppcodec/base64_url.hpp"
 #include "../include/Entry.hpp"
 #include "../include/NetUtils.hpp"
-#include "../include/SfmlFixes.hpp"
 #include "../include/ResourceLoader.hpp"
 #include "../include/Config.hpp"
 #include "../include/Tabs.hpp"
@@ -38,6 +37,7 @@
 #include "../include/Downloader.hpp"
 #include "../include/Storage.hpp"
 #include "../include/AsyncImageLoader.hpp"
+#include <mglpp/system/FloatRect.hpp>
 #include "../plugins/youtube/YoutubeMediaProxy.hpp"
 #include "../include/gui/Button.hpp"
 #include "../external/hash-library/sha256.h"
@@ -51,19 +51,22 @@
 #include <libgen.h>
 #include <limits.h>
 
-#include <SFML/Graphics/RectangleShape.hpp>
-#include <SFML/Window/Clipboard.hpp>
-#include <SFML/Graphics/Sprite.hpp>
-#include <SFML/Graphics/Text.hpp>
-#include <SFML/Window/Event.hpp>
+#include <mglpp/graphics/Rectangle.hpp>
+#include <mglpp/graphics/Sprite.hpp>
+#include <mglpp/graphics/Text.hpp>
+#include <mglpp/window/Event.hpp>
+extern "C" {
+#include <mgl/mgl.h>
+}
 #include <json/reader.h>
 #include <json/writer.h>
 #include <X11/keysym.h>
 #include <X11/extensions/Xrandr.h>
+#include <X11/Xatom.h>
 
 static int FPS_IDLE;
 static const double IDLE_TIMEOUT_SEC = 2.0;
-static const sf::Vector2i AVATAR_THUMBNAIL_SIZE(std::floor(32), std::floor(32));
+static const mgl::vec2i AVATAR_THUMBNAIL_SIZE(std::floor(32), std::floor(32));
 static const float more_items_height = 2.0f;
 
 static const std::pair<const char*, const char*> valid_plugins[] = {
@@ -181,12 +184,12 @@ static void get_screen_resolution(Display *display, int *width, int *height) {
     *height = DefaultScreenOfDisplay(display)->height;
 }
 
-static sf::Color interpolate_colors(sf::Color source, sf::Color target, double progress) {
+static mgl::Color interpolate_colors(mgl::Color source, mgl::Color target, double progress) {
     int diff_r = (int)target.r - (int)source.r;
     int diff_g = (int)target.g - (int)source.g;
     int diff_b = (int)target.b - (int)source.b;
     int diff_a = (int)target.a - (int)source.a;
-    return sf::Color(
+    return mgl::Color(
         source.r + diff_r * progress,
         source.g + diff_g * progress,
         source.b + diff_b * progress,
@@ -505,6 +508,7 @@ namespace QuickMedia {
         };
 
         no_video = force_no_video;
+        mgl_init();
         init(parent_window, program_path);
 
         if(strcmp(plugin_name, "download") == 0) {
@@ -555,20 +559,31 @@ namespace QuickMedia {
         return exit_code;
     }
 
-    static sf::Vector2i get_focused_monitor_center(Display *disp, sf::Vector2i &monitor_size) {
+    // TODO: Move to mgl
+    static mgl::vec2i get_global_mouse_position(Display *display) {
+        Window dummy_w;
+        int dummy_i;
+        unsigned int dummy_u;
+
+        mgl::vec2i mouse_pos;
+        XQueryPointer(display, DefaultRootWindow(display), &dummy_w, &dummy_w, &mouse_pos.x, &mouse_pos.y, &dummy_i, &dummy_i, &dummy_u);
+        return mouse_pos;
+    }
+
+    static mgl::vec2i get_focused_monitor_center(Display *disp, mgl::vec2i &monitor_size) {
         int screen = DefaultScreen(disp);
         monitor_size.x = DisplayWidth(disp, screen);
         monitor_size.y = DisplayWidth(disp, screen);
         int screen_center_x = monitor_size.x / 2;
         int screen_center_y = monitor_size.y / 2;
 
-        sf::Vector2i focused_monitor_center(screen_center_x, screen_center_y);
-        auto mouse_pos = sf::Mouse::getPosition();
+        mgl::vec2i focused_monitor_center(screen_center_x, screen_center_y);
+        mgl::vec2i mouse_pos = get_global_mouse_position(disp);
         for_each_active_monitor_output(disp, [&focused_monitor_center, mouse_pos, &monitor_size](const XRRCrtcInfo *crtc_info, const XRRModeInfo*){
-            if(sf::Rect<int>(crtc_info->x, crtc_info->y, crtc_info->width, crtc_info->height).contains(mouse_pos)) {
+            if(mgl::Rect<int>(mgl::vec2i(crtc_info->x, crtc_info->y), mgl::vec2i(crtc_info->width, crtc_info->height)).contains(mouse_pos)) {
                 monitor_size.x = crtc_info->width;
                 monitor_size.y = crtc_info->height;
-                focused_monitor_center = sf::Vector2i(crtc_info->x + crtc_info->width/2, crtc_info->y + crtc_info->height/2);
+                focused_monitor_center = mgl::vec2i(crtc_info->x + crtc_info->width/2, crtc_info->y + crtc_info->height/2);
             }
         });
 
@@ -585,51 +600,26 @@ namespace QuickMedia {
         XSetErrorHandler(x_error_handler);
         XSetIOErrorHandler(x_io_error_handler);
 
-        wm_delete_window_atom = XInternAtom(disp, "WM_DELETE_WINDOW", False);
-        net_wm_ping_atom = XInternAtom(disp, "_NET_WM_PING", True);
-
-        int screen = DefaultScreen(disp);
-        sf::Vector2i monitor_size;
-        sf::Vector2i focused_monitor_center = get_focused_monitor_center(disp, monitor_size);
+        mgl::vec2i monitor_size;
+        mgl::vec2i focused_monitor_center = get_focused_monitor_center(disp, monitor_size);
 
         if(strcmp(plugin_name, "download") == 0) {
             window_size.x = std::min(900, monitor_size.x);
             window_size.y = std::min(900, monitor_size.y);
         }
 
-        x11_window = XCreateWindow(disp, parent_window ? parent_window : DefaultRootWindow(disp),
-                            focused_monitor_center.x - window_size.x * 0.5f, focused_monitor_center.y - window_size.y * 0.5f, window_size.x, window_size.y, 0,
-                            DefaultDepth(disp, screen),
-                            InputOutput,
-                            DefaultVisual(disp, screen),
-                            0, nullptr);
-        if(!x11_window) {
-            show_notification("QuickMedia", "Failed to create window", Urgency::CRITICAL);
-            abort();
-        }
-
+        mgl::Window::CreateParams window_create_params;
+        window_create_params.position = { focused_monitor_center.x - window_size.x / 2, focused_monitor_center.y - window_size.y / 2 };
+        window_create_params.size = window_size;
         if(strcmp(plugin_name, "download") == 0) {
-            XSizeHints *size_hints = XAllocSizeHints();
-            if(size_hints) {
-                size_hints->width = window_size.x;
-                size_hints->min_width = window_size.x;
-                size_hints->max_width = window_size.x;
-
-                size_hints->height = window_size.y;
-                size_hints->min_height = window_size.y;
-                size_hints->max_height = window_size.y;
-                size_hints->flags = PSize | PMinSize | PMaxSize;
-
-                XSetWMNormalHints(disp, x11_window, size_hints);
-                XFree(size_hints);
-            }
+            window_create_params.min_size = window_size;
+            window_create_params.max_size = window_size;
+        }
+        window_create_params.parent_window = parent_window;
+        if(!window.create("QuickMedia", std::move(window_create_params))) {
+            show_notification("QuickMedia", "Failed to create opengl window", Urgency::CRITICAL);
+            abort();
         }
-
-        XStoreName(disp, x11_window, "QuickMedia");
-        XMapWindow(disp, x11_window);
-        XFlush(disp);
-
-        window.create(x11_window);
 
         if(!program_path.empty() && program_path.back() != '/')
             program_path += '/';
@@ -641,39 +631,39 @@ namespace QuickMedia {
 
         set_resource_loader_root_path(resources_root.c_str());
         set_use_system_fonts(get_config().use_system_fonts);
+        init_body_themes();
 
         if(!is_touch_enabled()) {
-            if(!circle_mask_shader.loadFromFile(resources_root + "shaders/circle_mask.glsl", sf::Shader::Type::Fragment)) {
+            if(!circle_mask_shader.load_from_file((resources_root + "shaders/circle_mask.glsl").c_str(), mgl::Shader::Type::Fragment)) {
                 show_notification("QuickMedia", "Failed to load " + resources_root + "/shaders/circle_mask.glsl", Urgency::CRITICAL);
                 abort();
             }
 
             if(get_theme().drop_shadow) {
-                if(!rounded_rectangle_shader.loadFromFile(resources_root + "shaders/rounded_rectangle.glsl", sf::Shader::Type::Fragment)) {
+                if(!rounded_rectangle_shader.load_from_file((resources_root + "shaders/rounded_rectangle.glsl").c_str(), mgl::Shader::Type::Fragment)) {
                     show_notification("QuickMedia", "Failed to load " + resources_root + "/shaders/rounded_rectangle.glsl", Urgency::CRITICAL);
                     abort();
                 }
             } else {
-                if(!rounded_rectangle_shader.loadFromFile(resources_root + "shaders/rounded_rectangle_no_shadow.glsl", sf::Shader::Type::Fragment)) {
+                if(!rounded_rectangle_shader.load_from_file((resources_root + "shaders/rounded_rectangle_no_shadow.glsl").c_str(), mgl::Shader::Type::Fragment)) {
                     show_notification("QuickMedia", "Failed to load " + resources_root + "/shaders/rounded_rectangle_no_shadow.glsl", Urgency::CRITICAL);
                     abort();
                 }
             }
 
-            if(!rounded_rectangle_mask_shader.loadFromFile(resources_root + "shaders/rounded_rectangle_mask.glsl", sf::Shader::Type::Fragment)) {
+            if(!rounded_rectangle_mask_shader.load_from_file((resources_root + "shaders/rounded_rectangle_mask.glsl").c_str(), mgl::Shader::Type::Fragment)) {
                 show_notification("QuickMedia", "Failed to load " + resources_root + "/shaders/rounded_rectangle_mask.glsl", Urgency::CRITICAL);
                 abort();
             }
         }
 
-        if(!loading_icon.loadFromFile(resources_root + "images/loading_icon.png")) {
+        if(!loading_icon.load_from_file((resources_root + "images/loading_icon.png").c_str())) {
             show_notification("QuickMedia", "Failed to load " + resources_root + "/images/loading_icon.png", Urgency::CRITICAL);
             abort();
         }
-        loading_icon.setSmooth(true);
-        load_sprite.setTexture(loading_icon, true);
-        sf::Vector2u loading_icon_size = loading_icon.getSize();
-        load_sprite.setOrigin(loading_icon_size.x * 0.5f, loading_icon_size.y * 0.5f);
+        load_sprite.set_texture(&loading_icon);
+        mgl::vec2i loading_icon_size = loading_icon.get_size();
+        load_sprite.set_origin(mgl::vec2f(loading_icon_size.x * 0.5f, loading_icon_size.y * 0.5f));
 
         struct sigaction action;
         action.sa_handler = sigpipe_handler;
@@ -684,9 +674,8 @@ namespace QuickMedia {
         XSetErrorHandler(x_error_handler);
         XSetIOErrorHandler(x_io_error_handler);
 
-        window.setVerticalSyncEnabled(true);
         monitor_hz = get_monitor_max_hz(disp);
-        window.setFramerateLimit(monitor_hz);
+        window.set_framerate_limit(monitor_hz);
         idle = false;
         fprintf(stderr, "Monitor hz: %d\n", monitor_hz);
 
@@ -717,7 +706,7 @@ namespace QuickMedia {
             show_room_side_panel = true;
 
         main_thread_id = std::this_thread::get_id();
-        auto window_size_u = window.getSize();
+        auto window_size_u = window.get_size();
         window_size.x = window_size_u.x;
         window_size.y = window_size_u.y;
     }
@@ -1038,7 +1027,7 @@ namespace QuickMedia {
         if(!plugin_name || plugin_name[0] == '\0')
             return;
 
-        window.setTitle("QuickMedia - " + std::string(plugin_name));
+        window.set_title(("QuickMedia - " + std::string(plugin_name)).c_str());
         no_video = force_no_video;
 
         if(strcmp(plugin_name, "youtube-audio") == 0) {
@@ -1051,12 +1040,12 @@ namespace QuickMedia {
         if(plugin_logo_name)
             plugin_logo_path = resources_root + "images/" + plugin_logo_name;
 
-        plugin_logo = sf::Texture();
+        plugin_logo = mgl::Texture();
         if(!plugin_logo_path.empty()) {
-            if(!plugin_logo.loadFromFile(plugin_logo_path))
+            if(!plugin_logo.load_from_file(plugin_logo_path.c_str()))
                 fprintf(stderr, "Failed to load plugin logo, path: %s\n", plugin_logo_path.c_str());
-            plugin_logo.generateMipmap();
-            plugin_logo.setSmooth(true);
+            // TODO: Fix
+            //plugin_logo.generateMipmap();
         }
 
         if(strcmp(plugin_name, "launcher") == 0) {
@@ -1253,13 +1242,13 @@ namespace QuickMedia {
             }
         } else if(strcmp(plugin_name, "pornhub") == 0) {
             check_youtube_dl_installed(plugin_name);
-            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://www.pornhub.com/", sf::Vector2i(320/1.5f, 180/1.5f), false);
+            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://www.pornhub.com/", mgl::vec2i(320/1.5f, 180/1.5f), false);
             add_pornhub_handlers(search_page.get());
             tabs.push_back(Tab{create_body(false, true), std::move(search_page), create_search_bar("Search...", 500)});
             use_youtube_dl = true;
         } else if(strcmp(plugin_name, "spankbang") == 0) {
             check_youtube_dl_installed(plugin_name);
-            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://spankbang.com/", sf::Vector2i(500/2.5f, 281/2.5f), true);
+            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://spankbang.com/", mgl::vec2i(500/2.5f, 281/2.5f), true);
             add_spankbang_handlers(search_page.get());
             tabs.push_back(Tab{create_body(false, true), std::move(search_page), create_search_bar("Search...", 500)});
             use_youtube_dl = true;
@@ -1269,13 +1258,13 @@ namespace QuickMedia {
             std::vector<CommandArg> extra_commands = {
                 { "-H", "Cookie: last_views=%5B%2236247565-" + std::to_string(time(nullptr)) + "%22%5D" }
             };
-            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://www.xvideos.com/", sf::Vector2i(352/1.5f, 198/1.5f), false, std::move(extra_commands));
+            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://www.xvideos.com/", mgl::vec2i(352/1.5f, 198/1.5f), false, std::move(extra_commands));
             add_xvideos_handlers(search_page.get());
             tabs.push_back(Tab{create_body(false, true), std::move(search_page), create_search_bar("Search...", 500)});
             use_youtube_dl = true;
         } else if(strcmp(plugin_name, "xhamster") == 0) {
             check_youtube_dl_installed(plugin_name);
-            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://xhamster.com/", sf::Vector2i(240, 135), false);
+            auto search_page = std::make_unique<MediaGenericSearchPage>(this, "https://xhamster.com/", mgl::vec2i(240, 135), false);
             add_xhamster_handlers(search_page.get());
             tabs.push_back(Tab{create_body(false, true), std::move(search_page), create_search_bar("Search...", 500)});
             use_youtube_dl = true;
@@ -1296,53 +1285,44 @@ namespace QuickMedia {
         }
     }
 
-    void Program::common_event_handler(sf::Event &event) {
-        if(event.type == sf::Event::KeyPressed) {
-            if(event.key.code == sf::Keyboard::Q && event.key.control)
+    void Program::common_event_handler(mgl::Event &event) {
+        if(event.type == mgl::Event::KeyPressed) {
+            if(event.key.code == mgl::Keyboard::Q && event.key.control)
                 window.close();
         }
     }
 
     void Program::handle_x11_events() {
-        window_closed = false;
-
-        while(XCheckTypedWindowEvent(disp, x11_window, ClientMessage, &xev)) {
-            if(net_wm_ping_atom && xev.xclient.format == 32 && (Atom)xev.xclient.data.l[0] == net_wm_ping_atom) {
-                fprintf(stderr, "Responding to X11 ping\n");
-                xev.xclient.window = DefaultRootWindow(disp);
-                XSendEvent(disp, DefaultRootWindow(disp), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
-            } else if(wm_delete_window_atom && xev.xclient.format == 32 && (Atom)xev.xclient.data.l[0] == wm_delete_window_atom) {
-                current_page = PageType::EXIT;
-                window.close();
-                window_closed = true;
-            }
+        if(window.is_open()) {
+            window_closed = false;
+        } else {
+            window_closed = true;
+            current_page = PageType::EXIT;
         }
     }
 
-    void Program::base_event_handler(sf::Event &event, PageType previous_page, Body *body, SearchBar *search_bar, bool handle_keypress, bool handle_searchbar) {
-        if(event.type == sf::Event::Resized) {
+    void Program::base_event_handler(mgl::Event &event, PageType previous_page, Body *body, SearchBar *search_bar, bool handle_keypress, bool handle_searchbar) {
+        if(event.type == mgl::Event::Resized) {
             window_size.x = event.size.width;
             window_size.y = event.size.height;
-            sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-            window.setView(sf::View(visible_area));
-        } else if(handle_keypress && event.type == sf::Event::KeyPressed) {
-            if(event.key.code == sf::Keyboard::Escape) {
+        } else if(handle_keypress && event.type == mgl::Event::KeyPressed) {
+            if(event.key.code == mgl::Keyboard::Escape) {
                 current_page = previous_page;
             }
         } else if(handle_searchbar) {
             assert(search_bar);
-            search_bar->on_event(event);
+            search_bar->on_event(window, event);
         }
     }
 
-    void Program::event_idle_handler(const sf::Event &event) {
-        if(event.type == sf::Event::KeyPressed || event.type == sf::Event::TextEntered)
+    void Program::event_idle_handler(const mgl::Event &event) {
+        if(event.type == mgl::Event::KeyPressed || event.type == mgl::Event::TextEntered)
             idle_active_handler();
     }
 
     void Program::idle_active_handler() {
         if(idle)
-            window.setFramerateLimit(monitor_hz);
+            window.set_framerate_limit(monitor_hz);
         idle = false;
         idle_timer.restart();
     }
@@ -1351,8 +1331,8 @@ namespace QuickMedia {
         if(idle)
             return;
 
-        if(idle_timer.getElapsedTime().asSeconds() > IDLE_TIMEOUT_SEC) {
-            window.setFramerateLimit(FPS_IDLE);
+        if(idle_timer.get_elapsed_time_seconds() > IDLE_TIMEOUT_SEC) {
+            window.set_framerate_limit(FPS_IDLE);
             idle = true;
         }
     }
@@ -1391,7 +1371,7 @@ namespace QuickMedia {
             body_item->thumbnail_url = "https://img.youtube.com/vi/" + video_id_str + "/mqdefault.jpg";
             body_item->set_description("Watched " + seconds_to_relative_time_str(time_now - timestamp.asInt64()));
             body_item->set_description_color(get_theme().faded_text_color);
-            body_item->thumbnail_size = sf::Vector2i(192, 108);
+            body_item->thumbnail_size = mgl::vec2i(192, 108);
             history_items.push_back(std::move(body_item));
         }
 
@@ -1428,6 +1408,10 @@ namespace QuickMedia {
         return json_result;
     }
 
+    void Program::set_clipboard(const std::string &str) {
+        window.set_clipboard(str);
+    }
+
     void Program::manga_get_watch_history(const char *plugin_name, BodyItems &history_items) {
         // TOOD: Make generic, instead of checking for plugin
         Path content_storage_dir = get_storage_dir().join(plugin_name);
@@ -1492,7 +1476,7 @@ namespace QuickMedia {
         fill_history_items_from_json(load_video_history_json(), history_items);
     }
 
-    static void get_body_dimensions(const sf::Vector2f &window_size, SearchBar *search_bar, sf::Vector2f &body_pos, sf::Vector2f &body_size, bool has_tabs = false) {
+    static void get_body_dimensions(const mgl::vec2i &window_size, SearchBar *search_bar, mgl::vec2f &body_pos, mgl::vec2f &body_size, bool has_tabs = false) {
         const float body_width = window_size.x;
 
         float tab_h = Tabs::get_shade_height();
@@ -1503,12 +1487,12 @@ namespace QuickMedia {
             tab_h = 0.0f;
 
         float search_bottom = search_bar ? search_bar->getBottomWithoutShadow() : 0.0f;
-        body_pos = sf::Vector2f(0.0f, search_bottom + tab_h);
-        body_size = sf::Vector2f(body_width, window_size.y - search_bottom - tab_h);
+        body_pos = mgl::vec2f(0.0f, search_bottom + tab_h);
+        body_size = mgl::vec2f(body_width, window_size.y - search_bottom - tab_h);
     }
 
     std::unique_ptr<Body> Program::create_body(bool plain_text_list, bool prefer_card_view) {
-        if(rounded_rectangle_mask_shader.getNativeHandle() == 0)
+        if(!rounded_rectangle_mask_shader.is_valid())
             plain_text_list = true;
         auto body = std::make_unique<Body>(plain_text_list ? BODY_THEME_MINIMAL : BODY_THEME_MODERN_SPACIOUS, loading_icon, &rounded_rectangle_shader, &rounded_rectangle_mask_shader);
         body->card_view = prefer_card_view;
@@ -1518,7 +1502,7 @@ namespace QuickMedia {
 
     std::unique_ptr<SearchBar> Program::create_search_bar(const std::string &placeholder, int search_delay) {
         auto search_bar = std::make_unique<SearchBar>(&plugin_logo, &rounded_rectangle_shader, placeholder);
-        search_bar->text_autosearch_delay = search_delay;
+        search_bar->text_autosearch_delay_ms = search_delay;
         return search_bar;
     }
 
@@ -1556,7 +1540,7 @@ namespace QuickMedia {
     }
 
     bool Program::is_window_focused() {
-        return window.hasFocus();
+        return window.has_focus();
     }
 
     RoomData* Program::get_current_chat_room() {
@@ -1686,38 +1670,38 @@ namespace QuickMedia {
         return true;
     }
 
-    void Program::page_loop_render(sf::RenderWindow &window, std::vector<Tab> &tabs, int selected_tab, TabAssociatedData &tab_associated_data, const Json::Value *json_chapters, Tabs &ui_tabs) {
-        if(tabs[selected_tab].search_bar) tabs[selected_tab].search_bar->draw(window, window_size, true);
+    void Program::page_loop_render(mgl::Window &window, std::vector<Tab> &tabs, int selected_tab, TabAssociatedData &tab_associated_data, const Json::Value *json_chapters, Tabs &ui_tabs) {
+        if(tabs[selected_tab].search_bar) tabs[selected_tab].search_bar->draw(window, window_size.to_vec2f(), true);
 
         float shade_extra_height = 0.0f;
         if(!tabs[selected_tab].search_bar) {
             shade_extra_height = std::floor(10.0f * get_config().scale);
-            sf::RectangleShape shade_top(sf::Vector2f(window_size.x, shade_extra_height));
-            shade_top.setFillColor(get_theme().shade_color);
+            mgl::Rectangle shade_top(mgl::vec2f(window_size.x, shade_extra_height));
+            shade_top.set_color(get_theme().shade_color);
             window.draw(shade_top);
         }
 
         float tab_vertical_offset = tabs[selected_tab].search_bar ? tabs[selected_tab].search_bar->getBottomWithoutShadow() : 0.0f;
-        ui_tabs.draw(window, sf::Vector2f(0.0f, tab_vertical_offset + shade_extra_height), window_size.x);
+        ui_tabs.draw(window, mgl::vec2f(0.0f, tab_vertical_offset + shade_extra_height), window_size.x);
         tabs[selected_tab].body->draw(window, body_pos, body_size, *json_chapters);
 
         if(tab_associated_data.fetching_next_page_running)
-            window.draw(gradient_points, 4, sf::Quads); // TODO: sf::Quads doesn't work with egl
+            window.draw(gradient_points, 4, mgl::PrimitiveType::Quads); // TODO: mgl::PrimitiveType::Quads doesn't work with egl
 
-        if(!tab_associated_data.search_result_text.getString().isEmpty() && !tabs[selected_tab].page->search_is_suggestion()) {
-            auto search_result_text_bounds = tab_associated_data.search_result_text.getLocalBounds();
-            tab_associated_data.search_result_text.setPosition(
-                std::floor(body_pos.x + body_size.x * 0.5f - search_result_text_bounds.width * 0.5f),
-                std::floor(body_pos.y + body_size.y * 0.5f - search_result_text_bounds.height * 0.5f));
+        if(!tab_associated_data.search_result_text.get_string().empty() && !tabs[selected_tab].page->search_is_suggestion()) {
+            auto search_result_text_bounds = tab_associated_data.search_result_text.get_bounds();
+            tab_associated_data.search_result_text.set_position(mgl::vec2f(
+                std::floor(body_pos.x + body_size.x * 0.5f - search_result_text_bounds.size.x * 0.5f),
+                std::floor(body_pos.y + body_size.y * 0.5f - search_result_text_bounds.size.y * 0.5f)));
             window.draw(tab_associated_data.search_result_text);
         }
 
         if(!tabs[selected_tab].page->is_ready()) {
-            sf::Text loading_text("Loading...", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(30 * get_config().scale * get_config().font_scale));
-            auto text_bounds = loading_text.getLocalBounds();
-            loading_text.setPosition(
-                std::floor(body_pos.x + body_size.x * 0.5f - text_bounds.width * 0.5f),
-                std::floor(body_pos.y + body_size.y * 0.5f - text_bounds.height * 0.5f));
+            mgl::Text loading_text("Loading...", *FontLoader::get_font(FontLoader::FontType::LATIN, 30 * get_config().scale * get_config().font_scale));
+            auto text_bounds = loading_text.get_bounds();
+            loading_text.set_position(mgl::vec2f(
+                std::floor(body_pos.x + body_size.x * 0.5f - text_bounds.size.x * 0.5f),
+                std::floor(body_pos.y + body_size.y * 0.5f - text_bounds.size.y * 0.5f)));
             window.draw(loading_text);
         }
 
@@ -1726,8 +1710,8 @@ namespace QuickMedia {
 
         if(matrix && !matrix->is_initial_sync_finished()) {
             // if(is_login_sync) {
-                load_sprite.setPosition(body_pos.x + body_size.x * 0.5f, body_pos.y + body_size.y * 0.5f);
-                load_sprite.setRotation(load_sprite_timer.getElapsedTime().asSeconds() * 400.0);
+                load_sprite.set_position(mgl::vec2f(body_pos.x + body_size.x * 0.5f, body_pos.y + body_size.y * 0.5f));
+                load_sprite.set_rotation(load_sprite_timer.get_elapsed_time_seconds() * 400.0);
                 window.draw(load_sprite);
             // }
             std::string err_msg;
@@ -1796,28 +1780,28 @@ namespace QuickMedia {
         std::vector<TabAssociatedData> tab_associated_data;
         for(size_t i = 0; i < tabs.size(); ++i) {
             TabAssociatedData data;
-            data.search_result_text = sf::Text("", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(30 * get_config().scale * get_config().font_scale));
+            data.search_result_text = mgl::Text("", *FontLoader::get_font(FontLoader::FontType::LATIN, 30 * get_config().scale * get_config().font_scale));
             tab_associated_data.push_back(std::move(data));
         }
 
         double gradient_inc = 0.0;
         const float gradient_height = 5.0f;
 
-        auto window_size_u = window.getSize();
+        auto window_size_u = window.get_size();
         window_size.x = window_size_u.x;
         window_size.y = window_size_u.y;
 
         std::function<void(const std::string&)> submit_handler = [this, &submit_handler, &after_submit_handler, &tabs, &tab_associated_data, &ui_tabs, &loop_running, &redraw](const std::string &search_text) {
-            sf::Event event;
-            while(window.pollEvent(event)) { common_event_handler(event); }
+            mgl::Event event;
+            while(window.poll_event(event)) { common_event_handler(event); }
 
             const int selected_tab = ui_tabs.get_selected();
             auto selected_item = tabs[selected_tab].body->get_selected_shared();
             if(!selected_item && search_text.empty())
                 return;
 
-            if(tabs[selected_tab].page->allow_submit_no_selection() && (sf::Keyboard::isKeyPressed(sf::Keyboard::LControl) || sf::Keyboard::isKeyPressed(sf::Keyboard::RControl)))
-                selected_item = nullptr;
+            if(tabs[selected_tab].page->allow_submit_no_selection() && (window.is_key_pressed(mgl::Keyboard::LControl) || window.is_key_pressed(mgl::Keyboard::RControl)))
+               selected_item = nullptr;
             
             if(!selected_item && !tabs[selected_tab].page->allow_submit_no_selection())
                 return;
@@ -1925,7 +1909,7 @@ namespace QuickMedia {
                 tabs[selected_tab].search_bar->clear();
                 chapters_body->filter_search_fuzzy(""); // Needed (or not really) to go to the next chapter when reaching the last page of a chapter
                 MangaImagesPage *manga_images_page = static_cast<MangaImagesPage*>(new_tabs[0].page.get());
-                window.setKeyRepeatEnabled(false);
+                window.set_key_repeat_enabled(false);
                 downloading_chapter_url.clear();
 
                 Path manga_progress_dir = get_storage_dir().join(manga_images_page->get_service_name());
@@ -1933,7 +1917,7 @@ namespace QuickMedia {
                     show_notification("QuickMedia", "Failed to create directory: " + manga_progress_dir.data, Urgency::CRITICAL);
                     current_page = pop_page_stack();
                 } else {
-                    while(window.isOpen() && (current_page == PageType::IMAGES || current_page == PageType::IMAGES_CONTINUOUS)) {
+                    while(window.is_open() && (current_page == PageType::IMAGES || current_page == PageType::IMAGES_CONTINUOUS)) {
                         if(current_page == PageType::IMAGES) {
                             while(current_page == PageType::IMAGES) {
                                 int page_navigation = image_page(manga_images_page, chapters_body);
@@ -1963,7 +1947,7 @@ namespace QuickMedia {
                 image_download_cancel = false;
                 images_to_upscale_queue.clear();
                 num_manga_pages = 0;
-                window.setKeyRepeatEnabled(true);
+                window.set_key_repeat_enabled(true);
                 malloc_trim(0);
             } else if(new_tabs.size() == 1 && new_tabs[0].page->get_type() == PageTypez::IMAGE_BOARD_THREAD) {
                 page_stack.push(current_page);
@@ -1986,7 +1970,7 @@ namespace QuickMedia {
                 current_chat_room = matrix->get_room_by_id(tmp_matrix_chat_page->room_id);
 
                 rooms_page->body->show_drop_shadow = false;
-                while(window.isOpen() && current_chat_room) {
+                while(window.is_open() && current_chat_room) {
                     auto matrix_chat_page = std::make_unique<MatrixChatPage>(this, current_chat_room->id, rooms_page, jump_to_event_id);
                     bool move_room = chat_page(matrix_chat_page.get(), current_chat_room);
                     matrix_chat_page->messages_tab_visible = false;
@@ -2037,7 +2021,7 @@ namespace QuickMedia {
                 int next_page = tab_associated_data[selected_tab].fetched_page + 1;
                 Page *page = tabs[selected_tab].page.get();
                 std::string update_search_text = tab_associated_data[selected_tab].update_search_text;
-                tab_associated_data[selected_tab].next_page_future = AsyncTask<BodyItems>([update_search_text, next_page, page]() {
+                tab_associated_data[selected_tab].next_page_future = AsyncTask<BodyItems>([update_search_text{std::move(update_search_text)}, next_page, page]() {
                     BodyItems result_items;
                     if(page->get_page(update_search_text, next_page, result_items) != PluginResult::OK)
                         fprintf(stderr, "Failed to get next page (page %d)\n", next_page);
@@ -2082,12 +2066,12 @@ namespace QuickMedia {
             }
         }
 
-        sf::Event event;
-        sf::Clock frame_timer;
+        mgl::Event event;
+        mgl::Clock frame_timer;
 
-        while (window.isOpen() && loop_running) {
-            sf::Int32 frame_time_ms = frame_timer.restart().asMilliseconds();
-            while (window.pollEvent(event)) {
+        while (window.is_open() && loop_running) {
+            int32_t frame_time_ms = frame_timer.restart() * 1000.0;
+            while (window.poll_event(event)) {
                 common_event_handler(event);
                 const int selected_tab = ui_tabs.get_selected();
 
@@ -2096,31 +2080,29 @@ namespace QuickMedia {
                 else
                     event_idle_handler(event);
 
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
                     idle_active_handler();
                 }
 
                 if(tabs[selected_tab].search_bar) {
-                    tabs[selected_tab].search_bar->on_event(event);
+                    tabs[selected_tab].search_bar->on_event(window, event);
                 }
 
                 ui_tabs.on_event(event);
 
-                if(event.type == sf::Event::Resized || event.type == sf::Event::GainedFocus)
+                if(event.type == mgl::Event::Resized || event.type == mgl::Event::GainedFocus)
                     redraw = true;
-                else if(event.type == sf::Event::KeyPressed) {
-                    if(event.key.code == sf::Keyboard::Escape && go_to_previous_on_escape) {
+                else if(event.type == mgl::Event::KeyPressed) {
+                    if(event.key.code == mgl::Keyboard::Escape && go_to_previous_on_escape) {
                         return false;
-                    } else if(event.key.code == sf::Keyboard::Enter) {
+                    } else if(event.key.code == mgl::Keyboard::Enter) {
                         if(!tabs[selected_tab].search_bar) {
                             BodyItem *selected_item = tabs[selected_tab].body->get_selected();
                             submit_handler(selected_item ? selected_item->get_title() : "");
                         }
-                    } else if(event.key.code == sf::Keyboard::T && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::T && event.key.control) {
                         BodyItem *selected_item = tabs[selected_tab].body->get_selected();
                         if(selected_item && tabs[selected_tab].page->is_trackable()) {
                             TrackablePage *trackable_page = dynamic_cast<TrackablePage*>(tabs[selected_tab].page.get());
@@ -2128,7 +2110,7 @@ namespace QuickMedia {
                                 return trackable_page->track(selected_item->get_title()) == TrackResult::OK;
                             });
                         }
-                    } else if(event.key.code == sf::Keyboard::B && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::B && event.key.control) {
                         auto bookmark_item = tabs[selected_tab].page->get_bookmark_body_item();
                         if(!bookmark_item)
                             bookmark_item = tabs[selected_tab].body->get_selected_shared();
@@ -2143,15 +2125,15 @@ namespace QuickMedia {
                                 }
                             }
                         }
-                    } else if(event.key.code == sf::Keyboard::C && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::C && event.key.control) {
                         BodyItem *selected_item = tabs[selected_tab].body->get_selected();
                         if(selected_item)
                             tabs[selected_tab].page->copy_to_clipboard(selected_item);
-                    } else if(event.key.code == sf::Keyboard::I && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::I && event.key.control) {
                         BodyItem *selected_item = tabs[selected_tab].body->get_selected();
                         if(show_info_page(selected_item, false))
                             redraw = true;
-                    } else if(event.key.code == sf::Keyboard::Tab && !event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::Tab && !event.key.control) {
                         set_search_bar_to_body_item_text(tabs[selected_tab].body->get_selected(), tabs[selected_tab].search_bar.get());
                     }
                 }
@@ -2159,14 +2141,14 @@ namespace QuickMedia {
             update_idle_state();
             handle_x11_events();
 
-            if(!loop_running || !window.isOpen())
+            if(!loop_running || !window.is_open())
                 break;
 
             const int selected_tab = ui_tabs.get_selected();
 
             if(redraw) {
                 redraw = false;
-                if(tabs[selected_tab].search_bar) tabs[selected_tab].search_bar->onWindowResize(window_size);
+                if(tabs[selected_tab].search_bar) tabs[selected_tab].search_bar->onWindowResize(window_size.to_vec2f());
                 // TODO: Dont show tabs if there is only one tab
                 get_body_dimensions(window_size, tabs[selected_tab].search_bar.get(), body_pos, body_size, true);
 
@@ -2200,7 +2182,7 @@ namespace QuickMedia {
             if(tab_associated_data[selected_tab].fetching_next_page_running) {
                 double progress = 0.5 + std::sin(std::fmod(gradient_inc, 360.0) * 0.017453292519943295 - 1.5707963267948966*0.5) * 0.5;
                 gradient_inc += (frame_time_ms * 0.5);
-                sf::Color bottom_color = interpolate_colors(get_theme().background_color, get_theme().loading_bar_color, progress);
+                mgl::Color bottom_color = interpolate_colors(get_theme().background_color, get_theme().loading_bar_color, progress);
 
                 if(tabs[selected_tab].body->attach_side == AttachSide::TOP) {
                     gradient_points[0].color = get_theme().background_color;
@@ -2231,7 +2213,7 @@ namespace QuickMedia {
             if(tabs[selected_tab].page->is_ready() && tabs[selected_tab].page->is_lazy_fetch_page() && tab_associated_data[selected_tab].fetch_status == FetchStatus::NONE && !tab_associated_data[selected_tab].lazy_fetch_finished) {
                 tab_associated_data[selected_tab].fetch_status = FetchStatus::LOADING;
                 tab_associated_data[selected_tab].fetch_type = FetchType::LAZY;
-                tab_associated_data[selected_tab].search_result_text.setString("Loading...");
+                tab_associated_data[selected_tab].search_result_text.set_string("Loading...");
                 LazyFetchPage *lazy_fetch_page = static_cast<LazyFetchPage*>(tabs[selected_tab].page.get());
                 tab_associated_data[selected_tab].fetch_future = AsyncTask<FetchResult>([lazy_fetch_page]() {
                     FetchResult fetch_result;
@@ -2287,10 +2269,10 @@ namespace QuickMedia {
                     associated_data.search_text_updated = false;
                     associated_data.fetch_status = FetchStatus::LOADING;
                     associated_data.fetch_type = FetchType::SEARCH;
-                    associated_data.search_result_text.setString("Searching...");
+                    associated_data.search_result_text.set_string("Searching...");
                     associated_data.search_suggestion_submitted = false;
                     Page *page = tabs[i].page.get();
-                    associated_data.fetch_future = AsyncTask<FetchResult>([update_search_text, page]() {
+                    associated_data.fetch_future = AsyncTask<FetchResult>([update_search_text{std::move(update_search_text)}, page]() {
                         FetchResult fetch_result;
                         fetch_result.result = search_result_to_plugin_result(page->search(update_search_text, fetch_result.body_items));
                         return fetch_result;
@@ -2310,11 +2292,11 @@ namespace QuickMedia {
                         associated_data.fetched_page = 0;
                         associated_data.fetching_next_page_failed = false;
                         if(fetch_result.result != PluginResult::OK)
-                            associated_data.search_result_text.setString("Search failed!");
+                            associated_data.search_result_text.set_string("Search failed!");
                         else if(tabs[i].body->get_num_items() == 0)
-                            associated_data.search_result_text.setString("No results found");
+                            associated_data.search_result_text.set_string("No results found");
                         else
-                            associated_data.search_result_text.setString("");
+                            associated_data.search_result_text.set_string("");
                         idle_active_handler();
                     } else {
                         associated_data.fetch_future.get();
@@ -2336,11 +2318,11 @@ namespace QuickMedia {
                     }
                     LazyFetchPage *lazy_fetch_page = static_cast<LazyFetchPage*>(tabs[i].page.get());
                     if(fetch_result.result != PluginResult::OK)
-                        associated_data.search_result_text.setString("Failed to fetch page!");
+                        associated_data.search_result_text.set_string("Failed to fetch page!");
                     else if(tabs[i].body->get_num_items() == 0 && !lazy_fetch_page->lazy_fetch_is_loader())
-                        associated_data.search_result_text.setString("No results found");
+                        associated_data.search_result_text.set_string("No results found");
                     else
-                        associated_data.search_result_text.setString("");
+                        associated_data.search_result_text.set_string("");
                     associated_data.fetch_status = FetchStatus::NONE;
                     idle_active_handler();
                 }
@@ -2508,18 +2490,16 @@ namespace QuickMedia {
         AsyncTask<bool> task = callback;
         TaskResult task_result = TaskResult::TRUE;
 
-        window_size.x = window.getSize().x;
-        window_size.y = window.getSize().y;
-        sf::Event event;
-        while(window.isOpen()) {
-            while(window.pollEvent(event)) {
+        window_size.x = window.get_size().x;
+        window_size.y = window.get_size().y;
+        mgl::Event event;
+        while(window.is_open()) {
+            while(window.poll_event(event)) {
                 common_event_handler(event);
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Escape) {
                     task.cancel();
                     task_result = TaskResult::CANCEL;
                     goto task_end;
@@ -2539,8 +2519,8 @@ namespace QuickMedia {
             }
 
             window.clear(get_theme().background_color);
-            load_sprite.setPosition(window_size.x * 0.5f, window_size.y * 0.5f);
-            load_sprite.setRotation(load_sprite_timer.getElapsedTime().asSeconds() * 400.0);
+            load_sprite.set_position(mgl::vec2f(window_size.x * 0.5f, window_size.y * 0.5f));
+            load_sprite.set_rotation(load_sprite_timer.get_elapsed_time_seconds() * 400.0);
             window.draw(load_sprite);
             window.display();
         }
@@ -2573,7 +2553,7 @@ namespace QuickMedia {
             || is_soundcloud(url);
     }
 
-    void Program::video_page_download_video(const std::string &url, sf::WindowHandle video_player_window) {
+    void Program::video_page_download_video(const std::string &url, mgl::WindowHandle video_player_window) {
         bool separate_audio_option = url_should_download_with_youtube_dl(url);
         std::string video_id;
         separate_audio_option |= youtube_url_extract_id(url, video_id);
@@ -2716,8 +2696,8 @@ namespace QuickMedia {
             move_in_parent = true;
         }
 
-        sf::WindowHandle video_player_window = None;
-        auto on_window_create = [this, &video_player_window, &video_loaded, &video_page](sf::WindowHandle _video_player_window) mutable {
+        mgl::WindowHandle video_player_window = None;
+        auto on_window_create = [this, &video_player_window, &video_loaded, &video_page](mgl::WindowHandle _video_player_window) mutable {
             video_player_window = _video_player_window;
             XSelectInput(disp, video_player_window, KeyPressMask | PointerMotionMask);
             XSync(disp, False);
@@ -2908,8 +2888,7 @@ namespace QuickMedia {
 
                 if(num_proxied_media > 0) {
                     youtube_downloader_task = AsyncTask<void>([&youtube_video_media_proxy, &youtube_audio_media_proxy]() {
-                        sf::Clock timer;
-                        const double sleep_time_millisec = 1;
+                        mgl::Clock timer;
                         // TODO: Poll instead of sleep
                         while(!program_is_dead_in_current_thread()) {
                             if(youtube_video_media_proxy)
@@ -2918,16 +2897,16 @@ namespace QuickMedia {
                             if(youtube_audio_media_proxy)
                                 youtube_audio_media_proxy->update();
 
-                            const int sleep_time = sleep_time_millisec - timer.restart().asMilliseconds();
-                            if(sleep_time > 0)
-                                std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time));
+                            const double sleep_left_sec = timer.restart();
+                            if(sleep_left_sec > 0.000001)
+                                std::this_thread::sleep_for(std::chrono::milliseconds((long)(sleep_left_sec * 1000.0)));
                         }
                     });
                 }
             }
 
             video_player = std::make_unique<VideoPlayer>(is_audio_only, get_config().use_system_mpv_config, is_matrix && !is_youtube, video_event_callback, on_window_create, resources_root, video_max_height, plugin_name);
-            VideoPlayer::Error err = video_player->load_video(v.c_str(), a.c_str(), window.getSystemHandle(), use_youtube_dl, video_title, start_time, media_chapters);
+            VideoPlayer::Error err = video_player->load_video(v.c_str(), a.c_str(), window.get_system_handle(), use_youtube_dl, video_title, start_time, media_chapters);
             if(err != VideoPlayer::Error::OK) {
                 std::string err_msg = "Failed to play url: ";
                 err_msg += video_page->get_url();
@@ -2999,11 +2978,11 @@ namespace QuickMedia {
 
         load_video_error_check();
 
-        sf::Event event;
+        mgl::Event event;
 
         XEvent xev;
         bool cursor_visible = true;
-        sf::Clock cursor_hide_timer;
+        mgl::Clock cursor_hide_timer;
 
         auto save_video_url_to_clipboard = [this, video_page]() {
             std::string url = video_page->get_download_url(video_get_max_height());
@@ -3016,33 +2995,31 @@ namespace QuickMedia {
                 if((int)time_in_file > 0)
                     clipboard += "&t=" + std::to_string((int)time_in_file);
 
-                sf::Clipboard::setString(sf::String::fromUtf8(clipboard.begin(), clipboard.end()));
+                set_clipboard(clipboard);
             } else {
-                sf::Clipboard::setString(sf::String::fromUtf8(url.begin(), url.end()));
+                set_clipboard(url);
             }
         };
 
-        while (current_page == PageType::VIDEO_CONTENT && window.isOpen() && !go_to_previous_page) {
-            while (window.pollEvent(event)) {
+        while (current_page == PageType::VIDEO_CONTENT && window.is_open() && !go_to_previous_page) {
+            while (window.poll_event(event)) {
                 common_event_handler(event);
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
-                } else if(event.type == sf::Event::KeyPressed && (event.key.code == sf::Keyboard::Escape || event.key.code == sf::Keyboard::Q || event.key.code == sf::Keyboard::Backspace)) {
+                } else if(event.type == mgl::Event::KeyPressed && (event.key.code == mgl::Keyboard::Escape || event.key.code == mgl::Keyboard::Q || event.key.code == mgl::Keyboard::Backspace)) {
                     // To be able to close the video player while the video is loading
-                    if(window_is_fullscreen(disp, window.getSystemHandle())) {
-                        window_set_fullscreen(disp, window.getSystemHandle(), WindowFullscreenState::UNSET);
+                    if(window_is_fullscreen(disp, window.get_system_handle())) {
+                        window_set_fullscreen(disp, window.get_system_handle(), WindowFullscreenState::UNSET);
                     } else {
                         current_page = previous_page;
                         go_to_previous_page = true;
                     }
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::F && event.key.control) {
-                    window_set_fullscreen(disp, window.getSystemHandle(), WindowFullscreenState::TOGGLE);
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::C && event.key.control) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::F && event.key.control) {
+                    window_set_fullscreen(disp, window.get_system_handle(), WindowFullscreenState::TOGGLE);
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::C && event.key.control) {
                     save_video_url_to_clipboard();
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::F5) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::F5) {
                     load_video_error_check();
                 }
             }
@@ -3057,15 +3034,15 @@ namespace QuickMedia {
                 if(pressed_keysym == XK_q && pressing_ctrl) {
                     window.close();
                 } else if(pressed_keysym == XK_Escape || pressed_keysym == XK_q || pressed_keysym == XK_BackSpace) {
-                    if(window_is_fullscreen(disp, window.getSystemHandle())) {
-                        window_set_fullscreen(disp, window.getSystemHandle(), WindowFullscreenState::UNSET);
+                    if(window_is_fullscreen(disp, window.get_system_handle())) {
+                        window_set_fullscreen(disp, window.get_system_handle(), WindowFullscreenState::UNSET);
                     } else {
                         current_page = previous_page;
                         go_to_previous_page = true;
                         break;
                     }
                 } else if(pressed_keysym == XK_f && pressing_ctrl) {
-                    window_set_fullscreen(disp, window.getSystemHandle(), WindowFullscreenState::TOGGLE);
+                    window_set_fullscreen(disp, window.get_system_handle(), WindowFullscreenState::TOGGLE);
                 } else if(pressed_keysym == XK_s && pressing_ctrl) {
                     video_page_download_video(video_page->get_download_url(video_get_max_height()), video_player_window);
                 } else if(pressed_keysym == XK_F5) {
@@ -3077,6 +3054,7 @@ namespace QuickMedia {
                     if(video_tasks.valid()) {
                         XUnmapWindow(disp, video_player_window);
                         XSync(disp, False);
+                        XFlush(disp);
 
                         TaskResult task_result = run_task_with_loading_screen([video_page, &related_videos]() {
                             related_videos = video_page->get_related_media(video_page->get_url());
@@ -3092,7 +3070,7 @@ namespace QuickMedia {
 
                     if(!cancelled) {
                         if(!cursor_visible)
-                            window.setMouseCursorVisible(true);
+                            window.set_cursor_visible(true);
                         cursor_visible = true;
 
                         XUnmapWindow(disp, video_player_window);
@@ -3108,6 +3086,10 @@ namespace QuickMedia {
                             XSync(disp, False);
                             show_notification("QuickMedia", "Failed to get related pages", Urgency::CRITICAL);
                         } else if(related_pages_result == TaskResult::TRUE) {
+                            XMapWindow(disp, video_player_window);
+                            XSync(disp, False);
+                            XFlush(disp);
+
                             bool page_changed = false;
                             double resume_start_time = 0.0;
                             page_loop(related_pages, video_page->get_related_pages_first_tab(), [&](const std::vector<Tab> &new_tabs) {
@@ -3128,7 +3110,7 @@ namespace QuickMedia {
                                 }
                             });
 
-                            if(!window.isOpen() || current_page == PageType::EXIT) {
+                            if(!window.is_open() || current_page == PageType::EXIT) {
                                 video_player.reset();
                                 return;
                             }
@@ -3154,7 +3136,7 @@ namespace QuickMedia {
                 while(XCheckTypedWindowEvent(disp, video_player_window, MotionNotify, &xev));
                 cursor_hide_timer.restart();
                 if(!cursor_visible)
-                    window.setMouseCursorVisible(true);
+                    window.set_cursor_visible(true);
                 cursor_visible = true;
             }
 
@@ -3270,14 +3252,14 @@ namespace QuickMedia {
 
             if(!video_loaded) {
                 window.clear(get_theme().background_color);
-                load_sprite.setPosition(window_size.x * 0.5f, window_size.y * 0.5f);
-                load_sprite.setRotation(load_sprite_timer.getElapsedTime().asSeconds() * 400.0);
+                load_sprite.set_position(mgl::vec2f(window_size.x * 0.5f, window_size.y * 0.5f));
+                load_sprite.set_rotation(load_sprite_timer.get_elapsed_time_seconds() * 400.0);
                 window.draw(load_sprite);
                 window.display();
 
                 if(!cursor_visible) {
                     cursor_visible = true;
-                    window.setMouseCursorVisible(true);
+                    window.set_cursor_visible(true);
                 }
                 cursor_hide_timer.restart();
                 continue;
@@ -3289,20 +3271,20 @@ namespace QuickMedia {
                     continue;
                 }
 
-                const int UI_HIDE_TIMEOUT = 2500;
-                if(cursor_hide_timer.getElapsedTime().asMilliseconds() > UI_HIDE_TIMEOUT) {
+                const double UI_HIDE_TIMEOUT_SEC = 2.5;
+                if(cursor_hide_timer.get_elapsed_time_seconds() > UI_HIDE_TIMEOUT_SEC) {
                     cursor_visible = false;
-                    window.setMouseCursorVisible(false);
+                    window.set_cursor_visible(false);
                 }
             }
             std::this_thread::sleep_for(std::chrono::milliseconds(50));
         }
 
         video_player.reset();
-        window.setMouseCursorVisible(true);
-        window_set_fullscreen(disp, window.getSystemHandle(), WindowFullscreenState::UNSET);
+        window.set_cursor_visible(true);
+        window_set_fullscreen(disp, window.get_system_handle(), WindowFullscreenState::UNSET);
 
-        auto window_size_u = window.getSize();
+        auto window_size_u = window.get_size();
         window_size.x = window_size_u.x;
         window_size.y = window_size_u.y;
     }
@@ -3344,7 +3326,7 @@ namespace QuickMedia {
 
     // TODO: Optimize this somehow. One image alone uses more than 20mb ram! Total ram usage for viewing one image
     // becomes 40mb (private memory, almost 100mb in total!) Unacceptable!
-    Program::LoadImageResult Program::load_image_by_index(int image_index, sf::Texture &image_texture, sf::String &error_message) {
+    Program::LoadImageResult Program::load_image_by_index(int image_index, mgl::Texture &image_texture, std::string &error_message) {
         Path image_path = content_cache_dir;
         image_path.join(std::to_string(image_index + 1));
 
@@ -3357,16 +3339,8 @@ namespace QuickMedia {
         }
 
         if(get_file_type(image_path) == FileType::REGULAR && upscaled_ok) {
-            sf::Image image;
-            if(load_image_from_file(image, image_path.data)) {
-                if(image_texture.loadFromImage(image)) {
-                    image_texture.setSmooth(true);
-                    //image_texture.generateMipmap();
-                    return LoadImageResult::OK;
-                } else {
-                    error_message = std::string("Failed to load image for page ") + std::to_string(image_index + 1);
-                    return LoadImageResult::FAILED;
-                }
+            if(image_texture.load_from_file(image_path.data.c_str())) {
+                return LoadImageResult::OK;
             } else {
                 show_notification("QuickMedia", "Failed to load image for page " + std::to_string(image_index + 1) + ". Image filepath: " + image_path.data, Urgency::CRITICAL);
                 error_message = std::string("Failed to load image for page ") + std::to_string(image_index + 1);
@@ -3501,18 +3475,16 @@ namespace QuickMedia {
             });
         }, std::move(num_manga_pages_promise));
 
-        sf::Event event;
+        mgl::Event event;
         PageType current_manga_page = current_page;
 
-        while (current_page == current_manga_page && window.isOpen()) {
-            while(window.pollEvent(event)) {
+        while (current_page == current_manga_page && window.is_open()) {
+            while(window.poll_event(event)) {
                 common_event_handler(event);
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Escape) {
                     current_page = pop_page_stack();
                 }
             }
@@ -3524,8 +3496,8 @@ namespace QuickMedia {
             }
 
             window.clear(get_theme().background_color);
-            load_sprite.setPosition(window_size.x * 0.5f, window_size.y * 0.5f);
-            load_sprite.setRotation(load_sprite_timer.getElapsedTime().asSeconds() * 400.0);
+            load_sprite.set_position(mgl::vec2f(window_size.x * 0.5f, window_size.y * 0.5f));
+            load_sprite.set_rotation(load_sprite_timer.get_elapsed_time_seconds() * 400.0);
             window.draw(load_sprite);
             AsyncImageLoader::get_instance().update();
             window.display();
@@ -3572,13 +3544,13 @@ namespace QuickMedia {
             return 0;
         }
 
-        sf::Texture image_texture;
-        sf::Sprite image;
-        sf::Text error_message("", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(30 * get_config().scale * get_config().font_scale));
-        error_message.setFillColor(get_theme().text_color);
+        mgl::Texture image_texture;
+        mgl::Sprite image;
+        mgl::Text error_message("", *FontLoader::get_font(FontLoader::FontType::LATIN, 30 * get_config().scale * get_config().font_scale));
+        error_message.set_color(get_theme().text_color);
 
         bool download_in_progress = false;
-        sf::Event event;
+        mgl::Event event;
 
         download_chapter_images_if_needed(images_page);
         if(num_manga_pages == 0) {
@@ -3586,7 +3558,7 @@ namespace QuickMedia {
             return 0;
         }
 
-        if(current_page != PageType::IMAGES || !window.isOpen())
+        if(current_page != PageType::IMAGES || !window.is_open())
             return 0;
 
         // TODO: Dont do this every time we change page?
@@ -3596,57 +3568,56 @@ namespace QuickMedia {
         save_manga_progress(images_page, json_chapters, json_chapter, latest_read);
 
         if(image_index < num_manga_pages) {
-            sf::String error_msg;
+            std::string error_msg;
             LoadImageResult load_image_result = load_image_by_index(image_index, image_texture, error_msg);
             if(load_image_result == LoadImageResult::OK)
-                image.setTexture(image_texture, true);
+                image.set_texture(&image_texture);
             else if(load_image_result == LoadImageResult::DOWNLOAD_IN_PROGRESS)
                 download_in_progress = true;
-            error_message.setString(error_msg);
+            error_message.set_string(std::move(error_msg));
         } else if(image_index == num_manga_pages) {
-            error_message.setString("End of " + images_page->get_chapter_name());
+            error_message.set_string("End of " + images_page->get_chapter_name());
         }
 
-        bool error = !error_message.getString().isEmpty();
+        bool error = !error_message.get_string().empty();
         bool redraw = true;
 
-        sf::Text chapter_text(images_page->manga_name + " | " + images_page->get_chapter_name() + " | Page " + std::to_string(image_index + 1) + "/" + std::to_string(num_manga_pages), *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(14 * get_config().scale * get_config().font_scale));
+        const int chapter_text_character_size = 14 * get_config().scale * get_config().font_scale;
+        mgl::Text chapter_text(images_page->manga_name + " | " + images_page->get_chapter_name() + " | Page " + std::to_string(image_index + 1) + "/" + std::to_string(num_manga_pages), *FontLoader::get_font(FontLoader::FontType::LATIN, chapter_text_character_size));
         if(image_index == num_manga_pages)
-            chapter_text.setString(images_page->manga_name + " | " + images_page->get_chapter_name() + " | End");
-        chapter_text.setFillColor(sf::Color::White);
-        sf::RectangleShape chapter_text_background;
-        chapter_text_background.setFillColor(sf::Color(0, 0, 0, 150));
+            chapter_text.set_string(images_page->manga_name + " | " + images_page->get_chapter_name() + " | End");
+        chapter_text.set_color(mgl::Color(255, 255, 255, 255));
+        mgl::Rectangle chapter_text_background;
+        chapter_text_background.set_color(mgl::Color(0, 0, 0, 150));
 
-        sf::Vector2u texture_size;
-        sf::Vector2f texture_size_f;
+        mgl::vec2i texture_size;
+        mgl::vec2f texture_size_f;
         if(!error) {
-            texture_size = image.getTexture()->getSize();
-            texture_size_f = sf::Vector2f(texture_size.x, texture_size.y);
+            texture_size = image.get_texture()->get_size();
+            texture_size_f = mgl::vec2f(texture_size.x, texture_size.y);
         }
 
-        sf::Clock check_downloaded_timer;
-        const sf::Int32 check_downloaded_timeout_ms = 500;
+        mgl::Clock check_downloaded_timer;
+        const double check_downloaded_timeout_sec = 0.5;
 
         malloc_trim(0);
 
-        sf::Clock force_redraw_timer;
-        window.setFramerateLimit(20);
+        mgl::Clock force_redraw_timer;
+        window.set_framerate_limit(20);
         idle = true;
 
         // TODO: Show to user if a certain page is missing (by checking page name (number) and checking if some are skipped)
-        while (current_page == PageType::IMAGES && window.isOpen()) {
-            while(window.pollEvent(event)) {
+        while (current_page == PageType::IMAGES && window.is_open()) {
+            while(window.poll_event(event)) {
                 common_event_handler(event);
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
                     redraw = true;
-                } else if(event.type == sf::Event::GainedFocus) {
+                } else if(event.type == mgl::Event::GainedFocus) {
                     redraw = true;
-                } else if(event.type == sf::Event::KeyPressed) {
-                    if(event.key.code == sf::Keyboard::Up || (event.key.control && event.key.code == sf::Keyboard::K)) {
+                } else if(event.type == mgl::Event::KeyPressed) {
+                    if(event.key.code == mgl::Keyboard::Up || (event.key.control && event.key.code == mgl::Keyboard::K)) {
                         if(image_index > 0) {
                             --image_index;
                             goto end_of_images_page;
@@ -3654,7 +3625,7 @@ namespace QuickMedia {
                             page_navigation = -1;
                             goto end_of_images_page;
                         }
-                    } else if(event.key.code == sf::Keyboard::Down || (event.key.control && event.key.code == sf::Keyboard::J)) {
+                    } else if(event.key.code == mgl::Keyboard::Down || (event.key.control && event.key.code == mgl::Keyboard::J)) {
                         if(image_index < num_manga_pages) {
                             ++image_index;
                             goto end_of_images_page;
@@ -3662,12 +3633,12 @@ namespace QuickMedia {
                             page_navigation = 1;
                             goto end_of_images_page;
                         }
-                    } else if(event.key.code == sf::Keyboard::Escape) {
+                    } else if(event.key.code == mgl::Keyboard::Escape) {
                         current_page = pop_page_stack();
-                    } else if(event.key.code == sf::Keyboard::I) {
+                    } else if(event.key.code == mgl::Keyboard::I) {
                         current_page = PageType::IMAGES_CONTINUOUS;
                         image_view_mode = ImageViewMode::SCROLL;
-                    } else if(event.key.code == sf::Keyboard::F) {
+                    } else if(event.key.code == mgl::Keyboard::F) {
                         fit_image_to_window = !fit_image_to_window;
                         redraw = true;
                     }
@@ -3675,33 +3646,33 @@ namespace QuickMedia {
             }
             handle_x11_events();
 
-            if(download_in_progress && check_downloaded_timer.getElapsedTime().asMilliseconds() >= check_downloaded_timeout_ms) {
-                sf::String error_msg;
+            if(download_in_progress && check_downloaded_timer.get_elapsed_time_seconds() >= check_downloaded_timeout_sec) {
+                std::string error_msg;
                 LoadImageResult load_image_result = load_image_by_index(image_index, image_texture, error_msg);
                 if(load_image_result == LoadImageResult::OK) {
-                    image.setTexture(image_texture, true);
+                    image.set_texture(&image_texture);
                     download_in_progress = false;
                     error = false;
-                    texture_size = image.getTexture()->getSize();
-                    texture_size_f = sf::Vector2f(texture_size.x, texture_size.y);
+                    texture_size = image.get_texture()->get_size();
+                    texture_size_f = mgl::vec2f(texture_size.x, texture_size.y);
                 } else if(load_image_result == LoadImageResult::FAILED) {
                     download_in_progress = false;
                     error = true;
                 }
-                error_message.setString(error_msg);
+                error_message.set_string(std::move(error_msg));
                 redraw = true;
                 check_downloaded_timer.restart();
             }
 
-            const float font_height = chapter_text.getCharacterSize() + 8.0f;
+            const float font_height = chapter_text_character_size + 8.0f;
             const float bottom_panel_height = font_height + 6.0f;
 
-            sf::Vector2f content_size;
+            mgl::vec2f content_size;
             content_size.x = window_size.x;
             content_size.y = window_size.y - bottom_panel_height;
 
             // TODO: Track x11 window damage instead
-            if(force_redraw_timer.getElapsedTime().asSeconds() >= 1.0f) {
+            if(force_redraw_timer.get_elapsed_time_seconds() >= 1.0f) {
                 force_redraw_timer.restart();
                 redraw = true;
             }
@@ -3709,20 +3680,20 @@ namespace QuickMedia {
             if(redraw) {
                 redraw = false;
                 if(error) {
-                    auto bounds = error_message.getLocalBounds();
-                    error_message.setPosition(vec2f_floor(content_size.x * 0.5f - bounds.width * 0.5f, content_size.y * 0.5f - bounds.height));
+                    auto bounds = error_message.get_bounds();
+                    error_message.set_position(vec2f_floor(content_size.x * 0.5f - bounds.size.x * 0.5f, content_size.y * 0.5f - bounds.size.y));
                 } else {
-                    sf::Vector2f image_scale;
+                    mgl::vec2f image_scale;
                     if(fit_image_to_window)
                         image_scale = get_ratio(texture_size_f, wrap_to_size(texture_size_f, content_size));
                     else
                         image_scale = get_ratio(texture_size_f, clamp_to_size(texture_size_f, content_size));
-                    image.setScale(image_scale);
+                    image.set_scale(image_scale);
 
                     auto image_size = texture_size_f;
                     image_size.x *= image_scale.x;
                     image_size.y *= image_scale.y;
-                    image.setPosition(vec2f_floor(content_size.x * 0.5f - image_size.x * 0.5f, content_size.y * 0.5f - image_size.y * 0.5f));
+                    image.set_position(vec2f_floor(content_size.x * 0.5f - image_size.x * 0.5f, content_size.y * 0.5f - image_size.y * 0.5f));
                 }
 
                 window.clear(get_theme().background_color);
@@ -3733,12 +3704,12 @@ namespace QuickMedia {
                     window.draw(image);
                 }
 
-                chapter_text_background.setSize(sf::Vector2f(window_size.x, bottom_panel_height));
-                chapter_text_background.setPosition(0.0f, std::floor(window_size.y - bottom_panel_height));
+                chapter_text_background.set_size(mgl::vec2f(window_size.x, bottom_panel_height));
+                chapter_text_background.set_position(mgl::vec2f(0.0f, std::floor(window_size.y - bottom_panel_height)));
                 window.draw(chapter_text_background);
 
-                auto text_bounds = chapter_text.getLocalBounds();
-                chapter_text.setPosition(vec2f_floor(window_size.x * 0.5f - text_bounds.width * 0.5f, window_size.y - bottom_panel_height * 0.5f - font_height * 0.5f));
+                auto text_bounds = chapter_text.get_bounds();
+                chapter_text.set_position(vec2f_floor(window_size.x * 0.5f - text_bounds.size.x * 0.5f, window_size.y - bottom_panel_height * 0.5f - font_height * 0.6f));
                 window.draw(chapter_text);
 
                 window.display();
@@ -3767,7 +3738,7 @@ namespace QuickMedia {
             return;
         }
 
-        if(current_page != PageType::IMAGES_CONTINUOUS || !window.isOpen())
+        if(current_page != PageType::IMAGES_CONTINUOUS || !window.is_open())
             return;
 
         Json::Value json_chapters;
@@ -3778,7 +3749,7 @@ namespace QuickMedia {
 
         idle_active_handler();
 
-        while(current_page == PageType::IMAGES_CONTINUOUS && window.isOpen()) {
+        while(current_page == PageType::IMAGES_CONTINUOUS && window.is_open()) {
             handle_x11_events();
             window.clear(get_theme().background_color);
             ImageViewerAction action = image_viewer.draw();
@@ -3809,8 +3780,8 @@ namespace QuickMedia {
             }
         }
 
-        window_size.x = window.getSize().x;
-        window_size.y = window.getSize().y;
+        window_size.x = window.get_size().x;
+        window_size.y = window.get_size().y;
     }
 
     static bool get_image_board_last_posted_filepath(const char *plugin_name, Path &path) {
@@ -3826,19 +3797,19 @@ namespace QuickMedia {
         float zoom = 1.0f;
         bool pressed = false;
         bool moved = false;
-        sf::Vector2f offset; // relative to center
-        sf::Vector2i prev_mouse_pos;
+        mgl::vec2f offset; // relative to center
+        mgl::vec2i prev_mouse_pos;
     };
 
-    static sf::Vector2f to_vec2f(sf::Vector2i vec) {
-        return sf::Vector2f(vec.x, vec.y);
+    static mgl::vec2f to_vec2f(mgl::vec2i vec) {
+        return mgl::vec2f(vec.x, vec.y);
     }
 
-    static sf::Vector2f to_vec2f(sf::Vector2u vec) {
-        return sf::Vector2f(vec.x, vec.y);
+    static mgl::vec2f to_vec2f(mgl::vec2u vec) {
+        return mgl::vec2f(vec.x, vec.y);
     }
 
-    static sf::Vector2f floor(sf::Vector2f vec) {
+    static mgl::vec2f floor(mgl::vec2f vec) {
         return { std::floor(vec.x), std::floor(vec.y) };
     }
 
@@ -3856,10 +3827,10 @@ namespace QuickMedia {
         thread_body->title_mark_urls = true;
 
         NavigationStage navigation_stage = NavigationStage::VIEWING_COMMENTS;
-        sf::Texture captcha_texture;
-        sf::Sprite captcha_sprite;
-        sf::Texture captcha_bg_texture;
-        sf::Sprite captcha_bg_sprite;
+        mgl::Texture captcha_texture;
+        mgl::Sprite captcha_sprite;
+        mgl::Texture captcha_bg_texture;
+        mgl::Sprite captcha_bg_sprite;
         bool has_captcha_bg = false;
         float captcha_slide = 0.0f;
         std::string attached_image_url;
@@ -3867,26 +3838,23 @@ namespace QuickMedia {
 
         ImageControl image_control;
 
-        captcha_texture.setSmooth(true);
-        captcha_bg_texture.setSmooth(true);
-
         const float captcha_slide_padding_x = std::floor(4.0f * get_config().scale);
         const float captcha_slide_padding_y = std::floor(4.0f * get_config().scale);
-        sf::Color background_color_darker = get_theme().background_color;
+        mgl::Color background_color_darker = get_theme().background_color;
         background_color_darker.r = std::max(0, (int)background_color_darker.r - 20);
         background_color_darker.g = std::max(0, (int)background_color_darker.g - 20);
         background_color_darker.b = std::max(0, (int)background_color_darker.b - 20);
-        RoundedRectangle captcha_slide_bg(sf::Vector2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale), background_color_darker, &rounded_rectangle_shader);
-        RoundedRectangle captcha_slide_fg(sf::Vector2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale - captcha_slide_padding_y), get_theme().loading_bar_color, &rounded_rectangle_shader);
+        RoundedRectangle captcha_slide_bg(mgl::vec2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale), background_color_darker, &rounded_rectangle_shader);
+        RoundedRectangle captcha_slide_fg(mgl::vec2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale - captcha_slide_padding_y), get_theme().loading_bar_color, &rounded_rectangle_shader);
 
-        auto attached_image_texture = std::make_unique<sf::Texture>();
-        sf::Sprite attached_image_sprite;
+        auto attached_image_texture = std::make_unique<mgl::Texture>();
+        mgl::Sprite attached_image_sprite;
 
         std::string captcha_post_id;
         std::string captcha_solution;
         std::string comment_to_post;
         const int captcha_solution_text_height = 18 * get_config().scale * get_config().font_scale;
-        sf::Text captcha_solution_text("", *FontLoader::get_font(FontLoader::FontType::LATIN_BOLD), captcha_solution_text_height);
+        mgl::Text captcha_solution_text("", *FontLoader::get_font(FontLoader::FontType::LATIN_BOLD, captcha_solution_text_height));
         int solved_captcha_ttl = 0;
         int64_t last_posted_time = time(nullptr);
         int64_t seconds_until_post_again = 60; // TODO: Timeout for other imageboards
@@ -3983,14 +3951,14 @@ namespace QuickMedia {
             return false;
         };
 
-        sf::RectangleShape comment_input_shade;
-        comment_input_shade.setFillColor(get_theme().shade_color);
+        mgl::Rectangle comment_input_shade;
+        comment_input_shade.set_color(get_theme().shade_color);
 
-        sf::Sprite logo_sprite(plugin_logo);
-        logo_sprite.setScale(0.8f * get_config().scale, 0.8f * get_config().scale);
-        sf::Vector2f logo_size(std::floor(plugin_logo.getSize().x * logo_sprite.getScale().x), std::floor(plugin_logo.getSize().y * logo_sprite.getScale().y));
+        mgl::Sprite logo_sprite(&plugin_logo);
+        logo_sprite.set_scale(mgl::vec2f(0.8f * get_config().scale, 0.8f * get_config().scale));
+        mgl::vec2f logo_size(std::floor(plugin_logo.get_size().x * logo_sprite.get_scale().x), std::floor(plugin_logo.get_size().y * logo_sprite.get_scale().y));
 
-        sf::Sprite file_to_upload_sprite;
+        mgl::Sprite file_to_upload_sprite;
         bool sprite_applied_texture = false;
         std::shared_ptr<ThumbnailData> file_to_upload_thumbnail_data;
 
@@ -4002,17 +3970,17 @@ namespace QuickMedia {
         const float chat_input_padding_x = std::floor(10.0f * get_config().scale);
         const float chat_input_padding_y = std::floor(10.0f * get_config().scale);
 
-        sf::Vector2f body_pos;
-        sf::Vector2f body_size;
-        sf::Event event;
+        mgl::vec2f body_pos;
+        mgl::vec2f body_size;
+        mgl::Event event;
 
         std::deque<int> comment_navigation_stack;
         std::deque<int> comment_page_scroll_stack;
 
-        sf::Clock frame_timer;
-        while (current_page == PageType::IMAGE_BOARD_THREAD && window.isOpen()) {
-            const float frame_elapsed_time_sec = frame_timer.restart().asSeconds();
-            while (window.pollEvent(event)) {
+        mgl::Clock frame_timer;
+        while (current_page == PageType::IMAGE_BOARD_THREAD && window.is_open()) {
+            const float frame_elapsed_time_sec = frame_timer.restart();
+            while (window.poll_event(event)) {
                 common_event_handler(event);
                 if(navigation_stage == NavigationStage::REPLYING || navigation_stage == NavigationStage::VIEWING_COMMENTS) {
                     if(thread_body->on_event(window, event, navigation_stage == NavigationStage::VIEWING_COMMENTS))
@@ -4021,30 +3989,28 @@ namespace QuickMedia {
 
                 event_idle_handler(event);
                 if(!frame_skip_text_entry)
-                    comment_input.process_event(event);
+                    comment_input.process_event(window, event);
 
                 if(navigation_stage == NavigationStage::REPLYING && !frame_skip_text_entry) {
-                    if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
+                    if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Escape) {
                         comment_input.set_editable(false);
                         navigation_stage = NavigationStage::VIEWING_COMMENTS;
                         break;
                     }
                 }
 
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
                     idle_active_handler();
                 }
 
-                if(event.type == sf::Event::Resized || event.type == sf::Event::GainedFocus)
+                if(event.type == mgl::Event::Resized || event.type == mgl::Event::GainedFocus)
                     redraw = true;
-                else if(navigation_stage == NavigationStage::VIEWING_COMMENTS && event.type == sf::Event::KeyPressed) {
-                    if(event.key.code == sf::Keyboard::Escape) {
+                else if(navigation_stage == NavigationStage::VIEWING_COMMENTS && event.type == mgl::Event::KeyPressed) {
+                    if(event.key.code == mgl::Keyboard::Escape) {
                         current_page = pop_page_stack();
-                    } else if(event.key.code == sf::Keyboard::P) {
+                    } else if(event.key.code == mgl::Keyboard::P) {
                         BodyItem *selected_item = thread_body->get_selected();
                         if(selected_item && !selected_item->url.empty()) {
                             if(is_url_video(selected_item->url)) {
@@ -4066,7 +4032,7 @@ namespace QuickMedia {
                                 BodyItem *selected_item = thread_body->get_selected();
                                 if(selected_item && !selected_item->url.empty()) {
                                     attached_image_url = selected_item->url;
-                                    sf::Image image;
+                                    mgl::Image image;
                                     TaskResult task_result = run_task_with_loading_screen([&attached_image_url, &image]{
                                         SHA256 sha256;
                                         sha256.add(attached_image_url.data(), attached_image_url.size());
@@ -4077,7 +4043,7 @@ namespace QuickMedia {
                                             return false;
                                         }
 
-                                        if(!load_image_from_file(image, media_file_path.data)) {
+                                        if(!image.load_from_file(media_file_path.data.c_str())) {
                                             show_notification("QuickMedia", "Failed to load image: " + attached_image_url, Urgency::CRITICAL);
                                             return false;
                                         }
@@ -4085,20 +4051,21 @@ namespace QuickMedia {
                                     });
 
                                     if(task_result == TaskResult::TRUE) {
-                                        attached_image_texture = std::make_unique<sf::Texture>();
-                                        if(attached_image_texture->loadFromImage(image)) {
-                                            attached_image_texture->setSmooth(true);
-                                            attached_image_sprite.setTexture(*attached_image_texture, true);
-                                            attached_image_sprite.setOrigin(0.0f, 0.0f);
-                                            attached_image_sprite.setScale(1.0f, 1.0f);
+                                        attached_image_texture = std::make_unique<mgl::Texture>();
+                                        if(attached_image_texture->load_from_image(image)) {
+                                            attached_image_sprite.set_texture(attached_image_texture.get());
+                                            attached_image_sprite.set_origin(mgl::vec2f(0.0f, 0.0f));
+                                            attached_image_sprite.set_scale(mgl::vec2f(1.0f, 1.0f));
                                             navigation_stage = NavigationStage::VIEWING_ATTACHED_IMAGE;
 
                                             image_control.zoom = 1.0f;
-                                            image_control.offset = to_vec2f(attached_image_texture->getSize()) * 0.5f;
-                                            image_control.pressed = sf::Mouse::isButtonPressed(sf::Mouse::Left);
+                                            image_control.offset = to_vec2f(attached_image_texture->get_size()) * 0.5f;
+                                            image_control.pressed = window.is_mouse_button_pressed(mgl::Mouse::Left);
+                                            image_control.pressed = false;
+
                                             image_control.moved = false;
                                             if(image_control.pressed)
-                                                image_control.prev_mouse_pos = sf::Mouse::getPosition(window);
+                                                image_control.prev_mouse_pos = window.get_mouse_position();
                                         } else {
                                             show_notification("QuickMedia", "Failed to load image: " + attached_image_url, Urgency::CRITICAL);
                                         }
@@ -4106,7 +4073,7 @@ namespace QuickMedia {
                                 }
                             }
                         }
-                    } else if(event.key.code == sf::Keyboard::U) {
+                    } else if(event.key.code == mgl::Keyboard::U) {
                         std::filesystem::path &fm_dir = file_manager_start_dir;
                         auto file_manager_page = std::make_unique<FileManagerPage>(this, (FileManagerMimeType)(FILE_MANAGER_MIME_TYPE_IMAGE|FILE_MANAGER_MIME_TYPE_VIDEO));
                         file_manager_page->set_current_directory(fm_dir.string());
@@ -4117,8 +4084,8 @@ namespace QuickMedia {
                         std::vector<Tab> file_manager_tabs;
                         file_manager_tabs.push_back(Tab{std::move(file_manager_body), std::move(file_manager_page), create_search_bar("Search...", SEARCH_DELAY_FILTER)});
 
-                        sf::Event event;
-                        while(window.pollEvent(event)) { common_event_handler(event); }
+                        mgl::Event event;
+                        while(window.poll_event(event)) { common_event_handler(event); }
 
                         selected_files.clear();
                         page_loop(file_manager_tabs);
@@ -4131,26 +4098,26 @@ namespace QuickMedia {
 
                         redraw = true;
                         frame_skip_text_entry = true;
-                    } else if(event.key.code == sf::Keyboard::D && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::D && event.key.control) {
                         selected_file_for_upload.clear();
-                    } else if(event.key.code == sf::Keyboard::C && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::C && event.key.control) {
                         BodyItem *selected_item = thread_body->get_selected();
                         if(selected_item)
                             thread_page->copy_to_clipboard(selected_item);
-                    } else if(event.key.code == sf::Keyboard::I && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::I && event.key.control) {
                         BodyItem *selected_item = thread_body->get_selected();
                         if(show_info_page(selected_item, true)) {
                             redraw = true;
                             frame_skip_text_entry = true;
                         }
-                    } else if(event.key.code == sf::Keyboard::S && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::S && event.key.control) {
                         BodyItem *selected_item = thread_body->get_selected();
                         if(selected_item && !selected_item->url.empty())
                             download_async_gui(selected_item->url, file_manager_start_dir.string(), false);
                     }
 
                     BodyItem *selected_item = thread_body->get_selected();
-                    if(event.key.code == sf::Keyboard::Enter && selected_item && (comment_navigation_stack.empty() || thread_body->get_selected_item() != comment_navigation_stack.back()) && (!selected_item->replies_to.empty() || !selected_item->replies.empty())) {
+                    if(event.key.code == mgl::Keyboard::Enter && selected_item && (comment_navigation_stack.empty() || thread_body->get_selected_item() != comment_navigation_stack.back()) && (!selected_item->replies_to.empty() || !selected_item->replies.empty())) {
                         thread_body->for_each_item([](std::shared_ptr<BodyItem> &body_item) {
                             body_item->visible = false;
                         });
@@ -4165,7 +4132,7 @@ namespace QuickMedia {
                         comment_page_scroll_stack.push_back(thread_body->get_page_scroll());
                         //thread_body->clamp_selection();
                         thread_body->set_page_scroll(0.0f);
-                    } else if(event.key.code == sf::Keyboard::BackSpace && !comment_navigation_stack.empty()) {
+                    } else if(event.key.code == mgl::Keyboard::Backspace && !comment_navigation_stack.empty()) {
                         size_t previous_selected = comment_navigation_stack.back();
                         float previous_page_scroll = comment_page_scroll_stack.back();
                         comment_navigation_stack.pop_back();
@@ -4192,13 +4159,13 @@ namespace QuickMedia {
                             thread_body->clamp_selection();
                         }
                         thread_body->set_page_scroll(previous_page_scroll);
-                    } else if(event.key.code == sf::Keyboard::R && selected_item) {
+                    } else if(event.key.code == mgl::Keyboard::R && selected_item) {
                         std::string text_to_add = ">>" + selected_item->post_number + "\n";
-                        comment_input.append_text(std::move(text_to_add));
+                        comment_input.insert_text_at_caret_position(std::move(text_to_add));
                         comment_input.move_caret_to_end();
                     }
 
-                    if(event.key.code == sf::Keyboard::I && !event.key.control) {
+                    if(event.key.code == mgl::Keyboard::I && !event.key.control) {
                         frame_skip_text_entry = true;
                         navigation_stage = NavigationStage::REPLYING;
                         comment_input.set_editable(true);
@@ -4206,75 +4173,74 @@ namespace QuickMedia {
                     }
                 }
 
-                if(event.type == sf::Event::KeyPressed && navigation_stage == NavigationStage::SOLVING_POST_CAPTCHA && !frame_skip_text_entry) {
-                    if(event.key.code == sf::Keyboard::Escape) {
+                if(event.type == mgl::Event::KeyPressed && navigation_stage == NavigationStage::SOLVING_POST_CAPTCHA && !frame_skip_text_entry) {
+                    if(event.key.code == mgl::Keyboard::Escape) {
                         navigation_stage = NavigationStage::VIEWING_COMMENTS;
-                    } else if(event.key.code == sf::Keyboard::Enter) {
+                    } else if(event.key.code == mgl::Keyboard::Enter) {
                         navigation_stage = NavigationStage::POSTING_COMMENT;
-                        auto str8 = captcha_solution_text.getString().toUtf8();
-                        captcha_solution.assign(str8.begin(), str8.end());
-                    } else if(event.key.code == sf::Keyboard::BackSpace) {
-                        auto str = captcha_solution_text.getString();
-                        if(!str.isEmpty()) {
-                            str.erase(str.getSize() - 1);
-                            captcha_solution_text.setString(std::move(str));
+                        captcha_solution = captcha_solution_text.get_string();
+                    } else if(event.key.code == mgl::Keyboard::Backspace) {
+                        std::string str = captcha_solution_text.get_string();
+                        if(!str.empty()) {
+                            str.erase(str.size() - 1);
+                            captcha_solution_text.set_string(std::move(str));
                         }
                     } else {
-                        const int alpha = (int)event.key.code - (int)sf::Keyboard::A;
-                        const int num = (int)event.key.code - (int)sf::Keyboard::Num0;
-                        const int numpad = (int)event.key.code - (int)sf::Keyboard::Numpad0;
-                        if(alpha >= 0 && alpha <= sf::Keyboard::Z - sf::Keyboard::A) {
-                            captcha_solution_text.setString(captcha_solution_text.getString() + (sf::Uint32)to_upper(alpha + 'a'));
-                        } else if(num >= 0 && num <= sf::Keyboard::Num9 - sf::Keyboard::Num0) {
-                            captcha_solution_text.setString(captcha_solution_text.getString() + (sf::Uint32)(num + '0'));
-                        } else if(numpad >= 0 && numpad <= sf::Keyboard::Numpad9 - sf::Keyboard::Numpad0) {
-                            captcha_solution_text.setString(captcha_solution_text.getString() + (sf::Uint32)(numpad + '0'));
+                        const int alpha = (int)event.key.code - (int)mgl::Keyboard::A;
+                        const int num = (int)event.key.code - (int)mgl::Keyboard::Num0;
+                        const int numpad = (int)event.key.code - (int)mgl::Keyboard::Numpad0;
+                        if(alpha >= 0 && alpha <= mgl::Keyboard::Z - mgl::Keyboard::A) {
+                            captcha_solution_text.set_string(captcha_solution_text.get_string() + (char)to_upper(alpha + 'a'));
+                        } else if(num >= 0 && num <= mgl::Keyboard::Num9 - mgl::Keyboard::Num0) {
+                            captcha_solution_text.set_string(captcha_solution_text.get_string() + (char)(num + '0'));
+                        } else if(numpad >= 0 && numpad <= mgl::Keyboard::Numpad9 - mgl::Keyboard::Numpad0) {
+                            captcha_solution_text.set_string(captcha_solution_text.get_string() + (char)(numpad + '0'));
                         }
                     }
                 }
 
                 if(navigation_stage == NavigationStage::VIEWING_ATTACHED_IMAGE) {
-                    if(event.type == sf::Event::MouseWheelScrolled) {
-                        image_control.zoom *= (1.0f + event.mouseWheelScroll.delta * 0.1f);
+                    if(event.type == mgl::Event::MouseWheelScrolled) {
+                        image_control.zoom *= (1.0f + event.mouse_wheel_scroll.delta * 0.1f);
                         if(image_control.zoom < 0.01f)
                             image_control.zoom = 0.01f;
                         image_control.moved = true;
-                    } else if(event.type == sf::Event::MouseButtonPressed && event.mouseButton.button == sf::Mouse::Left) {
+                    } else if(event.type == mgl::Event::MouseButtonPressed && event.mouse_button.button == mgl::Mouse::Left) {
                         image_control.pressed = true;
-                        image_control.prev_mouse_pos.x = event.mouseButton.x;
-                        image_control.prev_mouse_pos.y = event.mouseButton.y;
-                    } else if(event.type == sf::Event::MouseButtonReleased && event.mouseButton.button == sf::Mouse::Left) {
+                        image_control.prev_mouse_pos.x = event.mouse_button.x;
+                        image_control.prev_mouse_pos.y = event.mouse_button.y;
+                    } else if(event.type == mgl::Event::MouseButtonReleased && event.mouse_button.button == mgl::Mouse::Left) {
                         image_control.pressed = false;
-                    } else if(event.type == sf::Event::MouseMoved && image_control.pressed) {
-                        const sf::Vector2i mouse_diff = sf::Vector2i(event.mouseMove.x, event.mouseMove.y) - image_control.prev_mouse_pos;
-                        image_control.prev_mouse_pos.x = event.mouseMove.x;
-                        image_control.prev_mouse_pos.y = event.mouseMove.y;
+                    } else if(event.type == mgl::Event::MouseMoved && image_control.pressed) {
+                        const mgl::vec2i mouse_diff = mgl::vec2i(event.mouse_move.x, event.mouse_move.y) - image_control.prev_mouse_pos;
+                        image_control.prev_mouse_pos.x = event.mouse_move.x;
+                        image_control.prev_mouse_pos.y = event.mouse_move.y;
                         image_control.offset -= (to_vec2f(mouse_diff) / image_control.zoom);
                         image_control.moved = true;
                         idle_active_handler();
-                    } else if(event.type == sf::Event::KeyPressed) {
-                        if(event.key.code == sf::Keyboard::W) {
+                    } else if(event.type == mgl::Event::KeyPressed) {
+                        if(event.key.code == mgl::Keyboard::W) {
                             image_control.zoom = 1.0f;
                             image_control.moved = false;
-                            image_control.offset = to_vec2f(attached_image_texture->getSize()) * 0.5f;
-                            attached_image_sprite.setOrigin(0.0f, 0.0f);
-                            attached_image_sprite.setScale(1.0f, 1.0f);
+                            image_control.offset = to_vec2f(attached_image_texture->get_size()) * 0.5f;
+                            attached_image_sprite.set_origin(mgl::vec2f(0.0f, 0.0f));
+                            attached_image_sprite.set_scale(mgl::vec2f(1.0f, 1.0f));
                         }
                     }
                 }
 
-                if(event.type == sf::Event::KeyPressed && navigation_stage == NavigationStage::VIEWING_ATTACHED_IMAGE) {
-                    if(event.key.code == sf::Keyboard::Escape || event.key.code == sf::Keyboard::BackSpace) {
+                if(event.type == mgl::Event::KeyPressed && navigation_stage == NavigationStage::VIEWING_ATTACHED_IMAGE) {
+                    if(event.key.code == mgl::Keyboard::Escape || event.key.code == mgl::Keyboard::Backspace) {
                         navigation_stage = NavigationStage::VIEWING_COMMENTS;
-                        attached_image_texture.reset(new sf::Texture());
+                        attached_image_texture.reset(new mgl::Texture());
                         redraw = true;
-                    } else if(event.key.code == sf::Keyboard::I && event.key.control && !attached_image_url.empty()) {
+                    } else if(event.key.code == mgl::Keyboard::I && event.key.control && !attached_image_url.empty()) {
                         std::vector<Tab> saucenao_tabs;
                         saucenao_tabs.push_back(Tab{create_body(), std::make_unique<SaucenaoPage>(this, attached_image_url, false), nullptr});
                         page_loop(saucenao_tabs);
                         redraw = true;
                         frame_skip_text_entry = true;
-                    } else if(event.key.code == sf::Keyboard::S && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::S && event.key.control) {
                         download_async_gui(attached_image_url, file_manager_start_dir.string(), false);
                     }
                 }
@@ -4293,7 +4259,7 @@ namespace QuickMedia {
                     comment_input.set_editable(false);
                     captcha_post_id = std::move(captcha_challenge.challenge_id);
                     solved_captcha_ttl = 0;// captcha_challenge.ttl; // TODO: Support ttl to not have to solve captcha again
-                    captcha_solution_text.setString("");
+                    captcha_solution_text.set_string("");
                     captcha_slide = 0.0f;
 
                     if(captcha_post_id == "noop") { // TODO: Fix for other imageboard than 4chan in the future
@@ -4301,16 +4267,16 @@ namespace QuickMedia {
                         navigation_stage = NavigationStage::POSTING_COMMENT;
                     } else {
                         bool failed = false;
-                        sf::Image image;
-                        if(!load_image_from_memory(image, captcha_challenge.img_data.data(), captcha_challenge.img_data.size()) || !captcha_texture.loadFromImage(image)) {
+                        mgl::Image image;
+                        if(!image.load_from_memory((const unsigned char*)captcha_challenge.img_data.data(), captcha_challenge.img_data.size()) || !captcha_texture.load_from_image(image)) {
                             show_notification("QuickMedia", "Failed to load captcha image", Urgency::CRITICAL);
                             failed = true;
                         }
                         captcha_challenge.img_data = std::string();
 
                         has_captcha_bg = !failed && !captcha_challenge.bg_data.empty();
-                        sf::Image bg_Image;
-                        if(has_captcha_bg && (!load_image_from_memory(bg_Image, captcha_challenge.bg_data.data(), captcha_challenge.bg_data.size()) || !captcha_bg_texture.loadFromImage(bg_Image))) {
+                        mgl::Image bg_image;
+                        if(has_captcha_bg && (!bg_image.load_from_memory((const unsigned char*)captcha_challenge.bg_data.data(), captcha_challenge.bg_data.size()) || !captcha_bg_texture.load_from_image(bg_image))) {
                             show_notification("QuickMedia", "Failed to load captcha image", Urgency::CRITICAL);
                             failed = true;
                         }
@@ -4320,9 +4286,9 @@ namespace QuickMedia {
                             navigation_stage = NavigationStage::VIEWING_COMMENTS;
                         } else {
                             navigation_stage = NavigationStage::SOLVING_POST_CAPTCHA;
-                            captcha_sprite.setTexture(captcha_texture, true);
+                            captcha_sprite.set_texture(&captcha_texture);
                             if(has_captcha_bg)
-                                captcha_bg_sprite.setTexture(captcha_bg_texture, true);
+                                captcha_bg_sprite.set_texture(&captcha_bg_texture);
                         }
                     }
                 } else if(task_result == TaskResult::CANCEL) {
@@ -4351,13 +4317,12 @@ namespace QuickMedia {
                     redraw = true;
                 }
             } else {
-                file_to_upload_thumbnail_data = AsyncImageLoader::get_instance().get_thumbnail(selected_file_for_upload, true, sf::Vector2i(logo_size.x, logo_size.y * 4));
+                file_to_upload_thumbnail_data = AsyncImageLoader::get_instance().get_thumbnail(selected_file_for_upload, true, mgl::vec2i(logo_size.x, logo_size.y * 4));
             }
 
-            if(file_to_upload_thumbnail_data && file_to_upload_thumbnail_data->loading_state == LoadingState::FINISHED_LOADING && file_to_upload_thumbnail_data->image->getSize().x > 0 && file_to_upload_thumbnail_data->image->getSize().y > 0) {
-                if(!file_to_upload_thumbnail_data->texture.loadFromImage(*file_to_upload_thumbnail_data->image))
+            if(file_to_upload_thumbnail_data && file_to_upload_thumbnail_data->loading_state == LoadingState::FINISHED_LOADING && file_to_upload_thumbnail_data->image->get_size().x > 0 && file_to_upload_thumbnail_data->image->get_size().y > 0) {
+                if(!file_to_upload_thumbnail_data->texture.load_from_image(*file_to_upload_thumbnail_data->image))
                     fprintf(stderr, "Warning: failed to load texture for attached file\n");
-                file_to_upload_thumbnail_data->texture.setSmooth(true);
                 //room_avatar_thumbnail_data->texture.generateMipmap();
                 file_to_upload_thumbnail_data->image.reset();
                 file_to_upload_thumbnail_data->loading_state = LoadingState::APPLIED_TO_TEXTURE;
@@ -4365,18 +4330,18 @@ namespace QuickMedia {
             }
 
             if(file_to_upload_thumbnail_data && file_to_upload_thumbnail_data->loading_state == LoadingState::APPLIED_TO_TEXTURE && !sprite_applied_texture) {
-                file_to_upload_sprite.setTexture(file_to_upload_thumbnail_data->texture, true);
+                file_to_upload_sprite.set_texture(&file_to_upload_thumbnail_data->texture);
                 sprite_applied_texture = true;
 
-                sf::Vector2f texture_size_f(file_to_upload_thumbnail_data->texture.getSize().x, file_to_upload_thumbnail_data->texture.getSize().y);
-                sf::Vector2f image_scale = get_ratio(texture_size_f, clamp_to_size_x(texture_size_f, logo_size));
-                file_to_upload_sprite.setScale(image_scale);
+                mgl::vec2f texture_size_f(file_to_upload_thumbnail_data->texture.get_size().x, file_to_upload_thumbnail_data->texture.get_size().y);
+                mgl::vec2f image_scale = get_ratio(texture_size_f, clamp_to_size_x(texture_size_f, logo_size.x));
+                file_to_upload_sprite.set_scale(image_scale);
                 redraw = true;
             }
 
             float chat_input_height_full_images = logo_size.y;
             if(file_to_upload_thumbnail_data && file_to_upload_thumbnail_data->loading_state == LoadingState::APPLIED_TO_TEXTURE) {
-                const float file_to_upload_height = std::floor(logo_file_to_upload_spacing + file_to_upload_sprite.getTexture()->getSize().y * file_to_upload_sprite.getScale().y);
+                const float file_to_upload_height = std::floor(logo_file_to_upload_spacing + file_to_upload_sprite.get_texture()->get_size().y * file_to_upload_sprite.get_scale().y);
                 chat_input_height_full_images += file_to_upload_height;
             }
             chat_input_height_full = chat_input_padding_y + std::max(comment_input.get_height(), chat_input_height_full_images) + chat_input_padding_y;
@@ -4395,59 +4360,59 @@ namespace QuickMedia {
 
                 const float body_width = window_size.x;
 
-                comment_input_shade.setSize(sf::Vector2f(window_size.x, chat_input_height_full));
-                comment_input_shade.setPosition(0.0f, 0.0f);
+                comment_input_shade.set_size(mgl::vec2f(window_size.x, chat_input_height_full));
+                comment_input_shade.set_position(mgl::vec2f(0.0f, 0.0f));
 
-                body_pos = sf::Vector2f(0.0f, comment_input_shade.getSize().y);
-                body_size = sf::Vector2f(body_width, window_size.y - comment_input_shade.getSize().y);
+                body_pos = mgl::vec2f(0.0f, comment_input_shade.get_size().y);
+                body_size = mgl::vec2f(body_width, window_size.y - comment_input_shade.get_size().y);
 
-                logo_sprite.setPosition(logo_padding_x, chat_input_padding_y);
-                file_to_upload_sprite.setPosition(logo_sprite.getPosition() + sf::Vector2f(0.0f, logo_size.y + logo_file_to_upload_spacing));
+                logo_sprite.set_position(mgl::vec2f(logo_padding_x, chat_input_padding_y));
+                file_to_upload_sprite.set_position(logo_sprite.get_position() + mgl::vec2f(0.0f, logo_size.y + logo_file_to_upload_spacing));
             }
 
             //comment_input.update();
 
             window.clear(get_theme().background_color);
-            if(navigation_stage == NavigationStage::SOLVING_POST_CAPTCHA && captcha_texture.getNativeHandle() != 0) {
+            if(navigation_stage == NavigationStage::SOLVING_POST_CAPTCHA && captcha_texture.is_valid()) {
                 const float slide_speed = 0.5f;
-                const bool window_has_focus = window.hasFocus();
-                if(window_has_focus && sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
+                const bool window_has_focus = window.has_focus();
+                if(window_has_focus && window.is_key_pressed(mgl::Keyboard::Left)) {
                     captcha_slide -= (slide_speed * frame_elapsed_time_sec);
                     if(captcha_slide < 0.0f)
                         captcha_slide = 0.0f;
-                } else if(window_has_focus && sf::Keyboard::isKeyPressed(sf::Keyboard::Right)) {
+                } else if(window_has_focus && window.is_key_pressed(mgl::Keyboard::Right)) {
                     captcha_slide += (slide_speed * frame_elapsed_time_sec);
                     if(captcha_slide > 1.0f)
                         captcha_slide = 1.0f;
                 }
 
-                sf::Vector2f content_size = window_size;
+                mgl::vec2f content_size = window_size.to_vec2f();
                 int image_height = 0;
 
-                sf::Vector2u captcha_texture_size = captcha_texture.getSize();
-                sf::Vector2f captcha_texture_size_f(captcha_texture_size.x, captcha_texture_size.y);
+                mgl::vec2i captcha_texture_size = captcha_texture.get_size();
+                mgl::vec2f captcha_texture_size_f(captcha_texture_size.x, captcha_texture_size.y);
                 auto image_scale = get_ratio(captcha_texture_size_f, clamp_to_size(captcha_texture_size_f, content_size));
-                captcha_sprite.setScale(image_scale);
+                captcha_sprite.set_scale(image_scale);
 
                 auto captcha_image_size = captcha_texture_size_f;
                 captcha_image_size.x *= image_scale.x;
                 captcha_image_size.y *= image_scale.y;
-                captcha_sprite.setPosition(vec2f_floor(content_size.x * 0.5f - captcha_image_size.x * 0.5f, content_size.y * 0.5f - captcha_image_size.y * 0.5f));
+                captcha_sprite.set_position(vec2f_floor(content_size.x * 0.5f - captcha_image_size.x * 0.5f, content_size.y * 0.5f - captcha_image_size.y * 0.5f));
                 image_height = (int)captcha_image_size.y;
 
-                if(has_captcha_bg && captcha_bg_texture.getNativeHandle() != 0) {
-                    sf::Vector2f content_size = window_size;
+                if(has_captcha_bg && captcha_bg_texture.is_valid()) {
+                    mgl::vec2f content_size = window_size.to_vec2f();
 
-                    sf::Vector2u captcha_bg_texture_size = captcha_bg_texture.getSize();
-                    sf::Vector2f captcha_bg_texture_size_f(captcha_bg_texture_size.x, captcha_bg_texture_size.y);
+                    mgl::vec2i captcha_bg_texture_size = captcha_bg_texture.get_size();
+                    mgl::vec2f captcha_bg_texture_size_f(captcha_bg_texture_size.x, captcha_bg_texture_size.y);
                     auto image_scale = get_ratio(captcha_bg_texture_size_f, clamp_to_size(captcha_bg_texture_size_f, content_size));
-                    captcha_bg_sprite.setScale(image_scale);
+                    captcha_bg_sprite.set_scale(image_scale);
 
                     auto image_size = captcha_bg_texture_size_f;
                     image_size.x *= image_scale.x;
                     image_size.y *= image_scale.y;
                     const float width_diff = image_size.x - captcha_image_size.x;
-                    captcha_bg_sprite.setPosition(vec2f_floor(captcha_sprite.getPosition().x + width_diff*1.0f - captcha_slide*(width_diff + width_diff*2.0f), captcha_sprite.getPosition().y));
+                    captcha_bg_sprite.set_position(vec2f_floor(captcha_sprite.get_position().x + width_diff*1.0f - captcha_slide*(width_diff + width_diff*2.0f), captcha_sprite.get_position().y));
                     window.draw(captcha_bg_sprite);
 
                     image_height = std::max(image_height, (int)image_size.y);
@@ -4456,64 +4421,64 @@ namespace QuickMedia {
                 window.draw(captcha_sprite);
 
                 // TODO: Cut off ends with sf::View instead
-                sf::RectangleShape cut_off_rectangle(captcha_image_size);
-                cut_off_rectangle.setFillColor(get_theme().background_color);
-                cut_off_rectangle.setPosition(captcha_sprite.getPosition() - sf::Vector2f(cut_off_rectangle.getSize().x, 0.0f));
+                mgl::Rectangle cut_off_rectangle(captcha_image_size);
+                cut_off_rectangle.set_color(get_theme().background_color);
+                cut_off_rectangle.set_position(captcha_sprite.get_position() - mgl::vec2f(cut_off_rectangle.get_size().x, 0.0f));
                 window.draw(cut_off_rectangle);
 
-                cut_off_rectangle.setPosition(captcha_sprite.getPosition() + sf::Vector2f(captcha_image_size.x, 0.0f));
+                cut_off_rectangle.set_position(captcha_sprite.get_position() + mgl::vec2f(captcha_image_size.x, 0.0f));
                 window.draw(cut_off_rectangle);
 
                 const float captcha_slide_bg_height = std::floor(20.0f * get_config().scale);
-                captcha_slide_bg.set_size(sf::Vector2f(captcha_image_size.x, captcha_slide_bg_height));
-                captcha_slide_bg.set_position(sf::Vector2f(captcha_sprite.getPosition().x, captcha_sprite.getPosition().y + image_height + 10.0f));
+                captcha_slide_bg.set_size(mgl::vec2f(captcha_image_size.x, captcha_slide_bg_height));
+                captcha_slide_bg.set_position(mgl::vec2f(captcha_sprite.get_position().x, captcha_sprite.get_position().y + image_height + 10.0f));
 
-                const sf::Vector2f captcha_slide_fg_size = captcha_slide_bg.get_size() - sf::Vector2f(captcha_slide_padding_x * 2.0f, captcha_slide_padding_y * 2.0f);
+                const mgl::vec2f captcha_slide_fg_size = captcha_slide_bg.get_size() - mgl::vec2f(captcha_slide_padding_x * 2.0f, captcha_slide_padding_y * 2.0f);
                 captcha_slide_fg.set_size(vec2f_floor(captcha_slide_fg_size.x * captcha_slide, captcha_slide_fg_size.y));
-                captcha_slide_fg.set_position(captcha_slide_bg.get_position() + sf::Vector2f(captcha_slide_padding_x, captcha_slide_padding_y));
+                captcha_slide_fg.set_position(captcha_slide_bg.get_position() + mgl::vec2f(captcha_slide_padding_x, captcha_slide_padding_y));
 
                 if(has_captcha_bg) {
                     captcha_slide_bg.draw(window);
                     captcha_slide_fg.draw(window);
                 }
 
-                captcha_solution_text.setPosition(
-                    sf::Vector2f(
-                        std::floor(window_size.x * 0.5f - captcha_solution_text.getLocalBounds().width * 0.5f),
+                captcha_solution_text.set_position(
+                    mgl::vec2f(
+                        std::floor(window_size.x * 0.5f - captcha_solution_text.get_bounds().size.x * 0.5f),
                         std::floor(captcha_slide_bg.get_position().y + captcha_slide_bg.get_size().y + 10.0f)));
                 window.draw(captcha_solution_text);
             } else if(navigation_stage == NavigationStage::VIEWING_ATTACHED_IMAGE) {
-                if(attached_image_texture->getNativeHandle() != 0) {
+                if(attached_image_texture->is_valid()) {
                     if(image_control.moved) {
-                        attached_image_sprite.setOrigin(floor(image_control.offset));
-                        attached_image_sprite.setScale(image_control.zoom, image_control.zoom);
-                        attached_image_sprite.setPosition(floor(window_size * 0.5f));
+                        attached_image_sprite.set_origin(floor(image_control.offset));
+                        attached_image_sprite.set_scale(mgl::vec2f(image_control.zoom, image_control.zoom));
+                        attached_image_sprite.set_position(floor(window_size.to_vec2f() * 0.5f));
                         window.draw(attached_image_sprite);
                     } else {
-                        auto content_size = window_size;
-                        sf::Vector2u texture_size = attached_image_texture->getSize();
-                        sf::Vector2f texture_size_f(texture_size.x, texture_size.y);
+                        auto content_size = window_size.to_vec2f();
+                        mgl::vec2i texture_size = attached_image_texture->get_size();
+                        mgl::vec2f texture_size_f(texture_size.x, texture_size.y);
                         auto image_scale = get_ratio(texture_size_f, clamp_to_size(texture_size_f, content_size));
                         image_control.zoom = std::min(image_scale.x, image_scale.y);
-                        attached_image_sprite.setScale(image_scale);
+                        attached_image_sprite.set_scale(image_scale);
 
                         auto image_size = texture_size_f;
                         image_size.x *= image_scale.x;
                         image_size.y *= image_scale.y;
-                        attached_image_sprite.setPosition(vec2f_floor(content_size.x * 0.5f - image_size.x * 0.5f, content_size.y * 0.5f - image_size.y * 0.5f));
+                        attached_image_sprite.set_position(vec2f_floor(content_size.x * 0.5f - image_size.x * 0.5f, content_size.y * 0.5f - image_size.y * 0.5f));
                         window.draw(attached_image_sprite);
                     }
                 } else {
-                    sf::RectangleShape rect(sf::Vector2f(640.0f, 480.0f));
-                    rect.setFillColor(get_theme().image_loading_background_color);
-                    auto content_size = window_size;
-                    auto rect_size = clamp_to_size(rect.getSize(), content_size);
-                    rect.setSize(rect_size);
-                    rect.setPosition(vec2f_floor(content_size.x * 0.5f - rect_size.x * 0.5f, content_size.y * 0.5f - rect_size.y * 0.5f));
+                    mgl::Rectangle rect(mgl::vec2f(640.0f, 480.0f));
+                    rect.set_color(get_theme().image_loading_background_color);
+                    auto content_size = window_size.to_vec2f();
+                    auto rect_size = clamp_to_size(rect.get_size(), content_size);
+                    rect.set_size(rect_size);
+                    rect.set_position(vec2f_floor(content_size.x * 0.5f - rect_size.x * 0.5f, content_size.y * 0.5f - rect_size.y * 0.5f));
                     window.draw(rect);
 
-                    load_sprite.setPosition(window_size.x * 0.5f, window_size.y * 0.5f);
-                    load_sprite.setRotation(load_sprite_timer.getElapsedTime().asSeconds() * 400.0);
+                    load_sprite.set_position(mgl::vec2f(window_size.x * 0.5f, window_size.y * 0.5f));
+                    load_sprite.set_rotation(load_sprite_timer.get_elapsed_time_seconds() * 400.0);
                     window.draw(load_sprite);
                 }
             } else if(navigation_stage == NavigationStage::REPLYING) {
@@ -4535,16 +4500,16 @@ namespace QuickMedia {
             if((navigation_stage == NavigationStage::REPLYING || navigation_stage == NavigationStage::VIEWING_COMMENTS) && has_post_timeout) {
                 int64_t time_left_until_post_again = seconds_until_post_again - (time(nullptr) - last_posted_time);
                 if(time_left_until_post_again > 0) {
-                    sf::RectangleShape time_left_bg(comment_input_shade.getSize());
-                    time_left_bg.setPosition(comment_input_shade.getPosition());
-                    time_left_bg.setFillColor(sf::Color(0, 0, 0, 100));
+                    mgl::Rectangle time_left_bg(comment_input_shade.get_size());
+                    time_left_bg.set_position(comment_input_shade.get_position());
+                    time_left_bg.set_color(mgl::Color(0, 0, 0, 100));
                     window.draw(time_left_bg);
 
-                    sf::Text time_left_text("Wait " + std::to_string(time_left_until_post_again) + " second(s) before posting again", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(18 * get_config().scale * get_config().font_scale));
-                    time_left_text.setPosition(time_left_bg.getPosition() +
-                        sf::Vector2f(
-                            std::floor(time_left_bg.getSize().x * 0.5f - time_left_text.getLocalBounds().width * 0.5f),
-                            std::floor(time_left_bg.getSize().y * 0.5f - time_left_text.getLocalBounds().height * 0.5f)));
+                    mgl::Text time_left_text("Wait " + std::to_string(time_left_until_post_again) + " second(s) before posting again", *FontLoader::get_font(FontLoader::FontType::LATIN, 18 * get_config().scale * get_config().font_scale));
+                    time_left_text.set_position(time_left_bg.get_position() +
+                        mgl::vec2f(
+                            std::floor(time_left_bg.get_size().x * 0.5f - time_left_text.get_bounds().size.x * 0.5f),
+                            std::floor(time_left_bg.get_size().y * 0.5f - time_left_text.get_bounds().size.y * 0.5f)));
                     window.draw(time_left_text);
                 }
             }
@@ -4565,9 +4530,9 @@ namespace QuickMedia {
         SearchBar *inputs[num_inputs] = { &login_input, &password_input, &homeserver_input };
         int focused_input = 0;
 
-        RoundedRectangle background(sf::Vector2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().shade_color, &rounded_rectangle_shader);
+        RoundedRectangle background(mgl::vec2f(1.0f, 1.0f), 10.0f * get_config().scale, get_theme().shade_color, &rounded_rectangle_shader);
 
-        auto text_submit_callback = [this, inputs](const sf::String&) {
+        auto text_submit_callback = [this, inputs](const std::string&) {
             for(int i = 0; i < num_inputs; ++i) {
                 if(inputs[i]->get_text().empty()) {
                     show_notification("QuickMedia", "All fields need to be filled in", Urgency::CRITICAL);
@@ -4603,26 +4568,24 @@ namespace QuickMedia {
         const float padding_y = std::floor(20.0f * get_config().scale);
         const float spacing_y = std::floor(20.0f * get_config().scale);
 
-        sf::Vector2f body_pos;
-        sf::Vector2f body_size;
+        mgl::vec2f body_pos;
+        mgl::vec2f body_size;
         bool redraw = true;
-        sf::Event event;
+        mgl::Event event;
 
-        while (current_page == PageType::CHAT_LOGIN && window.isOpen()) {
-            while (window.pollEvent(event)) {
+        while (current_page == PageType::CHAT_LOGIN && window.is_open()) {
+            while (window.poll_event(event)) {
                 common_event_handler(event);
                 event_idle_handler(event);
 
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
                     redraw = true;
                     idle_active_handler();
-                } else if(event.type == sf::Event::GainedFocus) {
+                } else if(event.type == mgl::Event::GainedFocus) {
                     redraw = true;
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Tab) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Tab) {
                     for(int i = 0; i < num_inputs; ++i) {
                         inputs[i]->caret_visible = false;
                     }
@@ -4630,7 +4593,7 @@ namespace QuickMedia {
                     inputs[focused_input]->caret_visible = true;
                     idle_active_handler();
                 }
-                inputs[focused_input]->on_event(event);
+                inputs[focused_input]->on_event(window, event);
             }
             update_idle_state();
             handle_x11_events();
@@ -4641,12 +4604,12 @@ namespace QuickMedia {
             if(redraw) {
                 redraw = false;
                 get_body_dimensions(window_size, nullptr, body_pos, body_size);
-                background.set_size(sf::Vector2f(
-                    std::min(window_size.x, std::max(640.0f, window_size.x * 0.5f)),
+                background.set_size(mgl::vec2f(
+                    std::min((float)window_size.x, std::max(640.0f, window_size.x * 0.5f)),
                     num_inputs * inputs[0]->getBottomWithoutShadow() + padding_y * 2.0f + spacing_y * std::max(0, num_inputs - 1)));
-                background.set_position(window_size * 0.5f - background.get_size() * 0.5f);
+                background.set_position(window_size.to_vec2f() * 0.5f - background.get_size() * 0.5f);
 
-                sf::Vector2f pos = background.get_position() + sf::Vector2f(padding_x, padding_y);
+                mgl::vec2f pos = background.get_position() + mgl::vec2f(padding_x, padding_y);
                 for(int i = 0; i < num_inputs; ++i) {
                     inputs[i]->set_position(pos);
                     pos.y += inputs[i]->getBottomWithoutShadow() + spacing_y;
@@ -4657,7 +4620,7 @@ namespace QuickMedia {
             background.draw(window);
             for(int i = 0; i < num_inputs; ++i) {
                 inputs[i]->update();
-                inputs[i]->draw(window, background.get_size() - sf::Vector2f(padding_x * 2.0f, 0.0f), false);
+                inputs[i]->draw(window, background.get_size() - mgl::vec2f(padding_x * 2.0f, 0.0f), false);
             }
             AsyncImageLoader::get_instance().update();
             window.display();
@@ -4669,7 +4632,7 @@ namespace QuickMedia {
         AsyncTask<BodyItems> future;
     };
 
-    static const sf::Vector2i CHAT_MESSAGE_THUMBNAIL_MAX_SIZE(600, 337);
+    static const mgl::vec2i CHAT_MESSAGE_THUMBNAIL_MAX_SIZE(600, 337);
 
     // TODO: Optimize
     static std::shared_ptr<BodyItem> find_body_item_by_event_id(const std::shared_ptr<BodyItem> *body_items, size_t num_body_items, const std::string &event_id, size_t *index_result = nullptr) {
@@ -4852,7 +4815,7 @@ namespace QuickMedia {
             show_notification("QuickMedia", "Bug: current room empty", Urgency::CRITICAL);
             abort();
         }
-        window.setTitle("QuickMedia - matrix - " + current_room->get_name());
+        window.set_title(("QuickMedia - matrix - " + current_room->get_name()).c_str());
 
         auto video_page = std::make_unique<MatrixVideoPage>(this);
         bool move_room = false;
@@ -4881,7 +4844,7 @@ namespace QuickMedia {
             tab.body->show_drop_shadow = false;
         }
 
-        Tabs ui_tabs(&rounded_rectangle_shader, is_touch_enabled() ? sf::Color::Transparent : get_theme().background_color);
+        Tabs ui_tabs(&rounded_rectangle_shader, is_touch_enabled() ? mgl::Color(0, 0, 0, 0) : get_theme().background_color);
         const int PINNED_TAB_INDEX = ui_tabs.add_tab("Pinned messages (0)", tabs[0].body.get());
         const int MESSAGES_TAB_INDEX = ui_tabs.add_tab("Messages", tabs[1].body.get());
         const int USERS_TAB_INDEX = ui_tabs.add_tab("Users (0)", tabs[2].body.get());
@@ -4894,14 +4857,13 @@ namespace QuickMedia {
 
         bool redraw = true;
 
-        sf::Clock read_marker_timer;
-        const sf::Int32 read_marker_timeout_ms_default = 3000;
-        sf::Int32 read_marker_timeout_ms = 0;
+        mgl::Clock read_marker_timer;
+        double read_marker_timeout_sec = 0;
 
         AsyncTask<void> set_read_marker_future;
         bool setting_read_marker = false;
 
-        sf::Clock start_typing_timer;
+        mgl::Clock start_typing_timer;
         const double typing_timeout_seconds = 5.0;
         bool typing = false;
 
@@ -4936,7 +4898,7 @@ namespace QuickMedia {
             }
         };
 
-        bool is_window_focused = window.hasFocus();
+        bool is_window_focused = window.has_focus();
 
         enum class ChatState {
             NAVIGATING,
@@ -4950,26 +4912,26 @@ namespace QuickMedia {
         ChatState chat_state = ChatState::NAVIGATING;
 
         std::shared_ptr<BodyItem> currently_operating_on_item;
-        sf::Text replying_to_text("Replying to:", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(18 * get_config().scale * get_config().font_scale));
+        mgl::Text replying_to_text("Replying to:", *FontLoader::get_font(FontLoader::FontType::LATIN, 18 * get_config().scale * get_config().font_scale));
 
-        sf::Sprite logo_sprite(plugin_logo);
-        logo_sprite.setScale(0.8f * get_config().scale, 0.8f * get_config().scale);
-        sf::Vector2f logo_size(plugin_logo.getSize().x * logo_sprite.getScale().x, plugin_logo.getSize().y * logo_sprite.getScale().y);
+        mgl::Sprite logo_sprite(&plugin_logo);
+        logo_sprite.set_scale(mgl::vec2f(0.8f * get_config().scale, 0.8f * get_config().scale));
+        mgl::vec2f logo_size(plugin_logo.get_size().x * logo_sprite.get_scale().x, plugin_logo.get_size().y * logo_sprite.get_scale().y);
 
         const float room_name_text_height = std::floor(18.0f * get_config().scale * get_config().font_scale);
-        sf::Text room_name_text("", *FontLoader::get_font(FontLoader::FontType::LATIN_BOLD), room_name_text_height);
+        mgl::Text room_name_text("", *FontLoader::get_font(FontLoader::FontType::LATIN_BOLD, room_name_text_height));
         const float room_name_text_padding_y = std::floor(10.0f * get_config().scale);
         const float room_name_total_height = room_name_text_height + room_name_text_padding_y * 2.0f;
         const float room_avatar_height = 32.0f;
 
         const float room_topic_text_height = std::floor(12.0f * get_config().scale * get_config().font_scale);
-        sf::Text room_topic_text("", *FontLoader::get_font(FontLoader::FontType::LATIN), room_topic_text_height);
-        room_topic_text.setFillColor(get_theme().faded_text_color);
+        mgl::Text room_topic_text("", *FontLoader::get_font(FontLoader::FontType::LATIN, room_topic_text_height));
+        room_topic_text.set_color(get_theme().faded_text_color);
 
-        sf::Text room_label(matrix_chat_page->rooms_page->get_title(), *FontLoader::get_font(FontLoader::FontType::LATIN_BOLD), std::floor(18 * get_config().scale * get_config().font_scale));
-        room_label.setPosition(15.0f, room_name_text_padding_y + 4.0f);
+        mgl::Text room_label(matrix_chat_page->rooms_page->get_title(), *FontLoader::get_font(FontLoader::FontType::LATIN_BOLD, 18 * get_config().scale * get_config().font_scale));
+        room_label.set_position(mgl::vec2f(15.0f, room_name_text_padding_y + 4.0f));
 
-        sf::Sprite room_avatar_sprite;
+        mgl::Sprite room_avatar_sprite;
         auto room_avatar_thumbnail_data = std::make_shared<ThumbnailData>();
 
         bool draw_room_list = show_room_side_panel;
@@ -5205,10 +5167,10 @@ namespace QuickMedia {
         std::string room_topic = current_room->get_topic();
         string_replace_all(room_name, '\n', ' ');
         string_replace_all(room_topic, '\n', ' ');
-        room_name_text.setString(sf::String::fromUtf8(room_name.begin(), room_name.end()));
-        room_topic_text.setString(sf::String::fromUtf8(room_topic.begin(), room_topic.end()));
+        room_name_text.set_string(std::move(room_name));
+        room_topic_text.set_string(std::move(room_topic));
 
-        read_marker_timeout_ms = 0;
+        read_marker_timeout_sec = 0;
         redraw = true;
 
         Entry chat_input("Press i to begin writing a message...", &rounded_rectangle_shader);
@@ -5284,10 +5246,10 @@ namespace QuickMedia {
         };
 
         struct Mention {
-            sf::Clock filter_timer;
+            mgl::Clock filter_timer;
             bool visible = false;
             bool filter_updated = false;
-            sf::String filter;
+            std::string filter;
             Body *users_tab_body = nullptr;
 
             void show() {
@@ -5303,44 +5265,42 @@ namespace QuickMedia {
                 users_tab_body->clear_cache();
             }
 
-            void handle_event(const sf::Event &event) {
+            void handle_event(const mgl::Event &event) {
                 if(visible) {
-                    if(event.type == sf::Event::TextEntered) {
+                    if(event.type == mgl::Event::TextEntered) {
                         filter_timer.restart();
-                        if(event.text.unicode > 32) {
-                            filter += event.text.unicode;
+                        if(event.text.codepoint > 32) {
+                            filter.append(event.text.str, event.text.size);
                             filter_updated = true;
-                        } else if(event.text.unicode == ' ' || event.text.unicode == '\t') {
+                        } else if(event.text.codepoint == ' ' || event.text.codepoint == '\t') {
                             hide();
                         }
-                    } else if(event.type == sf::Event::KeyPressed) {
-                        if(event.key.code == sf::Keyboard::Up || (event.key.control && event.key.code == sf::Keyboard::K)) {
+                    } else if(event.type == mgl::Event::KeyPressed) {
+                        if(event.key.code == mgl::Keyboard::Up || (event.key.control && event.key.code == mgl::Keyboard::K)) {
                             users_tab_body->select_previous_item(true);
-                        } else if(event.key.code == sf::Keyboard::Down || (event.key.control && event.key.code == sf::Keyboard::J)) {
+                        } else if(event.key.code == mgl::Keyboard::Down || (event.key.control && event.key.code == mgl::Keyboard::J)) {
                             users_tab_body->select_next_item(true);
-                        } else if(event.key.code == sf::Keyboard::Enter && event.key.shift) {
+                        } else if(event.key.code == mgl::Keyboard::Enter && event.key.shift) {
                             hide();
-                        } else if(event.key.code == sf::Keyboard::Backspace) {
-                            if(filter.getSize() == 0) {
+                        } else if(event.key.code == mgl::Keyboard::Backspace) {
+                            if(filter.empty()) {
                                 hide();
                             } else {
-                                filter.erase(filter.getSize() - 1, 1);
+                                filter.erase(filter.size() - 1, 1);
                                 filter_updated = true;
                             }
                         }
                     }
                 }
 
-                if(event.type == sf::Event::TextEntered && event.text.unicode == '@' && !visible)
+                if(event.type == mgl::Event::TextEntered && event.text.codepoint == '@' && !visible)
                     show();
             }
 
             void update() {
-                if(visible && filter_updated && filter_timer.getElapsedTime().asMilliseconds() > 50) {
+                if(visible && filter_updated && filter_timer.get_elapsed_time_seconds() > 0.05) {
                     filter_updated = false;
-                    // TODO: Use std::string instead of sf::String
-                    auto u8 = filter.toUtf8();
-                    users_tab_body->filter_search_fuzzy(*(std::string*)&u8);
+                    users_tab_body->filter_search_fuzzy(filter);
                     users_tab_body->select_first_item();
                 }
             }
@@ -5360,7 +5320,7 @@ namespace QuickMedia {
                     if(!str_to_append.empty())
                         str_to_append.erase(0, 1);
                     str_to_append += " ";
-                    chat_input.replace(chat_input.get_caret_index() - mention.filter.getSize(), mention.filter.getSize(), sf::String::fromUtf8(str_to_append.begin(), str_to_append.end()));
+                    chat_input.replace(chat_input.get_caret_index() - mention.filter.size(), mention.filter.size(), str_to_append);
                     mention.hide();
                 }
                 return false;
@@ -5690,12 +5650,12 @@ namespace QuickMedia {
             return false;
         };
 
-        sf::Vector2f body_pos;
-        sf::Vector2f body_size;
-        sf::Event event;
+        mgl::vec2f body_pos;
+        mgl::vec2f body_size;
+        mgl::Event event;
 
         const float gradient_height = 5.0f;
-        sf::Vertex gradient_points[4];
+        mgl::Vertex gradient_points[4];
         double gradient_inc = 0;
 
         std::string before_token;
@@ -5704,15 +5664,15 @@ namespace QuickMedia {
         bool fetched_enough_messages_bottom = false;
         bool has_unread_messages = false;
 
-        sf::RectangleShape more_messages_below_rect;
-        more_messages_below_rect.setFillColor(get_theme().new_items_alert_color);
+        mgl::Rectangle more_messages_below_rect;
+        more_messages_below_rect.set_color(get_theme().new_items_alert_color);
 
-        sf::RectangleShape chat_input_shade;
-        chat_input_shade.setFillColor(get_theme().shade_color);
+        mgl::Rectangle chat_input_shade;
+        chat_input_shade.set_color(get_theme().shade_color);
 
         float tab_vertical_offset = 0.0f;
 
-        sf::Clock frame_timer;
+        mgl::Clock frame_timer;
 
         float prev_chat_height = chat_input.get_height();
         float chat_input_height_full = 0.0f;
@@ -6103,9 +6063,9 @@ namespace QuickMedia {
                 goto chat_page_end;
         }
 
-        while (current_page == PageType::CHAT && window.isOpen() && !move_room) {
-            sf::Int32 frame_time_ms = frame_timer.restart().asMilliseconds();
-            while (window.pollEvent(event)) {
+        while (current_page == PageType::CHAT && window.is_open() && !move_room) {
+            int32_t frame_time_ms = frame_timer.restart() * 1000.0;
+            while (window.poll_event(event)) {
                 common_event_handler(event);
                 const int selected_tab = ui_tabs.get_selected();
 
@@ -6123,8 +6083,8 @@ namespace QuickMedia {
                 base_event_handler(event, PageType::EXIT, tabs[selected_tab].body.get(), nullptr, false, false);
                 event_idle_handler(event);
                 if(!frame_skip_text_entry) {
-                    if(!mention.visible || event.type != sf::Event::KeyPressed || (event.key.code != sf::Keyboard::Up && event.key.code != sf::Keyboard::Down && event.key.code != sf::Keyboard::Left && event.key.code != sf::Keyboard::Right))
-                        chat_input.process_event(event);
+                    if(!mention.visible || event.type != mgl::Event::KeyPressed || (event.key.code != mgl::Keyboard::Up && event.key.code != mgl::Keyboard::Down && event.key.code != mgl::Keyboard::Left && event.key.code != mgl::Keyboard::Right))
+                        chat_input.process_event(window, event);
                     if(chat_input.is_editable())
                         mention.handle_event(event);
                 }
@@ -6134,52 +6094,50 @@ namespace QuickMedia {
                         idle_active_handler();
                 }
 
-                if(event.type == sf::Event::KeyPressed && event.key.alt && (chat_state == ChatState::NAVIGATING || chat_state == ChatState::URL_SELECTION)) {
-                    if(event.key.code == sf::Keyboard::Up || (event.key.control && event.key.code == sf::Keyboard::K)) {
+                if(event.type == mgl::Event::KeyPressed && event.key.alt && (chat_state == ChatState::NAVIGATING || chat_state == ChatState::URL_SELECTION)) {
+                    if(event.key.code == mgl::Keyboard::Up || (event.key.control && event.key.code == mgl::Keyboard::K)) {
                         matrix_chat_page->rooms_page->body->select_previous_item(true);
                         move_room = true;
                         goto chat_page_end;
-                    } else if(event.key.code == sf::Keyboard::Down || (event.key.control && event.key.code == sf::Keyboard::J)) {
+                    } else if(event.key.code == mgl::Keyboard::Down || (event.key.control && event.key.code == mgl::Keyboard::J)) {
                         matrix_chat_page->rooms_page->body->select_next_item(true);
                         move_room = true;
                         goto chat_page_end;
-                    } else if(event.key.code == sf::Keyboard::PageUp) {
+                    } else if(event.key.code == mgl::Keyboard::PageUp) {
                         matrix_chat_page->rooms_page->body->select_previous_page();
                         move_room = true;
                         goto chat_page_end;
-                    } else if(event.key.code == sf::Keyboard::PageDown) {
+                    } else if(event.key.code == mgl::Keyboard::PageDown) {
                         matrix_chat_page->rooms_page->body->select_next_page();
                         move_room = true;
                         goto chat_page_end;
-                    } else if(event.key.code == sf::Keyboard::Home) {
+                    } else if(event.key.code == mgl::Keyboard::Home) {
                         matrix_chat_page->rooms_page->body->select_first_item(false);
                         move_room = true;
                         goto chat_page_end;
-                    } else if(event.key.code == sf::Keyboard::End) {
+                    } else if(event.key.code == mgl::Keyboard::End) {
                         matrix_chat_page->rooms_page->body->select_last_item();
                         move_room = true;
                         goto chat_page_end;
-                    } else if(event.key.code == sf::Keyboard::Escape) {
+                    } else if(event.key.code == mgl::Keyboard::Escape) {
                         move_room = false;
                         goto chat_page_end;
                     }
                     continue;
                 }
 
-                if(event.type == sf::Event::GainedFocus) {
+                if(event.type == mgl::Event::GainedFocus) {
                     is_window_focused = true;
                     redraw = true;
-                } else if(event.type == sf::Event::LostFocus) {
+                } else if(event.type == mgl::Event::LostFocus) {
                     is_window_focused = false;
-                } else if(event.type == sf::Event::Resized) {
+                } else if(event.type == mgl::Event::Resized) {
                     redraw = true;
                     idle_active_handler();
-                } else if(event.type == sf::Event::GainedFocus) {
-                    redraw = true;
-                } else if(event.type == sf::Event::KeyPressed && chat_state == ChatState::NAVIGATING) {
-                    if(event.key.code == sf::Keyboard::Escape) {
+                } else if(event.type == mgl::Event::KeyPressed && chat_state == ChatState::NAVIGATING) {
+                    if(event.key.code == mgl::Keyboard::Escape) {
                         goto chat_page_end;
-                    } else if(event.key.code == sf::Keyboard::I && event.key.control) {
+                    } else if(event.key.code == mgl::Keyboard::I && event.key.control) {
                         BodyItem *selected_item = tabs[selected_tab].body->get_selected();
                         if(selected_item && selected_item->url.empty())
                             selected_item = selected_item->embedded_item.get();
@@ -6206,13 +6164,13 @@ namespace QuickMedia {
                     }
 
                     if((selected_tab == MESSAGES_TAB_INDEX || selected_tab == PINNED_TAB_INDEX) && !frame_skip_text_entry) {
-                        if(event.key.code == sf::Keyboard::Enter) {
+                        if(event.key.code == mgl::Keyboard::Enter) {
                             BodyItem *selected = tabs[selected_tab].body->get_selected();
                             if(selected) {
                                 if(!display_url_or_image(selected))
                                     display_url_or_image(selected->embedded_item.get());
                             }
-                        } else if(event.key.code == sf::Keyboard::S && event.key.control) {
+                        } else if(event.key.code == mgl::Keyboard::S && event.key.control) {
                             BodyItem *selected = tabs[selected_tab].body->get_selected();
                             if(selected) {
                                 if(!download_selected_item(selected))
@@ -6221,35 +6179,32 @@ namespace QuickMedia {
                         }
                     }
 
-                    if(event.key.control && event.key.code == sf::Keyboard::C) {
+                    if(event.key.control && event.key.code == mgl::Keyboard::C) {
                         BodyItem *selected = tabs[selected_tab].body->get_selected();
-                        if(selected) {
-                            auto desc = selected->get_description();
-                            sf::Clipboard::setString(sf::String::fromUtf8(desc.begin(), desc.end()));
-                        }
+                        if(selected)
+                            set_clipboard(selected->get_description());
                     }
 
                     if(selected_tab == MESSAGES_TAB_INDEX) {
-                        if(event.key.code == sf::Keyboard::U) {
+                        if(event.key.code == mgl::Keyboard::U) {
                             frame_skip_text_entry = true;
                             new_page = PageType::FILE_MANAGER;
                             chat_input.set_editable(false);
                         }
 
-                        if(event.key.code == sf::Keyboard::I && !event.key.control) {
+                        if(event.key.code == mgl::Keyboard::I && !event.key.control) {
                             frame_skip_text_entry = true;
                             chat_input.set_editable(true);
                             chat_state = ChatState::TYPING_MESSAGE;
                         }
 
-                        if(event.key.control && event.key.code == sf::Keyboard::V) {
+                        if(event.key.control && event.key.code == mgl::Keyboard::V) {
                             frame_skip_text_entry = true;
                             // TODO: Upload multiple files.
-                            auto clipboard = sf::Clipboard::getString().toUtf8();
-                            upload_file(std::string(clipboard.begin(), clipboard.end()));
+                            upload_file(window.get_clipboard());
                         }
 
-                        if(event.key.code == sf::Keyboard::R && tabs[selected_tab].body->get_selected_shared()) {
+                        if(event.key.code == mgl::Keyboard::R && tabs[selected_tab].body->get_selected_shared()) {
                             std::shared_ptr<BodyItem> selected = tabs[selected_tab].body->get_selected_shared();
                             Message *selected_message = static_cast<Message*>(selected->userdata);
                             const bool go_to_replied_message = event.key.control;
@@ -6272,20 +6227,20 @@ namespace QuickMedia {
                                         chat_state = ChatState::REPLYING;
                                         currently_operating_on_item = selected;
                                         chat_input.set_editable(true);
-                                        replying_to_text.setString("Replying to:");
+                                        replying_to_text.set_string("Replying to:");
                                         frame_skip_text_entry = true;
                                     }
                                 }
                             }
                         }
 
-                        if(event.key.code == sf::Keyboard::B && event.key.control) {
+                        if(event.key.code == mgl::Keyboard::B && event.key.control) {
                             // Reload room, goes to latest message l0l
                             move_room = true;
                             goto chat_page_end;
                         }
 
-                        if(event.key.code == sf::Keyboard::E) {
+                        if(event.key.code == mgl::Keyboard::E) {
                             frame_skip_text_entry = true;
                             std::shared_ptr<BodyItem> selected = tabs[selected_tab].body->get_selected_shared();
                             if(selected) {
@@ -6305,7 +6260,7 @@ namespace QuickMedia {
                                         chat_input.set_editable(true);
                                         chat_input.set_text(selected->get_description()); // TODO: Description? it may change in the future, in which case this should be edited
                                         chat_input.move_caret_to_end();
-                                        replying_to_text.setString("Editing message:");
+                                        replying_to_text.set_string("Editing message:");
                                     }
                                 }
                             } else {
@@ -6314,7 +6269,7 @@ namespace QuickMedia {
                             }
                         }
 
-                        if(event.key.control && event.key.code == sf::Keyboard::D && !chat_input.is_editable()) {
+                        if(event.key.control && event.key.code == mgl::Keyboard::D && !chat_input.is_editable()) {
                             frame_skip_text_entry = true;
                             BodyItem *selected = tabs[selected_tab].body->get_selected();
                             if(selected) {
@@ -6342,7 +6297,7 @@ namespace QuickMedia {
                             }
                         }
 
-                        if(event.key.control && event.key.code == sf::Keyboard::P && !chat_input.is_editable()) {
+                        if(event.key.control && event.key.code == mgl::Keyboard::P && !chat_input.is_editable()) {
                             frame_skip_text_entry = true;
                             BodyItem *selected = tabs[selected_tab].body->get_selected();
                             if(selected) {
@@ -6363,7 +6318,7 @@ namespace QuickMedia {
                             }
                         }
                     } else if(selected_tab == PINNED_TAB_INDEX) {
-                        if(event.key.control && event.key.code == sf::Keyboard::D && !chat_input.is_editable()) {
+                        if(event.key.control && event.key.code == mgl::Keyboard::D && !chat_input.is_editable()) {
                             frame_skip_text_entry = true;
                             BodyItem *selected = tabs[selected_tab].body->get_selected();
                             if(selected) {
@@ -6379,7 +6334,7 @@ namespace QuickMedia {
                             }
                         }
 
-                        if(event.key.code == sf::Keyboard::R && event.key.control && tabs[selected_tab].body->get_selected_shared()) {
+                        if(event.key.code == mgl::Keyboard::R && event.key.control && tabs[selected_tab].body->get_selected_shared()) {
                             std::shared_ptr<BodyItem> selected = tabs[selected_tab].body->get_selected_shared();
                             PinnedEventData *selected_event_data = static_cast<PinnedEventData*>(selected->userdata);
                             if(selected_event_data && !selected_event_data->event_id.empty()) {
@@ -6388,11 +6343,11 @@ namespace QuickMedia {
                             }
                         }
                     }
-                } else if(event.type == sf::Event::KeyPressed && chat_state == ChatState::URL_SELECTION) {
-                    if(event.key.code == sf::Keyboard::Escape) {
+                } else if(event.type == mgl::Event::KeyPressed && chat_state == ChatState::URL_SELECTION) {
+                    if(event.key.code == mgl::Keyboard::Escape) {
                         url_selection_body.clear_items();
                         chat_state = ChatState::NAVIGATING;
-                    } else if(event.key.code == sf::Keyboard::Enter) {
+                    } else if(event.key.code == mgl::Keyboard::Enter) {
                         BodyItem *selected_item = url_selection_body.get_selected();
                         if(!selected_item)
                             continue;
@@ -6402,9 +6357,9 @@ namespace QuickMedia {
 
                 if((chat_state == ChatState::TYPING_MESSAGE || chat_state == ChatState::REPLYING || chat_state == ChatState::EDITING) && selected_tab == MESSAGES_TAB_INDEX && !frame_skip_text_entry) {
                     frame_skip_text_entry = false;
-                    if(event.type == sf::Event::TextEntered) {
+                    if(event.type == mgl::Event::TextEntered) {
                         // TODO: Also show typing event when ctrl+v pasting?
-                        if(event.text.unicode != 13) { // Return key
+                        if(event.text.codepoint != 13) { // Return key
                             start_typing_timer.restart();
                             if(!typing && current_room) {
                                 fprintf(stderr, "Started typing\n");
@@ -6412,7 +6367,7 @@ namespace QuickMedia {
                             }
                             typing = true;
                         }
-                    } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
+                    } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Escape) {
                         if(mention.visible) {
                             mention.hide();
                         } else {
@@ -6504,7 +6459,7 @@ namespace QuickMedia {
                     // TODO: Instead of doing this, exit this current function and navigate to chat login page instead.
                     //delete current_plugin;
                     //current_plugin = new Matrix();
-                    window.setTitle("QuickMedia - matrix");
+                    window.set_title("QuickMedia - matrix");
                     current_page = PageType::CHAT_LOGIN;
                     chat_login_page();
                     if(current_page == PageType::CHAT)
@@ -6531,7 +6486,7 @@ namespace QuickMedia {
                     break;
             }
 
-            if(typing && start_typing_timer.getElapsedTime().asSeconds() >= typing_timeout_seconds && current_room) {
+            if(typing && start_typing_timer.get_elapsed_time_seconds() >= typing_timeout_seconds && current_room) {
                 fprintf(stderr, "Stopped typing\n");
                 typing = false;
                 typing_state_queue.push(false);
@@ -6540,10 +6495,9 @@ namespace QuickMedia {
             if(!current_room->body_item->thumbnail_url.empty())
                 room_avatar_thumbnail_data = AsyncImageLoader::get_instance().get_thumbnail(current_room->body_item->thumbnail_url, false, AVATAR_THUMBNAIL_SIZE);
 
-            if(room_avatar_thumbnail_data->loading_state == LoadingState::FINISHED_LOADING && room_avatar_thumbnail_data->image->getSize().x > 0 && room_avatar_thumbnail_data->image->getSize().y > 0) {
-                if(!room_avatar_thumbnail_data->texture.loadFromImage(*room_avatar_thumbnail_data->image))
+            if(room_avatar_thumbnail_data->loading_state == LoadingState::FINISHED_LOADING && room_avatar_thumbnail_data->image->get_size().x > 0 && room_avatar_thumbnail_data->image->get_size().y > 0) {
+                if(!room_avatar_thumbnail_data->texture.load_from_image(*room_avatar_thumbnail_data->image))
                     fprintf(stderr, "Warning: failed to load texture for room avatar\n");
-                room_avatar_thumbnail_data->texture.setSmooth(true);
                 //room_avatar_thumbnail_data->texture.generateMipmap();
                 room_avatar_thumbnail_data->image.reset();
                 room_avatar_thumbnail_data->loading_state = LoadingState::APPLIED_TO_TEXTURE;
@@ -6552,13 +6506,13 @@ namespace QuickMedia {
 
             if(room_avatar_thumbnail_data->loading_state == LoadingState::APPLIED_TO_TEXTURE && !avatar_applied) {
                 avatar_applied = true;
-                room_avatar_sprite.setTexture(room_avatar_thumbnail_data->texture, true);
-                auto texture_size = room_avatar_sprite.getTexture()->getSize();
+                room_avatar_sprite.set_texture(&room_avatar_thumbnail_data->texture);
+                auto texture_size = room_avatar_sprite.get_texture()->get_size();
                 if(texture_size.x > 0 && texture_size.y > 0) {
                     float width_ratio = (float)texture_size.x / (float)texture_size.y;
                     float height_scale = room_avatar_height / (float)texture_size.y;
                     float width_scale = height_scale * width_ratio;
-                    room_avatar_sprite.setScale(width_scale * get_config().scale, height_scale * get_config().scale);
+                    room_avatar_sprite.set_scale(mgl::vec2f(width_scale * get_config().scale, height_scale * get_config().scale));
                 }
                 redraw = true;
             }
@@ -6590,28 +6544,28 @@ namespace QuickMedia {
 
                 const float body_width = window_size.x;
 
-                this->body_pos = sf::Vector2f(0.0f, tab_shade_height);
+                this->body_pos = mgl::vec2f(0.0f, tab_shade_height);
                 if(window_size.x > 900.0f * get_config().scale * get_config().font_scale && show_room_side_panel) {
                     this->body_size = vec2f_floor(300.0f * get_config().scale * get_config().font_scale, window_size.y - tab_shade_height);
                     draw_room_list = true;
                 } else {
-                    this->body_size = sf::Vector2f(0.0f, 0.0f);
+                    this->body_size = mgl::vec2f(0.0f, 0.0f);
                     draw_room_list = false;
                 }
 
-                body_pos = sf::Vector2f(this->body_pos.x + this->body_size.x, tab_shade_height);
-                body_size = sf::Vector2f(body_width - this->body_pos.x - this->body_size.x, window_size.y - chat_input_height_full - tab_shade_height);
+                body_pos = mgl::vec2f(this->body_pos.x + this->body_size.x, tab_shade_height);
+                body_size = mgl::vec2f(body_width - this->body_pos.x - this->body_size.x, window_size.y - chat_input_height_full - tab_shade_height);
 
-                chat_input_shade.setSize(sf::Vector2f(window_size.x - body_pos.x, chat_input_height_full));
-                chat_input_shade.setPosition(body_pos.x, window_size.y - chat_input_shade.getSize().y);
+                chat_input_shade.set_size(mgl::vec2f(window_size.x - body_pos.x, chat_input_height_full));
+                chat_input_shade.set_position(mgl::vec2f(body_pos.x, window_size.y - chat_input_shade.get_size().y));
 
                 chat_input.set_max_width(window_size.x - (logo_padding_x + logo_size.x + chat_input_padding_x + logo_padding_x + body_pos.x));
                 chat_input.set_position(vec2f_floor(body_pos.x + logo_padding_x + logo_size.x + chat_input_padding_x, window_size.y - chat_height - chat_input_padding_y));
 
-                more_messages_below_rect.setSize(sf::Vector2f(chat_input_shade.getSize().x, gradient_height));
-                more_messages_below_rect.setPosition(chat_input_shade.getPosition().x, std::floor(window_size.y - chat_input_height_full - gradient_height));
+                more_messages_below_rect.set_size(mgl::vec2f(chat_input_shade.get_size().x, gradient_height));
+                more_messages_below_rect.set_position(mgl::vec2f(chat_input_shade.get_position().x, std::floor(window_size.y - chat_input_height_full - gradient_height)));
 
-                logo_sprite.setPosition(body_pos.x + logo_padding_x, std::floor(window_size.y - chat_input_height_full * 0.5f - logo_size.y * 0.5f));
+                logo_sprite.set_position(mgl::vec2f(body_pos.x + logo_padding_x, std::floor(window_size.y - chat_input_height_full * 0.5f - logo_size.y * 0.5f)));
             }
 
             sync_data.messages.clear();
@@ -6716,52 +6670,52 @@ namespace QuickMedia {
             } else {
                 tabs[selected_tab].body->draw(window, body_pos, body_size);
                 if(selected_tab == MESSAGES_TAB_INDEX && mention.visible && chat_state == ChatState::TYPING_MESSAGE) {
-                    sf::RectangleShape user_mention_background(sf::Vector2f(body_size.x, user_mention_body_height));
-                    user_mention_background.setPosition(sf::Vector2f(body_pos.x, body_pos.y + body_size.y - user_mention_body_height));
-                    user_mention_background.setFillColor(get_theme().shade_color);
+                    mgl::Rectangle user_mention_background(mgl::vec2f(body_size.x, user_mention_body_height));
+                    user_mention_background.set_position(mgl::vec2f(body_pos.x, body_pos.y + body_size.y - user_mention_body_height));
+                    user_mention_background.set_color(get_theme().shade_color);
 
                     window.draw(user_mention_background);
-                    tabs[USERS_TAB_INDEX].body->draw(window, user_mention_background.getPosition(), user_mention_background.getSize());
+                    tabs[USERS_TAB_INDEX].body->draw(window, user_mention_background.get_position(), user_mention_background.get_size());
                 }
             }
 
-            //tab_shade.setSize(sf::Vector2f(window_size.x, tab_shade_height));
+            //tab_shade.set_size(mgl::vec2f(window_size.x, tab_shade_height));
             //window.draw(tab_shade);
 
             if(selected_tab == MESSAGES_TAB_INDEX || selected_tab == PINNED_TAB_INDEX || selected_tab == USERS_TAB_INDEX) {
                 float room_name_text_offset_x = std::floor(10.0f * get_config().scale);
-                if(room_avatar_thumbnail_data->loading_state == LoadingState::APPLIED_TO_TEXTURE && room_avatar_sprite.getTexture() && room_avatar_sprite.getTexture()->getNativeHandle() != 0) {
-                    auto room_avatar_texture_size = room_avatar_sprite.getTexture()->getSize();
-                    room_avatar_texture_size.x *= room_avatar_sprite.getScale().x;
-                    room_avatar_texture_size.y *= room_avatar_sprite.getScale().y;
-                    room_avatar_sprite.setPosition(body_pos.x + std::floor(10.0f * get_config().scale), room_name_total_height * 0.5f - room_avatar_texture_size.y * 0.5f + 5.0f);
-                    circle_mask_shader.setUniform("resolution", sf::Vector2f(room_avatar_texture_size.x, room_avatar_texture_size.y));
+                if(room_avatar_thumbnail_data->loading_state == LoadingState::APPLIED_TO_TEXTURE && room_avatar_sprite.get_texture() && room_avatar_sprite.get_texture()->is_valid()) {
+                    auto room_avatar_texture_size = room_avatar_sprite.get_texture()->get_size();
+                    room_avatar_texture_size.x *= room_avatar_sprite.get_scale().x;
+                    room_avatar_texture_size.y *= room_avatar_sprite.get_scale().y;
+                    room_avatar_sprite.set_position(mgl::vec2f(body_pos.x + std::floor(10.0f * get_config().scale), room_name_total_height * 0.5f - room_avatar_texture_size.y * 0.5f + 5.0f));
+                    circle_mask_shader.set_uniform("resolution", mgl::vec2f(room_avatar_texture_size.x, room_avatar_texture_size.y));
                     window.draw(room_avatar_sprite, &circle_mask_shader);
                     room_name_text_offset_x += room_avatar_texture_size.x + 10.0f;
                 }
 
-                room_name_text.setPosition(body_pos.x + room_name_text_offset_x, room_name_text_padding_y);
+                room_name_text.set_position(mgl::vec2f(body_pos.x + room_name_text_offset_x, room_name_text_padding_y - 3.0f));
                 window.draw(room_name_text);
 
-                room_topic_text.setPosition(room_name_text.getPosition().x + room_name_text.getLocalBounds().width + 15.0f, room_name_text_padding_y + 2.0f + room_name_text_height * 0.5f - room_topic_text_height * 0.5f);
+                room_topic_text.set_position(mgl::vec2f(room_name_text.get_position().x + room_name_text.get_bounds().size.x + 15.0f, room_name_text_padding_y - 1.0f + room_name_text_height * 0.5f - room_topic_text_height * 0.5f));
                 window.draw(room_topic_text);
             }
 
             if(draw_room_list) {
-                sf::RectangleShape room_list_background(sf::Vector2f(this->body_size.x, window_size.y));
-                //room_list_background.setPosition(this->body_pos);
-                room_list_background.setFillColor(get_theme().shade_color);
+                mgl::Rectangle room_list_background(mgl::vec2f(this->body_size.x, window_size.y));
+                //room_list_background.set_position(this->body_pos);
+                room_list_background.set_color(get_theme().shade_color);
                 window.draw(room_list_background);
                 window.draw(room_label);
                 const float tab_y = std::floor(tab_vertical_offset) + room_name_padding_y;
-                matrix_chat_page->rooms_page->body->draw(window, sf::Vector2f(0.0f, tab_y), sf::Vector2f(this->body_size.x, window_size.y - tab_y), Json::Value::nullSingleton());
+                matrix_chat_page->rooms_page->body->draw(window, mgl::vec2f(0.0f, tab_y), mgl::vec2f(this->body_size.x, window_size.y - tab_y), Json::Value::nullSingleton());
             }
 
-            ui_tabs.draw(window, sf::Vector2f(body_pos.x, std::floor(tab_vertical_offset) + room_name_padding_y), body_size.x);
+            ui_tabs.draw(window, mgl::vec2f(body_pos.x, std::floor(tab_vertical_offset) + room_name_padding_y), body_size.x);
 
             if(chat_state == ChatState::REPLYING || chat_state == ChatState::EDITING) {
                 const float margin = 5.0f;
-                const float replying_to_text_height = replying_to_text.getLocalBounds().height + margin;
+                const float replying_to_text_height = replying_to_text.get_bounds().size.y + margin;
 
                 float item_height = std::min(body_size.y - replying_to_text_height - margin, tabs[MESSAGES_TAB_INDEX].body->get_item_height(currently_operating_on_item.get(), body_size.x) + margin);
                 if(item_height < 0.0f)
@@ -6771,38 +6725,38 @@ namespace QuickMedia {
                 if(mention.visible)
                     extra_user_mention_height = user_mention_body_height;
 
-                sf::RectangleShape overlay(sf::Vector2f(window_size.x, window_size.y - chat_input_height_full - extra_user_mention_height));
-                overlay.setFillColor(sf::Color(0, 0, 0, 240));
+                mgl::Rectangle overlay(mgl::vec2f(window_size.x, window_size.y - chat_input_height_full - extra_user_mention_height));
+                overlay.set_color(mgl::Color(0, 0, 0, 240));
                 window.draw(overlay);
 
                 const float padding_x = std::floor(10.0f * get_config().scale);
-                sf::Vector2f body_item_pos(body_pos.x + padding_x, window_size.y - chat_input_height_full - item_height);
-                sf::Vector2f body_item_size(body_size.x - padding_x * 2.0f, item_height);
+                mgl::vec2f body_item_pos(body_pos.x + padding_x, window_size.y - chat_input_height_full - item_height);
+                mgl::vec2f body_item_size(body_size.x - padding_x * 2.0f, item_height);
 
-                sf::RectangleShape item_background(sf::Vector2f(window_size.x, body_item_size.y + chat_input_height_full + replying_to_text_height + margin));
-                item_background.setPosition(sf::Vector2f(0.0f, window_size.y - (body_item_size.y + chat_input_height_full + replying_to_text_height + margin)));
-                item_background.setFillColor(get_theme().background_color);
+                mgl::Rectangle item_background(mgl::vec2f(window_size.x, body_item_size.y + chat_input_height_full + replying_to_text_height + margin));
+                item_background.set_position(mgl::vec2f(0.0f, window_size.y - (body_item_size.y + chat_input_height_full + replying_to_text_height + margin)));
+                item_background.set_color(get_theme().background_color);
                 window.draw(item_background);
 
                 if(mention.visible) {
-                    sf::RectangleShape user_mention_background(sf::Vector2f(window_size.x, user_mention_body_height));
-                    user_mention_background.setPosition(sf::Vector2f(0.0f, item_background.getPosition().y - user_mention_body_height));
-                    user_mention_background.setFillColor(get_theme().shade_color);
+                    mgl::Rectangle user_mention_background(mgl::vec2f(window_size.x, user_mention_body_height));
+                    user_mention_background.set_position(mgl::vec2f(0.0f, item_background.get_position().y - user_mention_body_height));
+                    user_mention_background.set_color(get_theme().shade_color);
 
                     window.draw(user_mention_background);
                     tabs[USERS_TAB_INDEX].body->draw(window,
-                        sf::Vector2f(body_pos.x + padding_x, item_background.getPosition().y - user_mention_body_height),
-                        sf::Vector2f(body_size.x - padding_x * 2.0f, user_mention_body_height));
+                        mgl::vec2f(body_pos.x + padding_x, item_background.get_position().y - user_mention_body_height),
+                        mgl::vec2f(body_size.x - padding_x * 2.0f, user_mention_body_height));
                 }
                 
-                replying_to_text.setPosition(body_item_pos.x, body_item_pos.y - replying_to_text_height);
+                replying_to_text.set_position(mgl::vec2f(body_item_pos.x, body_item_pos.y - replying_to_text_height));
                 window.draw(replying_to_text);
 
                 tabs[MESSAGES_TAB_INDEX].body->draw_item(window, currently_operating_on_item, body_item_pos, body_item_size);
             }
 
             if(selected_tab == MESSAGES_TAB_INDEX && current_room && current_room->body_item && (!current_room->last_message_read || has_unread_messages) && matrix->is_initial_sync_finished()) {
-                if(after_token.empty() && !tabs[selected_tab].body->is_bottom_cut_off() && is_window_focused && chat_state != ChatState::URL_SELECTION && !setting_read_marker && read_marker_timer.getElapsedTime().asMilliseconds() >= read_marker_timeout_ms) {
+                if(after_token.empty() && !tabs[selected_tab].body->is_bottom_cut_off() && is_window_focused && chat_state != ChatState::URL_SELECTION && !setting_read_marker && read_marker_timer.get_elapsed_time_seconds() >= read_marker_timeout_sec) {
                     auto body_items = tabs[selected_tab].body->get_items();
                     int last_timeline_message = (int)body_items.size() - 1;
                     for(int i = last_timeline_message - 1; i >= 0; --i) {
@@ -6860,9 +6814,9 @@ namespace QuickMedia {
                 // TODO: fetch_messages_dir
                 double progress = 0.5 + std::sin(std::fmod(gradient_inc, 360.0) * 0.017453292519943295 - 1.5707963267948966*0.5) * 0.5;
                 gradient_inc += (frame_time_ms * 0.5);
-                sf::Color top_color = interpolate_colors(get_theme().background_color, get_theme().loading_page_color, progress);
+                mgl::Color top_color = interpolate_colors(get_theme().background_color, get_theme().loading_page_color, progress);
 
-                gradient_points[0].position.x = chat_input_shade.getPosition().x;
+                gradient_points[0].position.x = chat_input_shade.get_position().x;
                 gradient_points[0].position.y = tab_shade_height;
 
                 gradient_points[1].position.x = window_size.x;
@@ -6871,7 +6825,7 @@ namespace QuickMedia {
                 gradient_points[2].position.x = window_size.x;
                 gradient_points[2].position.y = tab_shade_height + gradient_height;
 
-                gradient_points[3].position.x = chat_input_shade.getPosition().x;
+                gradient_points[3].position.x = chat_input_shade.get_position().x;
                 gradient_points[3].position.y = tab_shade_height + gradient_height;
 
                 gradient_points[0].color = top_color;
@@ -6880,10 +6834,10 @@ namespace QuickMedia {
                 gradient_points[3].color = get_theme().background_color;
 
                 if(fetch_messages_dir == MessageDirection::AFTER) {
-                    gradient_points[0].position.y = more_messages_below_rect.getPosition().y;
-                    gradient_points[1].position.y = more_messages_below_rect.getPosition().y;
-                    gradient_points[2].position.y = more_messages_below_rect.getPosition().y + gradient_height;
-                    gradient_points[3].position.y = more_messages_below_rect.getPosition().y + gradient_height;
+                    gradient_points[0].position.y = more_messages_below_rect.get_position().y;
+                    gradient_points[1].position.y = more_messages_below_rect.get_position().y;
+                    gradient_points[2].position.y = more_messages_below_rect.get_position().y + gradient_height;
+                    gradient_points[3].position.y = more_messages_below_rect.get_position().y + gradient_height;
                     
                     gradient_points[0].color = get_theme().background_color;
                     gradient_points[1].color = get_theme().background_color;
@@ -6891,7 +6845,7 @@ namespace QuickMedia {
                     gradient_points[3].color = top_color;
                 }
 
-                window.draw(gradient_points, 4, sf::Quads); // Note: sf::Quads doesn't work with egl
+                window.draw(gradient_points, 4, mgl::PrimitiveType::Quads); // Note: mgl::PrimitiveType::Quads doesn't work with egl
             }
 
             if(selected_tab == MESSAGES_TAB_INDEX) {
@@ -6999,7 +6953,7 @@ namespace QuickMedia {
         matrix_chat_page->set_current_room(nullptr, nullptr);
         fetch_messages_future.cancel();
         cleanup_tasks();
-        window.setTitle("QuickMedia - matrix");
+        window.set_title("QuickMedia - matrix");
         return move_room;
     }
 
@@ -7012,7 +6966,7 @@ namespace QuickMedia {
     }
 
     void Program::after_matrix_login_page() {
-        if(!window.isOpen())
+        if(!window.is_open())
             exit(exit_code);
 
         auto rooms_tags_body = create_body();
@@ -7078,7 +7032,7 @@ namespace QuickMedia {
     }
 
     void Program::download_page(std::string url) {
-        window.setTitle("QuickMedia - Select where you want to save " + std::string(url));
+        window.set_title(("QuickMedia - Select where you want to save " + std::string(url)).c_str());
 
         url = invidious_url_to_youtube_url(url);
         const bool download_use_youtube_dl = url_should_download_with_youtube_dl(url);
@@ -7225,32 +7179,18 @@ namespace QuickMedia {
 
         string_replace_all(filename, '/', '_');
         std::string output_filepath = file_save_page(filename);
-        if(!window.isOpen() || output_filepath.empty()) {
+        if(!window.is_open() || output_filepath.empty()) {
             exit_code = 1;
             return;
         }
 
-        sf::Vector2i monitor_size;
-        sf::Vector2i focused_monitor_center = get_focused_monitor_center(disp, monitor_size);
+        mgl::vec2i monitor_size;
+        mgl::vec2i focused_monitor_center = get_focused_monitor_center(disp, monitor_size);
         window_size.x = std::min(monitor_size.x, (int)(300.0f + 380.0f * get_config().scale));
         window_size.y = std::min(monitor_size.y, (int)(50.0f + 130.0f * get_config().scale));
-        window.setSize(sf::Vector2u(window_size.x, window_size.y));
-        XSizeHints *size_hints = XAllocSizeHints();
-        if(size_hints) {
-            size_hints->width = window_size.x;
-            size_hints->min_width = window_size.x;
-            size_hints->max_width = window_size.x;
-
-            size_hints->height = window_size.y;
-            size_hints->min_height = window_size.y;
-            size_hints->max_height = window_size.y;
-            size_hints->flags = PSize | PMinSize | PMaxSize;
-
-            XSetWMNormalHints(disp, x11_window, size_hints);
-            XFree(size_hints);
-            XFlush(disp);
-        }
-        window.setPosition(sf::Vector2i(focused_monitor_center.x - window_size.x * 0.5f, focused_monitor_center.y - window_size.y * 0.5f));
+        window.set_size(mgl::vec2i(window_size.x, window_size.y));
+        window.set_size_limits(window_size, window_size);
+        window.set_position(mgl::vec2i(focused_monitor_center.x - window_size.x * 0.5f, focused_monitor_center.y - window_size.y * 0.5f));
 
         std::string output_filepath_s = output_filepath;
         char *output_dir = dirname(output_filepath_s.data());
@@ -7266,22 +7206,22 @@ namespace QuickMedia {
 
         const float loading_bar_padding_x = std::floor(4.0f * get_config().scale);
         const float loading_bar_padding_y = std::floor(4.0f * get_config().scale);
-        RoundedRectangle loading_bar_background(sf::Vector2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale), get_theme().background_color, &rounded_rectangle_shader);
-        RoundedRectangle loading_bar(sf::Vector2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale - loading_bar_padding_y), get_theme().loading_bar_color, &rounded_rectangle_shader);
+        RoundedRectangle loading_bar_background(mgl::vec2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale), get_theme().background_color, &rounded_rectangle_shader);
+        RoundedRectangle loading_bar(mgl::vec2f(1.0f, 1.0f), std::floor(10.0f * get_config().scale - loading_bar_padding_y), get_theme().loading_bar_color, &rounded_rectangle_shader);
 
         const float padding_x = std::floor(30.0f * get_config().scale);
         const float spacing_y = std::floor(15.0f * get_config().scale);
         const float loading_bar_height = std::floor(20.0f * get_config().scale);
 
-        sf::Text progress_text("0kb/Unknown", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(20.0f * get_config().scale * get_config().font_scale));
-        sf::Text status_text("Downloading", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(20.0f * get_config().scale * get_config().font_scale));
-        sf::Text filename_text(filename.c_str(), *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(14.0f * get_config().scale * get_config().font_scale));
-        filename_text.setFillColor(get_theme().faded_text_color);
-        sf::Text download_speed_text("0 bytes/s", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(14.0f * get_config().scale * get_config().font_scale));
-        download_speed_text.setFillColor(get_theme().faded_text_color);
+        mgl::Text progress_text("0kb/Unknown", *FontLoader::get_font(FontLoader::FontType::LATIN, 20.0f * get_config().scale * get_config().font_scale));
+        mgl::Text status_text("Downloading", *FontLoader::get_font(FontLoader::FontType::LATIN, 20.0f * get_config().scale * get_config().font_scale));
+        mgl::Text filename_text(filename.c_str(), *FontLoader::get_font(FontLoader::FontType::LATIN, 14.0f * get_config().scale * get_config().font_scale));
+        filename_text.set_color(get_theme().faded_text_color);
+        mgl::Text download_speed_text("0 bytes/s", *FontLoader::get_font(FontLoader::FontType::LATIN, 14.0f * get_config().scale * get_config().font_scale));
+        download_speed_text.set_color(get_theme().faded_text_color);
 
         bool redraw = true;
-        sf::Event event;
+        mgl::Event event;
 
         std::unique_ptr<Downloader> downloader;
         if(download_use_youtube_dl) {
@@ -7306,20 +7246,18 @@ namespace QuickMedia {
             return;
         }
 
-        sf::Clock frame_timer;
-        sf::Clock progress_update_timer;
+        mgl::Clock frame_timer;
+        mgl::Clock progress_update_timer;
         bool download_completed = false;
         float progress = 0.0f;
         float ui_progress = 0.0f;
 
-        while(window.isOpen()) {
-            while (window.pollEvent(event)) {
+        while(window.is_open()) {
+            while (window.poll_event(event)) {
                 common_event_handler(event);
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
                     redraw = true;
                 }
             }
@@ -7332,7 +7270,7 @@ namespace QuickMedia {
                 exit(exit_code);
             }
 
-            if(progress_update_timer.getElapsedTime().asSeconds() >= 1.0f) {
+            if(progress_update_timer.get_elapsed_time_seconds() >= 1.0f) {
                 progress_update_timer.restart();
                 DownloadUpdateStatus update_status = downloader->update();
                 switch(update_status) {
@@ -7348,29 +7286,29 @@ namespace QuickMedia {
 
                 progress = downloader->get_progress();
                 progress = std::max(0.0f, std::min(1.0f, progress));
-                progress_text.setString(downloader->get_progress_text());
-                download_speed_text.setString(downloader->get_download_speed_text());
+                progress_text.set_string(downloader->get_progress_text());
+                download_speed_text.set_string(downloader->get_download_speed_text());
                 redraw = true;
             }
 
             if(redraw) {
                 redraw = false;
-                loading_bar_background.set_size(sf::Vector2f(window_size.x - padding_x * 2.0f, loading_bar_height));
-                loading_bar_background.set_position(window_size * 0.5f - loading_bar_background.get_size() * 0.5f + sf::Vector2f(0.0f, download_speed_text.getLocalBounds().height * 0.5f));
+                loading_bar_background.set_size(mgl::vec2f(window_size.x - padding_x * 2.0f, loading_bar_height));
+                loading_bar_background.set_position(window_size.to_vec2f() * 0.5f - loading_bar_background.get_size() * 0.5f + mgl::vec2f(0.0f, download_speed_text.get_bounds().size.y * 0.5f));
                 loading_bar_background.set_position(vec2f_floor(loading_bar_background.get_position().x, loading_bar_background.get_position().y));
-                loading_bar.set_position(loading_bar_background.get_position() + sf::Vector2f(loading_bar_padding_x, loading_bar_padding_y));
-                filename_text.setPosition(
-                    loading_bar_background.get_position() + sf::Vector2f(0.0f, -(filename_text.getLocalBounds().height + spacing_y)));
-                progress_text.setPosition(
-                    filename_text.getPosition() + sf::Vector2f(loading_bar_background.get_size().x - progress_text.getLocalBounds().width, -(progress_text.getLocalBounds().height + spacing_y)));
-                status_text.setPosition(
-                    filename_text.getPosition() + sf::Vector2f(0.0f, -(status_text.getLocalBounds().height + spacing_y)));
-                download_speed_text.setPosition(
-                    loading_bar_background.get_position() + sf::Vector2f(0.0f, loading_bar_height + spacing_y));
+                loading_bar.set_position(loading_bar_background.get_position() + mgl::vec2f(loading_bar_padding_x, loading_bar_padding_y));
+                filename_text.set_position(
+                    loading_bar_background.get_position() + mgl::vec2f(0.0f, -(filename_text.get_bounds().size.y + spacing_y)));
+                progress_text.set_position(
+                    filename_text.get_position() + mgl::vec2f(loading_bar_background.get_size().x - progress_text.get_bounds().size.x, -(progress_text.get_bounds().size.y + spacing_y)));
+                status_text.set_position(
+                    filename_text.get_position() + mgl::vec2f(0.0f, -(status_text.get_bounds().size.y + spacing_y)));
+                download_speed_text.set_position(
+                    loading_bar_background.get_position() + mgl::vec2f(0.0f, loading_bar_height + spacing_y));
             }
 
             const float progress_diff = progress - ui_progress;
-            const float progress_move = frame_timer.getElapsedTime().asSeconds() * 500.0f * std::abs(progress_diff);
+            const float progress_move = frame_timer.get_elapsed_time_seconds() * 500.0f * std::abs(progress_diff);
             if(std::abs(progress_diff) < progress_move) {
                 ui_progress = progress;
             } else {
@@ -7380,7 +7318,7 @@ namespace QuickMedia {
                     ui_progress -= progress_move;
             }
 
-            loading_bar.set_size(sf::Vector2f(
+            loading_bar.set_size(mgl::vec2f(
                 std::floor((loading_bar_background.get_size().x - loading_bar_padding_x * 2.0f) * ui_progress),
                 loading_bar_height - loading_bar_padding_y * 2.0f));
 
@@ -7409,10 +7347,10 @@ namespace QuickMedia {
     }
 
     std::string Program::file_save_page(const std::string &filename) {
-        sf::Vector2f body_pos;
-        sf::Vector2f body_size;
+        mgl::vec2f body_pos;
+        mgl::vec2f body_size;
         bool redraw = true;
-        sf::Event event;
+        mgl::Event event;
 
         auto file_manager_page = std::make_unique<FileManagerPage>(this);
         file_manager_page->set_current_directory(file_manager_start_dir);
@@ -7431,8 +7369,8 @@ namespace QuickMedia {
         };
 
         search_bar->onTextSubmitCallback = [this, &search_bar, &file_manager_body, &file_manager_page, &ui_tabs, tab_path_index](const std::string&) {
-            if(sf::Keyboard::isKeyPressed(sf::Keyboard::LControl) || sf::Keyboard::isKeyPressed(sf::Keyboard::RControl))
-                return;
+            if(window.is_key_pressed(mgl::Keyboard::LControl) || window.is_key_pressed(mgl::Keyboard::RControl))
+               return;
 
             BodyItem *selected = file_manager_body->get_selected();
             if(!selected)
@@ -7459,28 +7397,27 @@ namespace QuickMedia {
         const float bottom_panel_padding = 10.0f;
         const float bottom_panel_spacing = 10.0f;
 
-        Button cancel_button("Cancel", FontLoader::get_font(FontLoader::FontType::LATIN), 16, 100.0f, &rounded_rectangle_shader, get_config().scale * get_config().font_scale);
+        Button cancel_button("Cancel", FontLoader::get_font(FontLoader::FontType::LATIN, 16 * get_config().scale), 100.0f, &rounded_rectangle_shader, get_config().scale * get_config().font_scale);
         cancel_button.set_background_color(get_theme().cancel_button_background_color);
 
-        Button save_button("Save", FontLoader::get_font(FontLoader::FontType::LATIN), 16, 100.0f, &rounded_rectangle_shader, get_config().scale * get_config().font_scale);
+        Button save_button("Save", FontLoader::get_font(FontLoader::FontType::LATIN, 16 * get_config().scale), 100.0f, &rounded_rectangle_shader, get_config().scale * get_config().font_scale);
         save_button.set_background_color(get_theme().confirm_button_background_color);
 
-        sf::Text file_name_label("File name:", *FontLoader::get_font(FontLoader::FontType::LATIN), std::floor(16.0f * get_config().scale * get_config().font_scale));
+        mgl::Text file_name_label("File name:", *FontLoader::get_font(FontLoader::FontType::LATIN, 16.0f * get_config().scale * get_config().font_scale));
 
         Entry file_name_entry("", &rounded_rectangle_shader);
         file_name_entry.set_text(filename);
         file_name_entry.set_single_line(true);
         file_name_entry.set_editable(false);
 
-        sf::RectangleShape bottom_panel_background;
-        bottom_panel_background.setFillColor(get_theme().shade_color);
+        mgl::Rectangle bottom_panel_background;
+        bottom_panel_background.set_color(get_theme().shade_color);
 
         const float gradient_height = 5.0f;
-        sf::Vertex gradient_points[4];
+        mgl::Vertex gradient_points[4];
 
         auto save_file = [this, &file_name_entry, &file_manager_page]() -> std::string {
-            auto u8 = file_name_entry.get_text().toUtf8();
-            std::string *filename = (std::string*)&u8;
+            const std::string *filename = &file_name_entry.get_text();
 
             Path filename_full_path = file_manager_page->get_current_directory().string();
             filename_full_path.join(*filename);
@@ -7520,15 +7457,15 @@ namespace QuickMedia {
 
         float prev_entry_height = file_name_entry.get_height();
 
-        while (window.isOpen()) {
-            while (window.pollEvent(event)) {
+        while (window.is_open()) {
+            while (window.poll_event(event)) {
                 common_event_handler(event);
                 if(file_manager_body->on_event(window, event, !file_name_entry.is_editable()))
                     idle_active_handler();
                 else
                     event_idle_handler(event);
 
-                search_bar->on_event(event);
+                search_bar->on_event(window, event);
                 if(cancel_button.on_event(event) & BUTTON_EVENT_CLICKED)
                     return "";
                 if(save_button.on_event(event) & BUTTON_EVENT_CLICKED) {
@@ -7536,25 +7473,23 @@ namespace QuickMedia {
                     if(!save_path.empty())
                         return save_path;
                 }
-                file_name_entry.process_event(event);
+                file_name_entry.process_event(window, event);
 
-                if(event.type == sf::Event::Resized) {
+                if(event.type == mgl::Event::Resized) {
                     window_size.x = event.size.width;
                     window_size.y = event.size.height;
-                    sf::FloatRect visible_area(0, 0, window_size.x, window_size.y);
-                    window.setView(sf::View(visible_area));
                     redraw = true;
                     idle_active_handler();
-                } else if(event.type == sf::Event::GainedFocus) {
+                } else if(event.type == mgl::Event::GainedFocus) {
                     redraw = true;
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Tab) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Tab) {
                     file_name_entry.set_editable(!file_name_entry.is_editable());
                     search_bar->set_editable(!search_bar->is_editable());
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Enter && event.key.control) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Enter && event.key.control) {
                     std::string save_path = save_file();
                     if(!save_path.empty())
                         return save_path;
-                } else if(event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape) {
+                } else if(event.type == mgl::Event::KeyPressed && event.key.code == mgl::Keyboard::Escape) {
                     window.close();
                 }
             }
@@ -7573,30 +7508,30 @@ namespace QuickMedia {
                 get_body_dimensions(window_size, search_bar.get(), body_pos, body_size);
                 body_pos.y += Tabs::get_shade_height();
                 body_size.y -= Tabs::get_shade_height();
-                save_button.set_position(window_size - sf::Vector2f(save_button.get_width(), save_button.get_height()) - sf::Vector2f(bottom_panel_padding, bottom_panel_padding));
-                cancel_button.set_position(save_button.get_position() - sf::Vector2f(cancel_button.get_width() + bottom_panel_spacing, 0.0f));
-                file_name_label.setPosition(sf::Vector2f(bottom_panel_spacing, std::floor(window_size.y - bottom_panel_padding - file_name_entry.get_height() * 0.5f - file_name_label.getLocalBounds().height * 0.5f - 5.0f * get_config().scale)));
-                file_name_entry.set_position(sf::Vector2f(file_name_label.getPosition().x + file_name_label.getLocalBounds().width + bottom_panel_spacing, window_size.y - file_name_entry.get_height() - bottom_panel_padding));
-                file_name_entry.set_max_width(std::floor(cancel_button.get_position().x - bottom_panel_spacing - file_name_label.getLocalBounds().width - bottom_panel_spacing - bottom_panel_spacing));
-                bottom_panel_background.setPosition(0.0f, window_size.y - std::floor(bottom_panel_padding * 2.0f + file_name_entry.get_height()));
-                bottom_panel_background.setSize(sf::Vector2f(window_size.x, std::floor(bottom_panel_padding * 2.0f + file_name_entry.get_height())));
+                save_button.set_position(window_size.to_vec2f() - mgl::vec2f(save_button.get_width(), save_button.get_height()) - mgl::vec2f(bottom_panel_padding, bottom_panel_padding));
+                cancel_button.set_position(save_button.get_position() - mgl::vec2f(cancel_button.get_width() + bottom_panel_spacing, 0.0f));
+                file_name_label.set_position(mgl::vec2f(bottom_panel_spacing, std::floor(window_size.y - bottom_panel_padding - file_name_entry.get_height() * 0.5f - file_name_label.get_bounds().size.y * 0.5f - 5.0f * get_config().scale)));
+                file_name_entry.set_position(mgl::vec2f(file_name_label.get_position().x + file_name_label.get_bounds().size.x + bottom_panel_spacing, window_size.y - file_name_entry.get_height() - bottom_panel_padding));
+                file_name_entry.set_max_width(std::floor(cancel_button.get_position().x - bottom_panel_spacing - file_name_label.get_bounds().size.x - bottom_panel_spacing - bottom_panel_spacing));
+                bottom_panel_background.set_position(mgl::vec2f(0.0f, window_size.y - std::floor(bottom_panel_padding * 2.0f + file_name_entry.get_height())));
+                bottom_panel_background.set_size(mgl::vec2f(window_size.x, std::floor(bottom_panel_padding * 2.0f + file_name_entry.get_height())));
 
-                const sf::Color color(0, 0, 0, 50);
-                gradient_points[0] = sf::Vertex(bottom_panel_background.getPosition() + sf::Vector2f(0.0f, -gradient_height), sf::Color(color.r, color.g, color.b, 0));
-                gradient_points[1] = sf::Vertex(bottom_panel_background.getPosition() + sf::Vector2f(bottom_panel_background.getSize().x, -gradient_height), sf::Color(color.r, color.g, color.b, 0));
-                gradient_points[2] = sf::Vertex(bottom_panel_background.getPosition() + sf::Vector2f(bottom_panel_background.getSize().x, 0.0f), color);
-                gradient_points[3] = sf::Vertex(bottom_panel_background.getPosition() + sf::Vector2f(0.0f, 0.0f), color);
+                const mgl::Color color(0, 0, 0, 50);
+                gradient_points[0] = mgl::Vertex(bottom_panel_background.get_position() + mgl::vec2f(0.0f, -gradient_height), mgl::Color(color.r, color.g, color.b, 0));
+                gradient_points[1] = mgl::Vertex(bottom_panel_background.get_position() + mgl::vec2f(bottom_panel_background.get_size().x, -gradient_height), mgl::Color(color.r, color.g, color.b, 0));
+                gradient_points[2] = mgl::Vertex(bottom_panel_background.get_position() + mgl::vec2f(bottom_panel_background.get_size().x, 0.0f), color);
+                gradient_points[3] = mgl::Vertex(bottom_panel_background.get_position() + mgl::vec2f(0.0f, 0.0f), color);
             }
 
             window.clear(get_theme().background_color);
 
-            ui_tabs.draw(window, sf::Vector2f(0.0f, search_bar->getBottomWithoutShadow()), window_size.x);
-            search_bar->draw(window, window_size, true);
+            ui_tabs.draw(window, mgl::vec2f(0.0f, search_bar->getBottomWithoutShadow()), window_size.x);
+            search_bar->draw(window, window_size.to_vec2f(), true);
 
-            file_manager_body->draw(window, body_pos, body_size - sf::Vector2f(0.0f, bottom_panel_background.getSize().y));
+            file_manager_body->draw(window, body_pos, body_size - mgl::vec2f(0.0f, bottom_panel_background.get_size().y));
 
             window.draw(bottom_panel_background);
-            window.draw(gradient_points, 4, sf::Quads);
+            window.draw(gradient_points, 4, mgl::PrimitiveType::Quads);
             window.draw(file_name_label);
             cancel_button.draw(window);
             save_button.draw(window);