diff --git a/es-app/src/CollectionSystemsManager.cpp b/es-app/src/CollectionSystemsManager.cpp
index 3d8950288..60c4846fd 100644
--- a/es-app/src/CollectionSystemsManager.cpp
+++ b/es-app/src/CollectionSystemsManager.cpp
@@ -52,11 +52,11 @@ CollectionSystemsManager::CollectionSystemsManager(Window* window)
 {
     // clang-format off
     CollectionSystemDecl systemDecls[] = {
-    //  Type                  Name                Long name       Theme folder           isCustom
-        { AUTO_ALL_GAMES,     "all",              "all games",    "auto-allgames",       false },
-        { AUTO_LAST_PLAYED,   "recent",           "last played",  "auto-lastplayed",     false },
-        { AUTO_FAVORITES,     "favorites",        "favorites",    "auto-favorites",      false },
-        { CUSTOM_COLLECTION,  myCollectionsName,  "collections",  "custom-collections",  true  }
+    //  Type                 Name               Long name      Theme folder          isCustom
+        {AUTO_ALL_GAMES,     "all",              "all games",    "auto-allgames",       false},
+        {AUTO_LAST_PLAYED,   "recent",           "last played",  "auto-lastplayed",     false},
+        {AUTO_FAVORITES,     "favorites",        "favorites",    "auto-favorites",      false},
+        {CUSTOM_COLLECTION,  myCollectionsName,  "collections",  "custom-collections",  true }
     };
     // clang-format on
 
@@ -791,7 +791,7 @@ FileData* CollectionSystemsManager::updateCollectionFolderMetadata(SystemData* s
     if (gameCount > 1) {
         std::random_device randDev;
         //  Mersenne Twister pseudorandom number generator.
-        std::mt19937 engine { randDev() };
+        std::mt19937 engine{randDev()};
         unsigned int target;
 
         for (unsigned int i = 0; i < 3; i++) {
diff --git a/es-app/src/FileData.cpp b/es-app/src/FileData.cpp
index 834cbaae3..9ca4b0a8d 100644
--- a/es-app/src/FileData.cpp
+++ b/es-app/src/FileData.cpp
@@ -212,7 +212,7 @@ const std::string FileData::getMediaDirectory()
 
 const std::string FileData::getMediafilePath(std::string subdirectory, std::string mediatype) const
 {
-    const std::vector<std::string> extList = { ".png", ".jpg" };
+    const std::vector<std::string> extList = {".png", ".jpg"};
     std::string subFolders;
 
     // Extract possible subfolders from the path.
@@ -287,7 +287,7 @@ const std::string FileData::getThumbnailPath() const
 
 const std::string FileData::getVideoPath() const
 {
-    const std::vector<std::string> extList = { ".avi", ".mkv", ".mov", ".mp4", ".wmv" };
+    const std::vector<std::string> extList = {".avi", ".mkv", ".mov", ".mp4", ".wmv"};
     std::string subFolders;
 
     // Extract possible subfolders from the path.
@@ -1158,7 +1158,7 @@ std::string FileData::findEmulatorPath(std::string& command)
         HKEY registryKey;
         LSTATUS keyStatus = -1;
         LSTATUS pathStatus = -1;
-        char registryPath[1024] {};
+        char registryPath[1024]{};
         DWORD pathSize = 1024;
 
         // First look in HKEY_CURRENT_USER.
diff --git a/es-app/src/FileFilterIndex.cpp b/es-app/src/FileFilterIndex.cpp
index 0f83b7990..7042e509b 100644
--- a/es-app/src/FileFilterIndex.cpp
+++ b/es-app/src/FileFilterIndex.cpp
@@ -37,15 +37,15 @@ FileFilterIndex::FileFilterIndex()
     // clang-format off
     FilterDataDecl filterDecls[] = {
         //type              //allKeys                //filteredBy         //filteredKeys                //primaryKey    //hasSecondaryKey   //secondaryKey  //menuLabel
-        { FAVORITES_FILTER, &mFavoritesIndexAllKeys, &mFilterByFavorites, &mFavoritesIndexFilteredKeys, "favorite",     false,              "",             "FAVORITES" },
-        { GENRE_FILTER,     &mGenreIndexAllKeys,     &mFilterByGenre,     &mGenreIndexFilteredKeys,     "genre",        true,               "genre",        "GENRE" },
-        { PLAYER_FILTER,    &mPlayersIndexAllKeys,   &mFilterByPlayers,   &mPlayersIndexFilteredKeys,   "players",      false,              "",             "PLAYERS" },
-        { PUBDEV_FILTER,    &mPubDevIndexAllKeys,    &mFilterByPubDev,    &mPubDevIndexFilteredKeys,    "developer",    true,               "publisher",    "PUBLISHER / DEVELOPER" },
-        { RATINGS_FILTER,   &mRatingsIndexAllKeys,   &mFilterByRatings,   &mRatingsIndexFilteredKeys,   "rating",       false,              "",             "RATING" },
-        { KIDGAME_FILTER,   &mKidGameIndexAllKeys,   &mFilterByKidGame,   &mKidGameIndexFilteredKeys,   "kidgame",      false,              "",             "KIDGAME" },
-        { COMPLETED_FILTER, &mCompletedIndexAllKeys, &mFilterByCompleted, &mCompletedIndexFilteredKeys, "completed",    false,              "",             "COMPLETED" },
-        { BROKEN_FILTER,    &mBrokenIndexAllKeys,    &mFilterByBroken,    &mBrokenIndexFilteredKeys,    "broken",       false,              "",             "BROKEN" },
-        { HIDDEN_FILTER,    &mHiddenIndexAllKeys,    &mFilterByHidden,    &mHiddenIndexFilteredKeys,    "hidden",       false,              "",             "HIDDEN" }
+        {FAVORITES_FILTER, &mFavoritesIndexAllKeys, &mFilterByFavorites, &mFavoritesIndexFilteredKeys, "favorite",     false,              "",             "FAVORITES"},
+        {GENRE_FILTER,     &mGenreIndexAllKeys,     &mFilterByGenre,     &mGenreIndexFilteredKeys,     "genre",        true,               "genre",        "GENRE"},
+        {PLAYER_FILTER,    &mPlayersIndexAllKeys,   &mFilterByPlayers,   &mPlayersIndexFilteredKeys,   "players",      false,              "",             "PLAYERS"},
+        {PUBDEV_FILTER,    &mPubDevIndexAllKeys,    &mFilterByPubDev,    &mPubDevIndexFilteredKeys,    "developer",    true,               "publisher",    "PUBLISHER / DEVELOPER"},
+        {RATINGS_FILTER,   &mRatingsIndexAllKeys,   &mFilterByRatings,   &mRatingsIndexFilteredKeys,   "rating",       false,              "",             "RATING"},
+        {KIDGAME_FILTER,   &mKidGameIndexAllKeys,   &mFilterByKidGame,   &mKidGameIndexFilteredKeys,   "kidgame",      false,              "",             "KIDGAME"},
+        {COMPLETED_FILTER, &mCompletedIndexAllKeys, &mFilterByCompleted, &mCompletedIndexFilteredKeys, "completed",    false,              "",             "COMPLETED"},
+        {BROKEN_FILTER,    &mBrokenIndexAllKeys,    &mFilterByBroken,    &mBrokenIndexFilteredKeys,    "broken",       false,              "",             "BROKEN"},
+        {HIDDEN_FILTER,    &mHiddenIndexAllKeys,    &mFilterByHidden,    &mHiddenIndexFilteredKeys,    "hidden",       false,              "",             "HIDDEN"}
     };
     // clang-format on
 
@@ -67,15 +67,15 @@ void FileFilterIndex::importIndex(FileFilterIndex* indexToImport)
     };
 
     IndexImportStructure indexStructDecls[] = {
-        { &mFavoritesIndexAllKeys, &(indexToImport->mFavoritesIndexAllKeys) },
-        { &mGenreIndexAllKeys, &(indexToImport->mGenreIndexAllKeys) },
-        { &mPlayersIndexAllKeys, &(indexToImport->mPlayersIndexAllKeys) },
-        { &mPubDevIndexAllKeys, &(indexToImport->mPubDevIndexAllKeys) },
-        { &mRatingsIndexAllKeys, &(indexToImport->mRatingsIndexAllKeys) },
-        { &mKidGameIndexAllKeys, &(indexToImport->mKidGameIndexAllKeys) },
-        { &mCompletedIndexAllKeys, &(indexToImport->mCompletedIndexAllKeys) },
-        { &mBrokenIndexAllKeys, &(indexToImport->mBrokenIndexAllKeys) },
-        { &mHiddenIndexAllKeys, &(indexToImport->mHiddenIndexAllKeys) },
+        {&mFavoritesIndexAllKeys, &(indexToImport->mFavoritesIndexAllKeys)},
+        {&mGenreIndexAllKeys, &(indexToImport->mGenreIndexAllKeys)},
+        {&mPlayersIndexAllKeys, &(indexToImport->mPlayersIndexAllKeys)},
+        {&mPubDevIndexAllKeys, &(indexToImport->mPubDevIndexAllKeys)},
+        {&mRatingsIndexAllKeys, &(indexToImport->mRatingsIndexAllKeys)},
+        {&mKidGameIndexAllKeys, &(indexToImport->mKidGameIndexAllKeys)},
+        {&mCompletedIndexAllKeys, &(indexToImport->mCompletedIndexAllKeys)},
+        {&mBrokenIndexAllKeys, &(indexToImport->mBrokenIndexAllKeys)},
+        {&mHiddenIndexAllKeys, &(indexToImport->mHiddenIndexAllKeys)},
     };
 
     std::vector<IndexImportStructure> indexImportDecl = std::vector<IndexImportStructure>(
@@ -304,7 +304,7 @@ void FileFilterIndex::setKidModeFilters()
 {
     if (UIModeController::getInstance()->isUIModeKid()) {
         mFilterByKidGame = true;
-        std::vector<std::string> val = { "TRUE" };
+        std::vector<std::string> val = {"TRUE"};
         setFilter(KIDGAME_FILTER, &val);
     }
 }
@@ -419,14 +419,13 @@ bool FileFilterIndex::isFiltered()
 
 bool FileFilterIndex::isKeyBeingFilteredBy(std::string key, FilterIndexType type)
 {
-    const FilterIndexType filterTypes[9] = { FAVORITES_FILTER, GENRE_FILTER,   PLAYER_FILTER,
-                                             PUBDEV_FILTER,    RATINGS_FILTER, KIDGAME_FILTER,
-                                             COMPLETED_FILTER, BROKEN_FILTER,  HIDDEN_FILTER };
+    const FilterIndexType filterTypes[9] = {FAVORITES_FILTER, GENRE_FILTER,   PLAYER_FILTER,
+                                            PUBDEV_FILTER,    RATINGS_FILTER, KIDGAME_FILTER,
+                                            COMPLETED_FILTER, BROKEN_FILTER,  HIDDEN_FILTER};
     std::vector<std::string> filterKeysList[9] = {
         mFavoritesIndexFilteredKeys, mGenreIndexFilteredKeys,   mPlayersIndexFilteredKeys,
         mPubDevIndexFilteredKeys,    mRatingsIndexFilteredKeys, mKidGameIndexFilteredKeys,
-        mCompletedIndexFilteredKeys, mBrokenIndexFilteredKeys,  mHiddenIndexFilteredKeys
-    };
+        mCompletedIndexFilteredKeys, mBrokenIndexFilteredKeys,  mHiddenIndexFilteredKeys};
 
     for (int i = 0; i < 9; i++) {
         if (filterTypes[i] == type) {
diff --git a/es-app/src/FileSorts.cpp b/es-app/src/FileSorts.cpp
index 8c84f3d78..84479b8f3 100644
--- a/es-app/src/FileSorts.cpp
+++ b/es-app/src/FileSorts.cpp
@@ -45,8 +45,7 @@ namespace FileSorts
         FileData::SortType(&compareTimesPlayedDescending, "times played, descending"),
 
         FileData::SortType(&compareSystem, "system, ascending"),
-        FileData::SortType(&compareSystemDescending, "system, descending")
-    };
+        FileData::SortType(&compareSystemDescending, "system, descending")};
 
     const std::vector<FileData::SortType> SortTypes(typesArr,
                                                     typesArr +
diff --git a/es-app/src/Gamelist.cpp b/es-app/src/Gamelist.cpp
index 31ac2b9e8..c541db582 100644
--- a/es-app/src/Gamelist.cpp
+++ b/es-app/src/Gamelist.cpp
@@ -120,8 +120,8 @@ void parseGamelist(SystemData* system)
     std::string relativeTo = system->getStartPath();
     bool showHiddenFiles = Settings::getInstance()->getBool("ShowHiddenFiles");
 
-    std::vector<std::string> tagList = { "game", "folder" };
-    FileType typeList[2] = { GAME, FOLDER };
+    std::vector<std::string> tagList = {"game", "folder"};
+    FileType typeList[2] = {GAME, FOLDER};
     for (int i = 0; i < 2; i++) {
         std::string tag = tagList[i];
         FileType type = typeList[i];
diff --git a/es-app/src/MediaViewer.cpp b/es-app/src/MediaViewer.cpp
index 82ccecdc6..f79caacf3 100644
--- a/es-app/src/MediaViewer.cpp
+++ b/es-app/src/MediaViewer.cpp
@@ -83,7 +83,7 @@ void MediaViewer::update(int deltaTime)
 
 void MediaViewer::render()
 {
-    glm::mat4 trans = Renderer::getIdentity();
+    glm::mat4 trans{Renderer::getIdentity()};
     Renderer::setMatrix(trans);
 
     // Render a black background below the game media.
@@ -95,7 +95,7 @@ void MediaViewer::render()
 
 #if defined(USE_OPENGL_21)
         Renderer::shaderParameters videoParameters;
-        unsigned int shaders = 0;
+        unsigned int shaders{0};
         if (Settings::getInstance()->getBool("MediaViewerVideoScanlines"))
             shaders = Renderer::SHADER_SCANLINES;
         if (Settings::getInstance()->getBool("MediaViewerVideoBlur")) {
@@ -121,7 +121,7 @@ void MediaViewer::render()
         Renderer::shaderPostprocessing(shaders, videoParameters);
 #endif
     }
-    else if (mImage && mImage->hasImage() && mImage->getSize() != glm::vec2({})) {
+    else if (mImage && mImage->hasImage() && mImage->getSize() != glm::vec2{}) {
         mImage->render(trans);
 
 #if defined(USE_OPENGL_21)
diff --git a/es-app/src/MiximageGenerator.cpp b/es-app/src/MiximageGenerator.cpp
index 12e2f6f4a..5f9b5bf5a 100644
--- a/es-app/src/MiximageGenerator.cpp
+++ b/es-app/src/MiximageGenerator.cpp
@@ -472,7 +472,7 @@ bool MiximageGenerator::generateImage()
     frameImageAlpha.draw_image(xPosMarquee, yPosMarquee, marqueeImageAlpha);
 
     // Set a frame color based on an average of the screenshot contents.
-    unsigned char frameColor[] = { 0, 0, 0, 0 };
+    unsigned char frameColor[] = {0, 0, 0, 0};
     sampleFrameColor(screenshotImage, frameColor);
 
     // Upper / lower frame.
diff --git a/es-app/src/SystemData.cpp b/es-app/src/SystemData.cpp
index 6f95bf97a..643cd1923 100644
--- a/es-app/src/SystemData.cpp
+++ b/es-app/src/SystemData.cpp
@@ -919,7 +919,7 @@ SystemData* SystemData::getRandomSystem(const SystemData* currentSystem)
         // Get a random number in range.
         std::random_device randDev;
         //  Mersenne Twister pseudorandom number generator.
-        std::mt19937 engine { randDev() };
+        std::mt19937 engine{randDev()};
         std::uniform_int_distribution<int> uniform_dist(0, total - 1);
         int target = uniform_dist(engine);
 
@@ -998,7 +998,7 @@ FileData* SystemData::getRandomGame(const FileData* currentGame)
         // Get a random number in range.
         std::random_device randDev;
         //  Mersenne Twister pseudorandom number generator.
-        std::mt19937 engine { randDev() };
+        std::mt19937 engine{randDev()};
         std::uniform_int_distribution<int> uniform_dist(0, total - 1);
         target = uniform_dist(engine);
     } while (currentGame && gameList.at(target) == currentGame);
diff --git a/es-app/src/SystemScreensaver.cpp b/es-app/src/SystemScreensaver.cpp
index dfdc27c4e..f27d25b5a 100644
--- a/es-app/src/SystemScreensaver.cpp
+++ b/es-app/src/SystemScreensaver.cpp
@@ -254,7 +254,7 @@ void SystemScreensaver::renderScreensaver()
 
         // Only render the video if the state requires it.
         if (static_cast<int>(mState) >= STATE_FADE_IN_VIDEO) {
-            glm::mat4 trans = Renderer::getIdentity();
+            glm::mat4 trans{Renderer::getIdentity()};
             mVideoScreensaver->render(trans);
         }
     }
@@ -268,7 +268,7 @@ void SystemScreensaver::renderScreensaver()
         if (static_cast<int>(mState) >= STATE_FADE_IN_VIDEO) {
             if (mImageScreensaver->hasImage()) {
                 mImageScreensaver->setOpacity(255 - static_cast<unsigned char>(mOpacity * 255));
-                glm::mat4 trans = Renderer::getIdentity();
+                glm::mat4 trans{Renderer::getIdentity()};
                 mImageScreensaver->render(trans);
             }
         }
@@ -514,7 +514,7 @@ void SystemScreensaver::pickRandomImage(std::string& path)
         // Get a random number in range.
         std::random_device randDev;
         //  Mersenne Twister pseudorandom number generator.
-        std::mt19937 engine { randDev() };
+        std::mt19937 engine{randDev()};
         std::uniform_int_distribution<int> uniform_dist(0,
                                                         static_cast<int>(mImageFiles.size()) - 1);
         index = uniform_dist(engine);
@@ -548,7 +548,7 @@ void SystemScreensaver::pickRandomVideo(std::string& path)
         // Get a random number in range.
         std::random_device randDev;
         //  Mersenne Twister pseudorandom number generator.
-        std::mt19937 engine { randDev() };
+        std::mt19937 engine{randDev()};
         std::uniform_int_distribution<int> uniform_dist(0,
                                                         static_cast<int>(mVideoFiles.size()) - 1);
         index = uniform_dist(engine);
@@ -576,7 +576,7 @@ void SystemScreensaver::pickRandomCustomImage(std::string& path)
         // Get a random number in range.
         std::random_device randDev;
         //  Mersenne Twister pseudorandom number generator.
-        std::mt19937 engine { randDev() };
+        std::mt19937 engine{randDev()};
         std::uniform_int_distribution<int> uniform_dist(
             0, static_cast<int>(mImageCustomFiles.size()) - 1);
         index = uniform_dist(engine);
diff --git a/es-app/src/guis/GuiCollectionSystemsOptions.cpp b/es-app/src/guis/GuiCollectionSystemsOptions.cpp
index 76b2d27de..73c77b2fa 100644
--- a/es-app/src/guis/GuiCollectionSystemsOptions.cpp
+++ b/es-app/src/guis/GuiCollectionSystemsOptions.cpp
@@ -158,7 +158,7 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(Window* window, std::st
         auto bracketThemeCollection = std::make_shared<ImageComponent>(mWindow);
         bracketThemeCollection->setImage(":/graphics/arrow.svg");
         bracketThemeCollection->setResize(
-            glm::vec2(0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
+            glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
         row.addElement(themeCollection, true);
         row.addElement(bracketThemeCollection, false);
         row.makeAcceptInputHandler([this, unusedFolders] {
@@ -196,7 +196,7 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(Window* window, std::st
     auto bracketNewCollection = std::make_shared<ImageComponent>(mWindow);
     bracketNewCollection->setImage(":/graphics/arrow.svg");
     bracketNewCollection->setResize(
-        glm::vec2(0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
+        glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
     row.addElement(newCollection, true);
     row.addElement(bracketNewCollection, false);
     auto createCollectionCall = [this](const std::string& newVal) {
@@ -221,7 +221,7 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(Window* window, std::st
     auto bracketDeleteCollection = std::make_shared<ImageComponent>(mWindow);
     bracketDeleteCollection->setImage(":/graphics/arrow.svg");
     bracketDeleteCollection->setResize(
-        glm::vec2(0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
+        glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
     row.addElement(deleteCollection, true);
     row.addElement(bracketDeleteCollection, false);
     row.makeAcceptInputHandler([this, customSystems] {
diff --git a/es-app/src/guis/GuiGameScraper.cpp b/es-app/src/guis/GuiGameScraper.cpp
index 38d5594f4..b50676029 100644
--- a/es-app/src/guis/GuiGameScraper.cpp
+++ b/es-app/src/guis/GuiGameScraper.cpp
@@ -22,7 +22,7 @@ GuiGameScraper::GuiGameScraper(Window* window,
                                ScraperSearchParams params,
                                std::function<void(const ScraperSearchResult&)> doneFunc)
     : GuiComponent(window)
-    , mGrid(window, Vector2i(1, 7))
+    , mGrid(window, glm::ivec2{1, 7})
     , mBox(window, ":/graphics/frame.svg")
     , mSearchParams(params)
     , mClose(false)
@@ -52,20 +52,20 @@ GuiGameScraper::GuiGameScraper(Window* window,
         scrapeName +
             ((mSearchParams.game->getType() == FOLDER) ? "  " + ViewController::FOLDER_CHAR : ""),
         Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_CENTER);
-    mGrid.setEntry(mGameName, Vector2i(0, 1), false, true);
+    mGrid.setEntry(mGameName, glm::ivec2{0, 1}, false, true);
 
     // Row 2 is a spacer.
 
     mSystemName = std::make_shared<TextComponent>(
         mWindow, Utils::String::toUpper(mSearchParams.system->getFullName()),
         Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
-    mGrid.setEntry(mSystemName, Vector2i(0, 3), false, true);
+    mGrid.setEntry(mSystemName, glm::ivec2{0, 3}, false, true);
 
     // Row 4 is a spacer.
 
     // GuiScraperSearch.
     mSearch = std::make_shared<GuiScraperSearch>(window, GuiScraperSearch::NEVER_AUTO_ACCEPT, 1);
-    mGrid.setEntry(mSearch, Vector2i(0, 5), true);
+    mGrid.setEntry(mSearch, glm::ivec2{0, 5}, true);
 
     // Buttons
     std::vector<std::shared_ptr<ButtonComponent>> buttons;
@@ -92,7 +92,7 @@ GuiGameScraper::GuiGameScraper(Window* window,
     }));
     mButtonGrid = makeButtonGrid(mWindow, buttons);
 
-    mGrid.setEntry(mButtonGrid, Vector2i(0, 6), true, false);
+    mGrid.setEntry(mButtonGrid, glm::ivec2{0, 6}, true, false);
 
     mSearch->setAcceptCallback([this, doneFunc](const ScraperSearchResult& result) {
         doneFunc(result);
@@ -115,7 +115,7 @@ GuiGameScraper::GuiGameScraper(Window* window,
 
 void GuiGameScraper::onSizeChanged()
 {
-    mBox.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBox.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     mGrid.setRowHeightPerc(0, 0.04f, false);
     mGrid.setRowHeightPerc(1, mGameName->getFont()->getLetterHeight() / mSize.y, false);
diff --git a/es-app/src/guis/GuiGamelistFilter.cpp b/es-app/src/guis/GuiGamelistFilter.cpp
index a6d19091f..61a7361c2 100644
--- a/es-app/src/guis/GuiGamelistFilter.cpp
+++ b/es-app/src/guis/GuiGamelistFilter.cpp
@@ -106,7 +106,7 @@ void GuiGamelistFilter::addFiltersToMenu()
 
         auto bracket = std::make_shared<ImageComponent>(mWindow);
         bracket->setImage(":/graphics/arrow.svg");
-        bracket->setResize(glm::vec2(0.0f, lbl->getFont()->getLetterHeight()));
+        bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
         row.addElement(bracket, false);
 
         mTextFilterField->setValue(mFilterIndex->getTextFilter());
diff --git a/es-app/src/guis/GuiInfoPopup.cpp b/es-app/src/guis/GuiInfoPopup.cpp
index 0137d4ff4..2491c7e49 100644
--- a/es-app/src/guis/GuiInfoPopup.cpp
+++ b/es-app/src/guis/GuiInfoPopup.cpp
@@ -54,15 +54,15 @@ GuiInfoPopup::GuiInfoPopup(Window* window, std::string message, int duration)
     setPosition(posX, posY, 0);
 
     mFrame->setImagePath(":/graphics/frame.svg");
-    mFrame->fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mFrame->fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
     addChild(mFrame);
 
     // We only initialize the actual time when we first start to render.
     mStartTime = 0;
 
-    mGrid = new ComponentGrid(window, Vector2i(1, 3));
+    mGrid = new ComponentGrid(window, glm::ivec2{1, 3});
     mGrid->setSize(mSize);
-    mGrid->setEntry(s, Vector2i(0, 1), false, true);
+    mGrid->setEntry(s, glm::ivec2{0, 1}, false, true);
     addChild(mGrid);
 }
 
@@ -75,7 +75,7 @@ GuiInfoPopup::~GuiInfoPopup()
 void GuiInfoPopup::render(const glm::mat4& /*parentTrans*/)
 {
     // We use getIdentity() as we want to render on a specific window position, not on the view.
-    glm::mat4 trans = getTransform() * Renderer::getIdentity();
+    glm::mat4 trans{getTransform() * Renderer::getIdentity()};
     if (mRunning && updateState()) {
         // If we're still supposed to be rendering it.
         Renderer::setMatrix(trans);
diff --git a/es-app/src/guis/GuiLaunchScreen.cpp b/es-app/src/guis/GuiLaunchScreen.cpp
index 590ee78d0..3ec4434ba 100644
--- a/es-app/src/guis/GuiLaunchScreen.cpp
+++ b/es-app/src/guis/GuiLaunchScreen.cpp
@@ -34,7 +34,7 @@ GuiLaunchScreen::~GuiLaunchScreen()
 
 void GuiLaunchScreen::displayLaunchScreen(FileData* game)
 {
-    mGrid = new ComponentGrid(mWindow, Vector2i(3, 8));
+    mGrid = new ComponentGrid(mWindow, glm::ivec2{3, 8});
     addChild(mGrid);
 
     mImagePath = game->getMarqueePath();
@@ -51,8 +51,8 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
     const float gameNameFontSize = 0.073f;
 
     // Spacer row.
-    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0), false, false,
-                    Vector2i(1, 1));
+    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 0}, false, false,
+                    glm::ivec2{1, 1});
 
     // Title.
     mTitle = std::make_shared<TextComponent>(
@@ -60,19 +60,19 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
         Font::get(static_cast<int>(
             titleFontSize * std::min(Renderer::getScreenHeight(), Renderer::getScreenWidth()))),
         0x666666FF, ALIGN_CENTER);
-    mGrid->setEntry(mTitle, Vector2i(1, 1), false, true, Vector2i(1, 1));
+    mGrid->setEntry(mTitle, glm::ivec2{1, 1}, false, true, glm::ivec2{1, 1});
 
     // Spacer row.
-    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 2), false, false,
-                    Vector2i(1, 1));
+    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 2}, false, false,
+                    glm::ivec2{1, 1});
 
     // Row for the marquee.
-    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 3), false, false,
-                    Vector2i(1, 1));
+    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 3}, false, false,
+                    glm::ivec2{1, 1});
 
     // Spacer row.
-    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 4), false, false,
-                    Vector2i(1, 1));
+    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 4}, false, false,
+                    glm::ivec2{1, 1});
 
     // Game name.
     mGameName = std::make_shared<TextComponent>(
@@ -80,24 +80,24 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
         Font::get(static_cast<int>(
             gameNameFontSize * std::min(Renderer::getScreenHeight(), Renderer::getScreenWidth()))),
         0x444444FF, ALIGN_CENTER);
-    mGrid->setEntry(mGameName, Vector2i(1, 5), false, true, Vector2i(1, 1));
+    mGrid->setEntry(mGameName, glm::ivec2{1, 5}, false, true, glm::ivec2{1, 1});
 
     // System name.
     mSystemName = std::make_shared<TextComponent>(
         mWindow, "SYSTEM NAME", Font::get(FONT_SIZE_MEDIUM), 0x666666FF, ALIGN_CENTER);
-    mGrid->setEntry(mSystemName, Vector2i(1, 6), false, true, Vector2i(1, 1));
+    mGrid->setEntry(mSystemName, glm::ivec2{1, 6}, false, true, glm::ivec2{1, 1});
 
     // Spacer row.
-    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 7), false, false,
-                    Vector2i(1, 1));
+    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 7}, false, false,
+                    glm::ivec2{1, 1});
 
     // Left spacer.
-    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false, false,
-                    Vector2i(1, 8));
+    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 0}, false, false,
+                    glm::ivec2{1, 8});
 
     // Right spacer.
-    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(2, 0), false, false,
-                    Vector2i(1, 8));
+    mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{2, 0}, false, false,
+                    glm::ivec2{1, 8});
 
     // Adjust the width depending on the aspect ratio of the screen, to make the screen look
     // somewhat coherent regardless of screen type. The 1.778 aspect ratio value is the 16:9
@@ -169,8 +169,8 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
                                          mGrid->getRowHeight(3));
 
         mMarquee->setOrigin(0.5f, 0.5f);
-        glm::vec3 currentPos = mMarquee->getPosition();
-        glm::vec2 currentSize = mMarquee->getSize();
+        glm::vec3 currentPos{mMarquee->getPosition()};
+        glm::vec2 currentSize{mMarquee->getSize()};
 
         // Position the image in the middle of row four.
         currentPos.x = mSize.x / 2.0f;
@@ -179,13 +179,13 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
         mMarquee->setPosition(currentPos);
     }
 
-    setOrigin({ 0.5f, 0.5f });
+    setOrigin({0.5f, 0.5f});
 
     // Center on the X axis and keep slightly off-center on the Y axis.
     setPosition(static_cast<float>(Renderer::getScreenWidth()) / 2.0f,
                 static_cast<float>(Renderer::getScreenHeight()) / 2.25f);
 
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
     mBackground.setEdgeColor(0xEEEEEEFF);
 }
 
@@ -228,7 +228,7 @@ void GuiLaunchScreen::render()
     if (mScaleUp < 1.0f)
         setScale(mScaleUp);
 
-    glm::mat4 trans = Renderer::getIdentity() * getTransform();
+    glm::mat4 trans{Renderer::getIdentity() * getTransform()};
     Renderer::setMatrix(trans);
 
     GuiComponent::renderChildren(trans);
diff --git a/es-app/src/guis/GuiMenu.cpp b/es-app/src/guis/GuiMenu.cpp
index a7ff2208a..0451b0d80 100644
--- a/es-app/src/guis/GuiMenu.cpp
+++ b/es-app/src/guis/GuiMenu.cpp
@@ -898,7 +898,7 @@ void GuiMenu::openOtherOptions()
     auto bracketMediaDirectory = std::make_shared<ImageComponent>(mWindow);
     bracketMediaDirectory->setImage(":/graphics/arrow.svg");
     bracketMediaDirectory->setResize(
-        glm::vec2(0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
+        glm::vec2{0.0f, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()});
     rowMediaDir.addElement(media_directory, true);
     rowMediaDir.addElement(bracketMediaDirectory, false);
     std::string titleMediaDir = "ENTER GAME MEDIA DIRECTORY";
diff --git a/es-app/src/guis/GuiMetaDataEd.cpp b/es-app/src/guis/GuiMetaDataEd.cpp
index fbb7506e1..31cabc75b 100644
--- a/es-app/src/guis/GuiMetaDataEd.cpp
+++ b/es-app/src/guis/GuiMetaDataEd.cpp
@@ -42,7 +42,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
     : GuiComponent(window)
     , mScraperParams(scraperParams)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(1, 3))
+    , mGrid(window, glm::ivec2{1, 3})
     , mMetaDataDecl(mdd)
     , mMetaData(md)
     , mSavedCallback(saveCallback)
@@ -53,7 +53,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
     addChild(&mBackground);
     addChild(&mGrid);
 
-    mHeaderGrid = std::make_shared<ComponentGrid>(mWindow, Vector2i(1, 5));
+    mHeaderGrid = std::make_shared<ComponentGrid>(mWindow, glm::ivec2{1, 5});
 
     mTitle = std::make_shared<TextComponent>(mWindow, "EDIT METADATA", Font::get(FONT_SIZE_LARGE),
                                              0x555555FF, ALIGN_CENTER);
@@ -78,15 +78,15 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
         folderPath + Utils::FileSystem::getFileName(scraperParams.game->getPath()) + " [" +
             Utils::String::toUpper(scraperParams.system->getName()) + "]" +
             (scraperParams.game->getType() == FOLDER ? "  " + ViewController::FOLDER_CHAR : ""),
-        Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_CENTER, glm::vec3({}), glm::vec2({}),
-        0x00000000, 0.05f);
-    mHeaderGrid->setEntry(mTitle, Vector2i(0, 1), false, true);
-    mHeaderGrid->setEntry(mSubtitle, Vector2i(0, 3), false, true);
+        Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_CENTER, glm::vec3{}, glm::vec2{}, 0x00000000,
+        0.05f);
+    mHeaderGrid->setEntry(mTitle, glm::ivec2{0, 1}, false, true);
+    mHeaderGrid->setEntry(mSubtitle, glm::ivec2{0, 3}, false, true);
 
-    mGrid.setEntry(mHeaderGrid, Vector2i(0, 0), false, true);
+    mGrid.setEntry(mHeaderGrid, glm::ivec2{0, 0}, false, true);
 
     mList = std::make_shared<ComponentList>(mWindow);
-    mGrid.setEntry(mList, Vector2i(0, 1), true, true);
+    mGrid.setEntry(mList, glm::ivec2{0, 1}, true, true);
 
     // Populate list.
     for (auto iter = mdd.cbegin(); iter != mdd.cend(); iter++) {
@@ -123,7 +123,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
             case MD_BOOL: {
                 ed = std::make_shared<SwitchComponent>(window);
                 // Make the switches slightly smaller.
-                glm::vec2 switchSize = ed->getSize() * 0.9f;
+                glm::vec2 switchSize{ed->getSize() * 0.9f};
                 ed->setResize(switchSize.x, switchSize.y);
                 ed->setOrigin(-0.05f, -0.09f);
 
@@ -182,7 +182,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
 
                 auto bracket = std::make_shared<ImageComponent>(mWindow);
                 bracket->setImage(":/graphics/arrow.svg");
-                bracket->setResize(glm::vec2(0.0f, lbl->getFont()->getLetterHeight()));
+                bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
                 row.addElement(bracket, false);
 
                 bool multiLine = false;
@@ -223,7 +223,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
 
                 auto bracket = std::make_shared<ImageComponent>(mWindow);
                 bracket->setImage(":/graphics/arrow.svg");
-                bracket->setResize(glm::vec2(0.0f, lbl->getFont()->getLetterHeight()));
+                bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
                 row.addElement(bracket, false);
 
                 bool multiLine = iter->type == MD_MULTILINE_STRING;
@@ -346,7 +346,7 @@ GuiMetaDataEd::GuiMetaDataEd(Window* window,
     }
 
     mButtons = makeButtonGrid(mWindow, buttons);
-    mGrid.setEntry(mButtons, Vector2i(0, 2), true, false);
+    mGrid.setEntry(mButtons, glm::ivec2{0, 2}, true, false);
 
     // Resize + center.
     float width =
@@ -386,12 +386,12 @@ void GuiMetaDataEd::onSizeChanged()
     // Adjust the size of the list and window.
     float heightAdjustment = listSize - listHeight;
     mList->setSize(mList->getSize().x, listHeight);
-    glm::vec2 newWindowSize = mSize;
+    glm::vec2 newWindowSize{mSize};
     newWindowSize.y -= heightAdjustment;
-    mBackground.fitTo(newWindowSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(newWindowSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     // Move the buttons up as well to make the layout align correctly after the resize.
-    glm::vec3 newButtonPos = mButtons->getPosition();
+    glm::vec3 newButtonPos{mButtons->getPosition()};
     newButtonPos.y -= heightAdjustment;
     mButtons->setPosition(newButtonPos);
 
diff --git a/es-app/src/guis/GuiOfflineGenerator.cpp b/es-app/src/guis/GuiOfflineGenerator.cpp
index 16c8bc85c..4bd6f84b8 100644
--- a/es-app/src/guis/GuiOfflineGenerator.cpp
+++ b/es-app/src/guis/GuiOfflineGenerator.cpp
@@ -16,7 +16,7 @@
 GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileData*>& gameQueue)
     : GuiComponent(window)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(6, 13))
+    , mGrid(window, glm::ivec2{6, 13})
     , mGameQueue(gameQueue)
 {
     addChild(&mBackground);
@@ -38,100 +38,100 @@ GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileDa
     // Header.
     mTitle = std::make_shared<TextComponent>(mWindow, "MIXIMAGE OFFLINE GENERATOR",
                                              Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
-    mGrid.setEntry(mTitle, Vector2i(0, 0), false, true, Vector2i(6, 1));
+    mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true, glm::ivec2{6, 1});
 
     mStatus = std::make_shared<TextComponent>(mWindow, "NOT STARTED", Font::get(FONT_SIZE_MEDIUM),
                                               0x777777FF, ALIGN_CENTER);
-    mGrid.setEntry(mStatus, Vector2i(0, 1), false, true, Vector2i(6, 1));
+    mGrid.setEntry(mStatus, glm::ivec2{0, 1}, false, true, glm::ivec2{6, 1});
 
     mGameCounter = std::make_shared<TextComponent>(
         mWindow,
         std::to_string(mGamesProcessed) + " OF " + std::to_string(mTotalGames) +
             (mTotalGames == 1 ? " GAME " : " GAMES ") + "PROCESSED",
         Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
-    mGrid.setEntry(mGameCounter, Vector2i(0, 2), false, true, Vector2i(6, 1));
+    mGrid.setEntry(mGameCounter, glm::ivec2{0, 2}, false, true, glm::ivec2{6, 1});
 
     // Spacer row with top border.
-    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 3), false, false,
-                   Vector2i(6, 1), GridFlags::BORDER_TOP);
+    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 3}, false, false,
+                   glm::ivec2{6, 1}, GridFlags::BORDER_TOP);
 
     // Left spacer.
-    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 4), false, false,
-                   Vector2i(1, 7));
+    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 4}, false, false,
+                   glm::ivec2{1, 7});
 
     // Generated label.
     mGeneratedLbl = std::make_shared<TextComponent>(
         mWindow, "Generated:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mGeneratedLbl, Vector2i(1, 4), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mGeneratedLbl, glm::ivec2{1, 4}, false, true, glm::ivec2{1, 1});
 
     // Generated value/counter.
     mGeneratedVal =
         std::make_shared<TextComponent>(mWindow, std::to_string(mGamesProcessed),
                                         Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mGeneratedVal, Vector2i(2, 4), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mGeneratedVal, glm::ivec2{2, 4}, false, true, glm::ivec2{1, 1});
 
     // Overwritten label.
     mOverwrittenLbl = std::make_shared<TextComponent>(
         mWindow, "Overwritten:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mOverwrittenLbl, Vector2i(1, 5), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mOverwrittenLbl, glm::ivec2{1, 5}, false, true, glm::ivec2{1, 1});
 
     // Overwritten value/counter.
     mOverwrittenVal =
         std::make_shared<TextComponent>(mWindow, std::to_string(mImagesOverwritten),
                                         Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mOverwrittenVal, Vector2i(2, 5), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mOverwrittenVal, glm::ivec2{2, 5}, false, true, glm::ivec2{1, 1});
 
     // Skipping label.
     mSkippedLbl = std::make_shared<TextComponent>(
         mWindow, "Skipped (existing):", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mSkippedLbl, Vector2i(1, 6), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mSkippedLbl, glm::ivec2{1, 6}, false, true, glm::ivec2{1, 1});
 
     // Skipping value/counter.
     mSkippedVal = std::make_shared<TextComponent>(
         mWindow, std::to_string(mGamesSkipped), Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mSkippedVal, Vector2i(2, 6), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mSkippedVal, glm::ivec2{2, 6}, false, true, glm::ivec2{1, 1});
 
     // Failed label.
     mFailedLbl = std::make_shared<TextComponent>(mWindow, "Failed:", Font::get(FONT_SIZE_SMALL),
                                                  0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mFailedLbl, Vector2i(1, 7), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mFailedLbl, glm::ivec2{1, 7}, false, true, glm::ivec2{1, 1});
 
     // Failed value/counter.
     mFailedVal = std::make_shared<TextComponent>(
         mWindow, std::to_string(mGamesFailed), Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mFailedVal, Vector2i(2, 7), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mFailedVal, glm::ivec2{2, 7}, false, true, glm::ivec2{1, 1});
 
     // Processing label.
     mProcessingLbl = std::make_shared<TextComponent>(
         mWindow, "Processing: ", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mProcessingLbl, Vector2i(3, 4), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mProcessingLbl, glm::ivec2{3, 4}, false, true, glm::ivec2{1, 1});
 
     // Processing value.
     mProcessingVal = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_SMALL),
                                                      0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mProcessingVal, Vector2i(4, 4), false, true, Vector2i(1, 1));
+    mGrid.setEntry(mProcessingVal, glm::ivec2{4, 4}, false, true, glm::ivec2{1, 1});
 
     // Spacer row.
-    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 8), false, false,
-                   Vector2i(4, 1));
+    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 8}, false, false,
+                   glm::ivec2{4, 1});
 
     // Last error message label.
     mLastErrorLbl = std::make_shared<TextComponent>(
         mWindow, "Last error message:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mLastErrorLbl, Vector2i(1, 9), false, true, Vector2i(4, 1));
+    mGrid.setEntry(mLastErrorLbl, glm::ivec2{1, 9}, false, true, glm::ivec2{4, 1});
 
     // Last error message value.
     mLastErrorVal = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_SMALL),
                                                     0x888888FF, ALIGN_LEFT);
-    mGrid.setEntry(mLastErrorVal, Vector2i(1, 10), false, true, Vector2i(4, 1));
+    mGrid.setEntry(mLastErrorVal, glm::ivec2{1, 10}, false, true, glm::ivec2{4, 1});
 
     // Right spacer.
-    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(5, 4), false, false,
-                   Vector2i(1, 7));
+    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{5, 4}, false, false,
+                   glm::ivec2{1, 7});
 
     // Spacer row with bottom border.
-    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 11), false, false,
-                   Vector2i(6, 1), GridFlags::BORDER_BOTTOM);
+    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 11}, false, false,
+                   glm::ivec2{6, 1}, GridFlags::BORDER_BOTTOM);
 
     // Buttons.
     std::vector<std::shared_ptr<ButtonComponent>> buttons;
@@ -177,7 +177,7 @@ GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileDa
     buttons.push_back(mCloseButton);
     mButtonGrid = makeButtonGrid(mWindow, buttons);
 
-    mGrid.setEntry(mButtonGrid, Vector2i(0, 12), true, false, Vector2i(6, 1));
+    mGrid.setEntry(mButtonGrid, glm::ivec2{0, 12}, true, false, glm::ivec2{6, 1});
 
     // For narrower displays (e.g. in 4:3 ratio), allow the window to fill 95% of the screen
     // width rather than the 85% allowed for wider displays.
@@ -203,7 +203,7 @@ GuiOfflineGenerator::~GuiOfflineGenerator()
 
 void GuiOfflineGenerator::onSizeChanged()
 {
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     // Set row heights.
     mGrid.setRowHeightPerc(0, mTitle->getFont()->getLetterHeight() * 1.9725f / mSize.y, false);
diff --git a/es-app/src/guis/GuiScraperMulti.cpp b/es-app/src/guis/GuiScraperMulti.cpp
index 70233e14e..7206d5492 100644
--- a/es-app/src/guis/GuiScraperMulti.cpp
+++ b/es-app/src/guis/GuiScraperMulti.cpp
@@ -28,7 +28,7 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
                                  bool approveResults)
     : GuiComponent(window)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(1, 5))
+    , mGrid(window, glm::ivec2{1, 5})
     , mSearchQueue(searches)
     , mApproveResults(approveResults)
 {
@@ -47,15 +47,15 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
     // Set up grid.
     mTitle = std::make_shared<TextComponent>(mWindow, "SCRAPING IN PROGRESS",
                                              Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
-    mGrid.setEntry(mTitle, Vector2i(0, 0), false, true);
+    mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true);
 
     mSystem = std::make_shared<TextComponent>(mWindow, "SYSTEM", Font::get(FONT_SIZE_MEDIUM),
                                               0x777777FF, ALIGN_CENTER);
-    mGrid.setEntry(mSystem, Vector2i(0, 1), false, true);
+    mGrid.setEntry(mSystem, glm::ivec2{0, 1}, false, true);
 
     mSubtitle = std::make_shared<TextComponent>(
         mWindow, "subtitle text", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
-    mGrid.setEntry(mSubtitle, Vector2i(0, 2), false, true);
+    mGrid.setEntry(mSubtitle, glm::ivec2{0, 2}, false, true);
 
     if (mApproveResults && !Settings::getInstance()->getBool("ScraperSemiautomatic"))
         mSearchComp = std::make_shared<GuiScraperSearch>(
@@ -70,7 +70,7 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
         std::bind(&GuiScraperMulti::acceptResult, this, std::placeholders::_1));
     mSearchComp->setSkipCallback(std::bind(&GuiScraperMulti::skip, this));
     mSearchComp->setCancelCallback(std::bind(&GuiScraperMulti::finish, this));
-    mGrid.setEntry(mSearchComp, Vector2i(0, 3),
+    mGrid.setEntry(mSearchComp, glm::ivec2{0, 3},
                    mSearchComp->getSearchType() != GuiScraperSearch::ALWAYS_ACCEPT_FIRST_RESULT,
                    true);
 
@@ -102,7 +102,7 @@ GuiScraperMulti::GuiScraperMulti(Window* window,
                                                         std::bind(&GuiScraperMulti::finish, this)));
 
     mButtonGrid = makeButtonGrid(mWindow, buttons);
-    mGrid.setEntry(mButtonGrid, Vector2i(0, 4), true, false);
+    mGrid.setEntry(mButtonGrid, glm::ivec2{0, 4}, true, false);
 
     // Limit the width of the GUI on ultrawide monitors. The 1.778 aspect ratio value is
     // the 16:9 reference.
@@ -130,7 +130,7 @@ GuiScraperMulti::~GuiScraperMulti()
 
 void GuiScraperMulti::onSizeChanged()
 {
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     mGrid.setRowHeightPerc(0, mTitle->getFont()->getLetterHeight() * 1.9725f / mSize.y, false);
     mGrid.setRowHeightPerc(1, (mSystem->getFont()->getLetterHeight() + 2.0f) / mSize.y, false);
diff --git a/es-app/src/guis/GuiScraperSearch.cpp b/es-app/src/guis/GuiScraperSearch.cpp
index 262bff12b..e12edd803 100644
--- a/es-app/src/guis/GuiScraperSearch.cpp
+++ b/es-app/src/guis/GuiScraperSearch.cpp
@@ -38,7 +38,7 @@
 
 GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int scrapeCount)
     : GuiComponent(window)
-    , mGrid(window, Vector2i(4, 3))
+    , mGrid(window, glm::ivec2{4, 3})
     , mBusyAnim(window)
     , mSearchType(type)
     , mScrapeCount(scrapeCount)
@@ -54,8 +54,8 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
     mRetryCount = 0;
 
     // Left spacer (empty component, needed for borders).
-    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false, false,
-                   Vector2i(1, 3), GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
+    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 0}, false, false,
+                   glm::ivec2{1, 3}, GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
 
     // Selected result name.
     mResultName = std::make_shared<TextComponent>(mWindow, "Result name",
@@ -63,7 +63,7 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
 
     // Selected result thumbnail.
     mResultThumbnail = std::make_shared<ImageComponent>(mWindow);
-    mGrid.setEntry(mResultThumbnail, Vector2i(1, 1), false, false, Vector2i(1, 1));
+    mGrid.setEntry(mResultThumbnail, glm::ivec2{1, 1}, false, false, glm::ivec2{1, 1});
 
     // Selected result description and container.
     mDescContainer = std::make_shared<ScrollableContainer>(mWindow);
@@ -87,14 +87,14 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
     mMD_ReleaseDate = std::make_shared<DateTimeEditComponent>(mWindow);
     mMD_ReleaseDate->setColor(mdColor);
     mMD_ReleaseDate->setUppercase(true);
-    mMD_Developer = std::make_shared<TextComponent>(
-        mWindow, "", font, mdColor, ALIGN_LEFT, glm::vec3({}), glm::vec2({}), 0x00000000, 0.02f);
-    mMD_Publisher = std::make_shared<TextComponent>(
-        mWindow, "", font, mdColor, ALIGN_LEFT, glm::vec3({}), glm::vec2({}), 0x00000000, 0.02f);
-    mMD_Genre = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
-                                                glm::vec3({}), glm::vec2({}), 0x00000000, 0.02f);
+    mMD_Developer = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
+                                                    glm::vec3{}, glm::vec2{}, 0x00000000, 0.02f);
+    mMD_Publisher = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
+                                                    glm::vec3{}, glm::vec2{}, 0x00000000, 0.02f);
+    mMD_Genre = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, glm::vec3{},
+                                                glm::vec2{}, 0x00000000, 0.02f);
     mMD_Players = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
-                                                  glm::vec3({}), glm::vec2({}), 0x00000000, 0.02f);
+                                                  glm::vec3{}, glm::vec2{}, 0x00000000, 0.02f);
     mMD_Filler = std::make_shared<TextComponent>(mWindow, "", font, mdColor);
 
     if (Settings::getInstance()->getString("Scraper") != "thegamesdb")
@@ -123,15 +123,15 @@ GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int
             std::make_shared<TextComponent>(mWindow, "", font, mdLblColor), mMD_Filler));
 
     mMD_Grid = std::make_shared<ComponentGrid>(
-        mWindow, Vector2i(2, static_cast<int>(mMD_Pairs.size() * 2 - 1)));
+        mWindow, glm::ivec2{2, static_cast<int>(mMD_Pairs.size() * 2 - 1)});
     unsigned int i = 0;
     for (auto it = mMD_Pairs.cbegin(); it != mMD_Pairs.cend(); it++) {
-        mMD_Grid->setEntry(it->first, Vector2i(0, i), false, true);
-        mMD_Grid->setEntry(it->second, Vector2i(1, i), false, it->resize);
+        mMD_Grid->setEntry(it->first, glm::ivec2{0, i}, false, true);
+        mMD_Grid->setEntry(it->second, glm::ivec2{1, i}, false, it->resize);
         i += 2;
     }
 
-    mGrid.setEntry(mMD_Grid, Vector2i(2, 1), false, false);
+    mGrid.setEntry(mMD_Grid, glm::ivec2{2, 1}, false, false);
 
     // Result list.
     mResultList = std::make_shared<ComponentList>(mWindow);
@@ -229,7 +229,7 @@ void GuiScraperSearch::onSizeChanged()
     mResultDesc->setSize(mDescContainer->getSize().x, 0.0f);
 
     // Set the width of mResultName to the cell width so that text abbreviation will work correctly.
-    glm::vec2 resultNameSize = mResultName->getSize();
+    glm::vec2 resultNameSize{mResultName->getSize()};
     mResultName->setSize(mGrid.getColWidth(3), resultNameSize.y);
 
     mGrid.onSizeChanged();
@@ -288,30 +288,30 @@ void GuiScraperSearch::updateViewStyle()
     // Add them back depending on search type.
     if (mSearchType == ALWAYS_ACCEPT_FIRST_RESULT) {
         // Show name.
-        mGrid.setEntry(mResultName, Vector2i(1, 0), false, false, Vector2i(2, 1),
+        mGrid.setEntry(mResultName, glm::ivec2{1, 0}, false, false, glm::ivec2{2, 1},
                        GridFlags::BORDER_TOP);
 
         // Need a border on the bottom left.
-        mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 2), false, false,
-                       Vector2i(3, 1), GridFlags::BORDER_BOTTOM);
+        mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 2}, false, false,
+                       glm::ivec2{3, 1}, GridFlags::BORDER_BOTTOM);
 
         // Show description on the right.
-        mGrid.setEntry(mDescContainer, Vector2i(3, 0), false, false, Vector2i(1, 3),
+        mGrid.setEntry(mDescContainer, glm::ivec2{3, 0}, false, false, glm::ivec2{1, 3},
                        GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
         // Make description text wrap at edge of container.
         mResultDesc->setSize(mDescContainer->getSize().x, 0.0f);
     }
     else {
         // Fake row where name would be.
-        mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0), false, true,
-                       Vector2i(2, 1), GridFlags::BORDER_TOP);
+        mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{1, 0}, false, true,
+                       glm::ivec2{2, 1}, GridFlags::BORDER_TOP);
 
         // Show result list on the right.
-        mGrid.setEntry(mResultList, Vector2i(3, 0), true, true, Vector2i(1, 3),
+        mGrid.setEntry(mResultList, glm::ivec2{3, 0}, true, true, glm::ivec2{1, 3},
                        GridFlags::BORDER_LEFT | GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
 
         // Show description under image/info.
-        mGrid.setEntry(mDescContainer, Vector2i(1, 2), false, false, Vector2i(2, 1),
+        mGrid.setEntry(mDescContainer, glm::ivec2{1, 2}, false, false, glm::ivec2{2, 1},
                        GridFlags::BORDER_BOTTOM);
         // Make description text wrap at edge of container.
         mResultDesc->setSize(mDescContainer->getSize().x, 0);
@@ -562,7 +562,7 @@ bool GuiScraperSearch::input(InputConfig* config, Input input)
 
 void GuiScraperSearch::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     renderChildren(trans);
     Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0x00000009, 0x00000009);
diff --git a/es-app/src/guis/GuiSettings.cpp b/es-app/src/guis/GuiSettings.cpp
index 87e000e27..b5827febb 100644
--- a/es-app/src/guis/GuiSettings.cpp
+++ b/es-app/src/guis/GuiSettings.cpp
@@ -170,7 +170,7 @@ void GuiSettings::addEditableTextComponent(const std::string label,
 
     auto bracket = std::make_shared<ImageComponent>(mWindow);
     bracket->setImage(":/graphics/arrow.svg");
-    bracket->setResize(glm::vec2(0.0f, lbl->getFont()->getLetterHeight()));
+    bracket->setResize(glm::vec2{0.0f, lbl->getFont()->getLetterHeight()});
     row.addElement(bracket, false);
 
     // OK callback (apply new value to ed).
diff --git a/es-app/src/main.cpp b/es-app/src/main.cpp
index fe243b8ae..97a0fa7ad 100644
--- a/es-app/src/main.cpp
+++ b/es-app/src/main.cpp
@@ -572,7 +572,7 @@ int main(int argc, char* argv[])
 
     bool splashScreen = Settings::getInstance()->getBool("SplashScreen");
     bool splashScreenProgress = Settings::getInstance()->getBool("SplashScreenProgress");
-    SDL_Event event {};
+    SDL_Event event{};
 
     if (!window.init()) {
         LOG(LogError) << "Window failed to initialize";
diff --git a/es-app/src/scrapers/GamesDBJSONScraper.cpp b/es-app/src/scrapers/GamesDBJSONScraper.cpp
index 7ca45b709..e92138254 100644
--- a/es-app/src/scrapers/GamesDBJSONScraper.cpp
+++ b/es-app/src/scrapers/GamesDBJSONScraper.cpp
@@ -33,90 +33,90 @@ namespace
     TheGamesDBJSONRequestResources resources;
 }
 
-const std::map<PlatformId, std::string> gamesdb_new_platformid_map {
-    { THREEDO, "25" },
-    { COMMODORE_AMIGA, "4911" },
-    { COMMODORE_AMIGA_CD32, "4947" },
-    { AMSTRAD_CPC, "4914" },
-    { APPLE_II, "4942" },
-    { ARCADE, "23" },
-    { ATARI_800, "4943" },
-    { ATARI_2600, "22" },
-    { ATARI_5200, "26" },
-    { ATARI_7800, "27" },
-    { ATARI_JAGUAR, "28" },
-    { ATARI_JAGUAR_CD, "29" },
-    { ATARI_LYNX, "4924" },
-    { ATARI_ST, "4937" },
-    { ATARI_XE, "30" },
-    { CAVESTORY, "1" },
-    { COLECOVISION, "31" },
-    { COMMODORE_64, "40" },
-    { DAPHNE, "23" },
-    { INTELLIVISION, "32" },
-    { APPLE_MACINTOSH, "37" },
-    { MICROSOFT_XBOX, "14" },
-    { MICROSOFT_XBOX_360, "15" },
-    { MOONLIGHT, "1" },
-    { MSX, "4929" },
-    { MSX2, "4929" },
-    { MSX_TURBO_R, "4929" },
-    { SNK_NEO_GEO, "24" },
-    { SNK_NEO_GEO_CD, "24" },
-    { SNK_NEO_GEO_POCKET, "4922" },
-    { SNK_NEO_GEO_POCKET_COLOR, "4923" },
-    { NINTENDO_3DS, "4912" },
-    { NINTENDO_64, "3" },
-    { NINTENDO_DS, "8" },
-    { NINTENDO_FAMICOM, "7" },
-    { NINTENDO_FAMICOM_DISK_SYSTEM, "4936" },
-    { NINTENDO_ENTERTAINMENT_SYSTEM, "7" },
-    { NINTENDO_GAME_BOY, "4" },
-    { NINTENDO_GAME_BOY_ADVANCE, "5" },
-    { NINTENDO_GAME_BOY_COLOR, "41" },
-    { NINTENDO_GAMECUBE, "2" },
-    { NINTENDO_WII, "9" },
-    { NINTENDO_WII_U, "38" },
-    { NINTENDO_VIRTUAL_BOY, "4918" },
-    { NINTENDO_GAME_AND_WATCH, "4950" },
-    { NINTENDO_POKEMON_MINI, "4957" },
-    { NINTENDO_SATELLAVIEW, "6" },
-    { NINTENDO_SWITCH, "4971" },
-    { BANDAI_SUFAMI_TURBO, "6" },
-    { DOS, "1" },
-    { PC, "1" },
-    { VALVE_STEAM, "1" },
-    { NEC_PCFX, "4930" },
-    { SEGA_32X, "33" },
-    { SEGA_CD, "21" },
-    { SEGA_DREAMCAST, "16" },
-    { SEGA_GAME_GEAR, "20" },
-    { SEGA_GENESIS, "18" },
-    { SEGA_MASTER_SYSTEM, "35" },
-    { SEGA_MEGA_DRIVE, "36" },
-    { SEGA_SATURN, "17" },
-    { SEGA_SG1000, "4949" },
-    { SONY_PLAYSTATION, "10" },
-    { SONY_PLAYSTATION_2, "11" },
-    { SONY_PLAYSTATION_3, "12" },
-    { SONY_PLAYSTATION_4, "4919" },
-    { SONY_PLAYSTATION_VITA, "39" },
-    { SONY_PLAYSTATION_PORTABLE, "13" },
-    { SUPER_NINTENDO, "6" },
-    { SHARP_X1, "4977" },
-    { SHARP_X68000, "4931" },
-    { NEC_SUPERGRAFX, "34" },
-    { NEC_PC_8800, "4933" },
-    { NEC_PC_9800, "4934" },
-    { NEC_PC_ENGINE, "34" },
-    { NEC_PC_ENGINE_CD, "4955" },
-    { BANDAI_WONDERSWAN, "4925" },
-    { BANDAI_WONDERSWAN_COLOR, "4926" },
-    { SINCLAIR_ZX_SPECTRUM, "4913" },
-    { VIDEOPAC_ODYSSEY2, "4927" },
-    { VECTREX, "4939" },
-    { TANDY_COLOR_COMPUTER, "4941" },
-    { TANDY_TRS80, "4941" },
+const std::map<PlatformId, std::string> gamesdb_new_platformid_map{
+    {THREEDO, "25"},
+    {COMMODORE_AMIGA, "4911"},
+    {COMMODORE_AMIGA_CD32, "4947"},
+    {AMSTRAD_CPC, "4914"},
+    {APPLE_II, "4942"},
+    {ARCADE, "23"},
+    {ATARI_800, "4943"},
+    {ATARI_2600, "22"},
+    {ATARI_5200, "26"},
+    {ATARI_7800, "27"},
+    {ATARI_JAGUAR, "28"},
+    {ATARI_JAGUAR_CD, "29"},
+    {ATARI_LYNX, "4924"},
+    {ATARI_ST, "4937"},
+    {ATARI_XE, "30"},
+    {CAVESTORY, "1"},
+    {COLECOVISION, "31"},
+    {COMMODORE_64, "40"},
+    {DAPHNE, "23"},
+    {INTELLIVISION, "32"},
+    {APPLE_MACINTOSH, "37"},
+    {MICROSOFT_XBOX, "14"},
+    {MICROSOFT_XBOX_360, "15"},
+    {MOONLIGHT, "1"},
+    {MSX, "4929"},
+    {MSX2, "4929"},
+    {MSX_TURBO_R, "4929"},
+    {SNK_NEO_GEO, "24"},
+    {SNK_NEO_GEO_CD, "24"},
+    {SNK_NEO_GEO_POCKET, "4922"},
+    {SNK_NEO_GEO_POCKET_COLOR, "4923"},
+    {NINTENDO_3DS, "4912"},
+    {NINTENDO_64, "3"},
+    {NINTENDO_DS, "8"},
+    {NINTENDO_FAMICOM, "7"},
+    {NINTENDO_FAMICOM_DISK_SYSTEM, "4936"},
+    {NINTENDO_ENTERTAINMENT_SYSTEM, "7"},
+    {NINTENDO_GAME_BOY, "4"},
+    {NINTENDO_GAME_BOY_ADVANCE, "5"},
+    {NINTENDO_GAME_BOY_COLOR, "41"},
+    {NINTENDO_GAMECUBE, "2"},
+    {NINTENDO_WII, "9"},
+    {NINTENDO_WII_U, "38"},
+    {NINTENDO_VIRTUAL_BOY, "4918"},
+    {NINTENDO_GAME_AND_WATCH, "4950"},
+    {NINTENDO_POKEMON_MINI, "4957"},
+    {NINTENDO_SATELLAVIEW, "6"},
+    {NINTENDO_SWITCH, "4971"},
+    {BANDAI_SUFAMI_TURBO, "6"},
+    {DOS, "1"},
+    {PC, "1"},
+    {VALVE_STEAM, "1"},
+    {NEC_PCFX, "4930"},
+    {SEGA_32X, "33"},
+    {SEGA_CD, "21"},
+    {SEGA_DREAMCAST, "16"},
+    {SEGA_GAME_GEAR, "20"},
+    {SEGA_GENESIS, "18"},
+    {SEGA_MASTER_SYSTEM, "35"},
+    {SEGA_MEGA_DRIVE, "36"},
+    {SEGA_SATURN, "17"},
+    {SEGA_SG1000, "4949"},
+    {SONY_PLAYSTATION, "10"},
+    {SONY_PLAYSTATION_2, "11"},
+    {SONY_PLAYSTATION_3, "12"},
+    {SONY_PLAYSTATION_4, "4919"},
+    {SONY_PLAYSTATION_VITA, "39"},
+    {SONY_PLAYSTATION_PORTABLE, "13"},
+    {SUPER_NINTENDO, "6"},
+    {SHARP_X1, "4977"},
+    {SHARP_X68000, "4931"},
+    {NEC_SUPERGRAFX, "34"},
+    {NEC_PC_8800, "4933"},
+    {NEC_PC_9800, "4934"},
+    {NEC_PC_ENGINE, "34"},
+    {NEC_PC_ENGINE_CD, "4955"},
+    {BANDAI_WONDERSWAN, "4925"},
+    {BANDAI_WONDERSWAN_COLOR, "4926"},
+    {SINCLAIR_ZX_SPECTRUM, "4913"},
+    {VIDEOPAC_ODYSSEY2, "4927"},
+    {VECTREX, "4939"},
+    {TANDY_COLOR_COMPUTER, "4941"},
+    {TANDY_TRS80, "4941"},
 };
 
 void thegamesdb_generate_json_scraper_requests(
diff --git a/es-app/src/scrapers/Scraper.cpp b/es-app/src/scrapers/Scraper.cpp
index 234fd8a6a..c768843a8 100644
--- a/es-app/src/scrapers/Scraper.cpp
+++ b/es-app/src/scrapers/Scraper.cpp
@@ -26,10 +26,9 @@
 #include <cmath>
 #include <fstream>
 
-const std::map<std::string, generate_scraper_requests_func> scraper_request_funcs {
-    { "thegamesdb", &thegamesdb_generate_json_scraper_requests },
-    { "screenscraper", &screenscraper_generate_scraper_requests }
-};
+const std::map<std::string, generate_scraper_requests_func> scraper_request_funcs{
+    {"thegamesdb", &thegamesdb_generate_json_scraper_requests},
+    {"screenscraper", &screenscraper_generate_scraper_requests}};
 
 std::unique_ptr<ScraperSearchHandle> startScraperSearch(const ScraperSearchParams& params)
 {
diff --git a/es-app/src/scrapers/ScreenScraper.cpp b/es-app/src/scrapers/ScreenScraper.cpp
index 7135960a2..252388518 100644
--- a/es-app/src/scrapers/ScreenScraper.cpp
+++ b/es-app/src/scrapers/ScreenScraper.cpp
@@ -26,109 +26,108 @@ using namespace PlatformIds;
 
 // List of systems and their IDs from:
 // https://www.screenscraper.fr/api/systemesListe.php?devid=xxx&devpassword=yyy&softname=zzz&output=XML
-const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
-    { THREEDO, 29 },
-    { COMMODORE_AMIGA, 64 },
-    { COMMODORE_AMIGA_CD32, 130 },
-    { AMSTRAD_CPC, 65 },
-    { AMSTRAD_GX4000, 87 },
-    { APPLE_II, 86 },
-    { APPLE_IIGS, 217 },
-    { ARCADE, 75 },
-    { ATARI_800, 43 },
-    { ATARI_2600, 26 },
-    { ATARI_5200, 40 },
-    { ATARI_7800, 41 },
-    { ATARI_JAGUAR, 27 },
-    { ATARI_JAGUAR_CD, 171 },
-    { ATARI_LYNX, 28 },
-    { ATARI_ST, 42 },
-    { ATARI_XE, 43 },
-    { ATOMISWAVE, 53 },
-    { BBC_MICRO, 37 },
-    { CAVESTORY, 135 },
-    { COLECOVISION, 48 },
-    { COMMODORE_64, 66 },
-    { COMMODORE_CDTV, 129 },
-    { DAPHNE, 49 },
-    { INTELLIVISION, 115 },
-    { GAMEENGINE_LUTRO, 206 },
-    { APPLE_MACINTOSH, 146 },
-    { MICROSOFT_XBOX, 32 },
-    { MICROSOFT_XBOX_360, 33 },
-    { MOONLIGHT, 138 },
-    { MSX, 113 },
-    { MSX2, 116 },
-    { MSX_TURBO_R, 118 },
-    { SNK_NEO_GEO, 142 },
-    { SNK_NEO_GEO_CD, 142 },
-    { SNK_NEO_GEO_POCKET, 25 },
-    { SNK_NEO_GEO_POCKET_COLOR, 82 },
-    { NINTENDO_3DS, 17 },
-    { NINTENDO_64, 14 },
-    { NINTENDO_DS, 15 },
-    { NINTENDO_FAMICOM, 3 },
-    { NINTENDO_FAMICOM_DISK_SYSTEM, 106 },
-    { NINTENDO_ENTERTAINMENT_SYSTEM, 3 },
-    { FAIRCHILD_CHANNELF, 80 },
-    { NINTENDO_GAME_BOY, 9 },
-    { NINTENDO_GAME_BOY_ADVANCE, 12 },
-    { NINTENDO_GAME_BOY_COLOR, 10 },
-    { NINTENDO_GAMECUBE, 13 },
-    { NINTENDO_WII, 16 },
-    { NINTENDO_WII_U, 18 },
-    { NINTENDO_VIRTUAL_BOY, 11 },
-    { NINTENDO_GAME_AND_WATCH, 52 },
-    { NINTENDO_POKEMON_MINI, 211 },
-    { NINTENDO_SATELLAVIEW, 107 },
-    { NINTENDO_SWITCH, 225 },
-    { BANDAI_SUFAMI_TURBO, 108 },
-    { DOS, 135 },
-    { PC, 135 },
-    { VALVE_STEAM, 135 },
-    { NEC_PCFX, 72 },
-    { GAMEENGINE_OPENBOR, 214 },
-    { TANGERINE_ORIC, 131 },
-    { GAMEENGINE_SCUMMVM, 123 },
-    { SEGA_32X, 19 },
-    { SEGA_CD, 20 },
-    { SEGA_DREAMCAST, 23 },
-    { SEGA_GAME_GEAR, 21 },
-    { SEGA_GENESIS, 1 },
-    { SEGA_MASTER_SYSTEM, 2 },
-    { SEGA_MEGA_DRIVE, 1 },
-    { SEGA_SATURN, 22 },
-    { SEGA_SG1000, 109 },
-    { SHARP_X1, 220 },
-    { SHARP_X68000, 79 },
-    { GAMEENGINE_SOLARUS, 223 },
-    { SONY_PLAYSTATION, 57 },
-    { SONY_PLAYSTATION_2, 58 },
-    { SONY_PLAYSTATION_3, 59 },
-    { SONY_PLAYSTATION_VITA, 62 },
-    { SONY_PLAYSTATION_PORTABLE, 61 },
-    { SAMCOUPE, 213 },
-    { SUPER_NINTENDO, 4 },
-    { NEC_SUPERGRAFX, 105 },
-    { GAMEENGINE_TIC80, 222 },
-    { NEC_PC_8800, 221 },
-    { NEC_PC_9800, 208 },
-    { NEC_PC_ENGINE, 31 },
-    { NEC_PC_ENGINE_CD, 114 },
-    { BANDAI_WONDERSWAN, 45 },
-    { BANDAI_WONDERSWAN_COLOR, 46 },
-    { SINCLAIR_ZX_SPECTRUM, 76 },
-    { SINCLAIR_ZX81_SINCLAR, 77 },
-    { VIDEOPAC_ODYSSEY2, 104 },
-    { VECTREX, 102 },
-    { TANDY_TRS80, 144 },
-    { TANDY_COLOR_COMPUTER, 144 },
-    { SEGA_NAOMI, 56 },
-    { THOMSON_MOTO, 141 },
-    { UZEBOX, 216 },
-    { SPECTRAVIDEO, 218 },
-    { PALM_OS, 219 }
-};
+const std::map<PlatformId, unsigned short> screenscraper_platformid_map{
+    {THREEDO, 29},
+    {COMMODORE_AMIGA, 64},
+    {COMMODORE_AMIGA_CD32, 130},
+    {AMSTRAD_CPC, 65},
+    {AMSTRAD_GX4000, 87},
+    {APPLE_II, 86},
+    {APPLE_IIGS, 217},
+    {ARCADE, 75},
+    {ATARI_800, 43},
+    {ATARI_2600, 26},
+    {ATARI_5200, 40},
+    {ATARI_7800, 41},
+    {ATARI_JAGUAR, 27},
+    {ATARI_JAGUAR_CD, 171},
+    {ATARI_LYNX, 28},
+    {ATARI_ST, 42},
+    {ATARI_XE, 43},
+    {ATOMISWAVE, 53},
+    {BBC_MICRO, 37},
+    {CAVESTORY, 135},
+    {COLECOVISION, 48},
+    {COMMODORE_64, 66},
+    {COMMODORE_CDTV, 129},
+    {DAPHNE, 49},
+    {INTELLIVISION, 115},
+    {GAMEENGINE_LUTRO, 206},
+    {APPLE_MACINTOSH, 146},
+    {MICROSOFT_XBOX, 32},
+    {MICROSOFT_XBOX_360, 33},
+    {MOONLIGHT, 138},
+    {MSX, 113},
+    {MSX2, 116},
+    {MSX_TURBO_R, 118},
+    {SNK_NEO_GEO, 142},
+    {SNK_NEO_GEO_CD, 142},
+    {SNK_NEO_GEO_POCKET, 25},
+    {SNK_NEO_GEO_POCKET_COLOR, 82},
+    {NINTENDO_3DS, 17},
+    {NINTENDO_64, 14},
+    {NINTENDO_DS, 15},
+    {NINTENDO_FAMICOM, 3},
+    {NINTENDO_FAMICOM_DISK_SYSTEM, 106},
+    {NINTENDO_ENTERTAINMENT_SYSTEM, 3},
+    {FAIRCHILD_CHANNELF, 80},
+    {NINTENDO_GAME_BOY, 9},
+    {NINTENDO_GAME_BOY_ADVANCE, 12},
+    {NINTENDO_GAME_BOY_COLOR, 10},
+    {NINTENDO_GAMECUBE, 13},
+    {NINTENDO_WII, 16},
+    {NINTENDO_WII_U, 18},
+    {NINTENDO_VIRTUAL_BOY, 11},
+    {NINTENDO_GAME_AND_WATCH, 52},
+    {NINTENDO_POKEMON_MINI, 211},
+    {NINTENDO_SATELLAVIEW, 107},
+    {NINTENDO_SWITCH, 225},
+    {BANDAI_SUFAMI_TURBO, 108},
+    {DOS, 135},
+    {PC, 135},
+    {VALVE_STEAM, 135},
+    {NEC_PCFX, 72},
+    {GAMEENGINE_OPENBOR, 214},
+    {TANGERINE_ORIC, 131},
+    {GAMEENGINE_SCUMMVM, 123},
+    {SEGA_32X, 19},
+    {SEGA_CD, 20},
+    {SEGA_DREAMCAST, 23},
+    {SEGA_GAME_GEAR, 21},
+    {SEGA_GENESIS, 1},
+    {SEGA_MASTER_SYSTEM, 2},
+    {SEGA_MEGA_DRIVE, 1},
+    {SEGA_SATURN, 22},
+    {SEGA_SG1000, 109},
+    {SHARP_X1, 220},
+    {SHARP_X68000, 79},
+    {GAMEENGINE_SOLARUS, 223},
+    {SONY_PLAYSTATION, 57},
+    {SONY_PLAYSTATION_2, 58},
+    {SONY_PLAYSTATION_3, 59},
+    {SONY_PLAYSTATION_VITA, 62},
+    {SONY_PLAYSTATION_PORTABLE, 61},
+    {SAMCOUPE, 213},
+    {SUPER_NINTENDO, 4},
+    {NEC_SUPERGRAFX, 105},
+    {GAMEENGINE_TIC80, 222},
+    {NEC_PC_8800, 221},
+    {NEC_PC_9800, 208},
+    {NEC_PC_ENGINE, 31},
+    {NEC_PC_ENGINE_CD, 114},
+    {BANDAI_WONDERSWAN, 45},
+    {BANDAI_WONDERSWAN_COLOR, 46},
+    {SINCLAIR_ZX_SPECTRUM, 76},
+    {SINCLAIR_ZX81_SINCLAR, 77},
+    {VIDEOPAC_ODYSSEY2, 104},
+    {VECTREX, 102},
+    {TANDY_TRS80, 144},
+    {TANDY_COLOR_COMPUTER, 144},
+    {SEGA_NAOMI, 56},
+    {THOMSON_MOTO, 141},
+    {UZEBOX, 216},
+    {SPECTRAVIDEO, 218},
+    {PALM_OS, 219}};
 
 // Helper XML parsing method, finding a node-by-name recursively.
 pugi::xml_node find_node_by_name_re(const pugi::xml_node& node,
@@ -333,11 +332,10 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
             Utils::String::toLower(Settings::getInstance()->getString("ScraperLanguage"));
 
         // Name fallback: US, WOR(LD). (Xpath: Data/jeu[0]/noms/nom[*]).
-        result.mdl.set("name",
-                       find_child_by_attribute_list(game.child("noms"), "nom", "region",
-                                                    { region, "wor", "us", "ss", "eu", "jp" })
-                           .text()
-                           .get());
+        result.mdl.set("name", find_child_by_attribute_list(game.child("noms"), "nom", "region",
+                                                            {region, "wor", "us", "ss", "eu", "jp"})
+                                   .text()
+                                   .get());
         LOG(LogDebug) << "ScreenScraperRequest::processGame(): Name: " << result.mdl.get("name");
 
         // Validate rating.
@@ -360,7 +358,7 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
 
         // Description fallback language: EN, WOR(LD).
         std::string description = find_child_by_attribute_list(game.child("synopsis"), "synopsis",
-                                                               "langue", { language, "en", "wor" })
+                                                               "langue", {language, "en", "wor"})
                                       .text()
                                       .get();
 
@@ -373,7 +371,7 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
         // Get the date proper. The API returns multiple 'date' children nodes to the 'dates'
         // main child of 'jeu'. Date fallback: WOR(LD), US, SS, JP, EU.
         std::string _date = find_child_by_attribute_list(game.child("dates"), "date", "region",
-                                                         { region, "wor", "us", "ss", "jp", "eu" })
+                                                         {region, "wor", "us", "ss", "jp", "eu"})
                                 .text()
                                 .get();
 
@@ -411,10 +409,10 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
         }
 
         // Genre fallback language: EN. (Xpath: Data/jeu[0]/genres/genre[*]).
-        std::string genre = find_child_by_attribute_list(game.child("genres"), "genre", "langue",
-                                                         { language, "en" })
-                                .text()
-                                .get();
+        std::string genre =
+            find_child_by_attribute_list(game.child("genres"), "genre", "langue", {language, "en"})
+                .text()
+                .get();
         if (!genre.empty()) {
             result.mdl.set("genre", genre);
             LOG(LogDebug) << "ScreenScraperRequest::processGame(): Genre: "
@@ -482,8 +480,7 @@ void ScreenScraperRequest::processMedia(ScraperSearchResult& result,
         }
         else {
             // Region fallback: WOR(LD), US, CUS(TOM?), JP, EU.
-            for (auto _region :
-                 std::vector<std::string> { region, "wor", "us", "cus", "jp", "eu" }) {
+            for (auto _region : std::vector<std::string>{region, "wor", "us", "cus", "jp", "eu"}) {
                 if (art)
                     break;
 
diff --git a/es-app/src/scrapers/ScreenScraper.h b/es-app/src/scrapers/ScreenScraper.h
index 97295587b..3e07bf61b 100644
--- a/es-app/src/scrapers/ScreenScraper.h
+++ b/es-app/src/scrapers/ScreenScraper.h
@@ -46,10 +46,10 @@ public:
         std::string getGameSearchUrl(const std::string gameName) const;
 
         // Access to the API.
-        const std::string API_DEV_U = { 15, 21, 39, 22, 42, 40 };
-        const std::string API_DEV_P = { 32, 70, 46, 54, 12, 5, 13, 120, 50, 66, 25 };
-        const std::string API_DEV_KEY = { 67, 112, 72, 120, 121, 77, 119, 74,  84,  56,
-                                          75, 122, 78, 98,  69,  86, 56,  120, 120, 49 };
+        const std::string API_DEV_U = {15, 21, 39, 22, 42, 40};
+        const std::string API_DEV_P = {32, 70, 46, 54, 12, 5, 13, 120, 50, 66, 25};
+        const std::string API_DEV_KEY = {67, 112, 72, 120, 121, 77, 119, 74,  84,  56,
+                                         75, 122, 78, 98,  69,  86, 56,  120, 120, 49};
         const std::string API_URL_BASE = "https://www.screenscraper.fr/api2";
         const std::string API_SOFT_NAME =
             "EmulationStation-DE " + static_cast<std::string>(PROGRAM_VERSION_STRING);
diff --git a/es-app/src/views/SystemView.cpp b/es-app/src/views/SystemView.cpp
index eb9c285c4..916ac0526 100644
--- a/es-app/src/views/SystemView.cpp
+++ b/es-app/src/views/SystemView.cpp
@@ -23,8 +23,8 @@
 #endif
 
 // Buffer values for scrolling velocity (left, stopped, right).
-const int logoBuffersLeft[] = { -5, -2, -1 };
-const int logoBuffersRight[] = { 1, 2, 5 };
+const int logoBuffersLeft[] = {-5, -2, -1};
+const int logoBuffersRight[] = {1, 2, 5};
 
 SystemView::SystemView(Window* window)
     : IList<SystemViewData, SystemData*>(window, LIST_SCROLL_STYLE_SLOW, LIST_ALWAYS_LOOP)
@@ -123,7 +123,7 @@ void SystemView::populate()
                     e.data.logo->setOrigin(0.5, 0.5);
             }
 
-            glm::vec2 denormalized = mCarousel.logoSize * e.data.logo->getOrigin();
+            glm::vec2 denormalized{mCarousel.logoSize * e.data.logo->getOrigin()};
             e.data.logo->setPosition(denormalized.x, denormalized.y, 0.0f);
 
             // Make background extras.
@@ -401,7 +401,7 @@ void SystemView::render(const glm::mat4& parentTrans)
     if (size() == 0)
         return; // Nothing to render.
 
-    glm::mat4 trans = getTransform() * parentTrans;
+    glm::mat4 trans{getTransform() * parentTrans};
 
     renderExtras(trans, INT16_MIN, INT16_MAX);
 
@@ -475,17 +475,17 @@ void SystemView::getViewElements(const std::shared_ptr<ThemeData>& theme)
 void SystemView::renderCarousel(const glm::mat4& trans)
 {
     // Background box behind logos.
-    glm::mat4 carouselTrans = trans;
+    glm::mat4 carouselTrans{trans};
     carouselTrans =
-        glm::translate(carouselTrans, glm::vec3(mCarousel.pos.x, mCarousel.pos.y, 0.0f));
+        glm::translate(carouselTrans, glm::vec3{mCarousel.pos.x, mCarousel.pos.y, 0.0f});
     carouselTrans = glm::translate(carouselTrans,
-                                   glm::vec3(mCarousel.origin.x * mCarousel.size.x * -1.0f,
-                                             mCarousel.origin.y * mCarousel.size.y * -1.0f, 0.0f));
+                                   glm::vec3{mCarousel.origin.x * mCarousel.size.x * -1.0f,
+                                             mCarousel.origin.y * mCarousel.size.y * -1.0f, 0.0f});
 
-    glm::vec2 clipPos(carouselTrans[3].x, carouselTrans[3].y);
+    glm::vec2 clipPos{carouselTrans[3].x, carouselTrans[3].y};
     Renderer::pushClipRect(
-        Vector2i(static_cast<int>(clipPos.x), static_cast<int>(clipPos.y)),
-        Vector2i(static_cast<int>(mCarousel.size.x), static_cast<int>(mCarousel.size.y)));
+        glm::ivec2{static_cast<int>(clipPos.x), static_cast<int>(clipPos.y)},
+        glm::ivec2{static_cast<int>(mCarousel.size.x), static_cast<int>(mCarousel.size.y)});
 
     Renderer::setMatrix(carouselTrans);
     Renderer::drawRect(0.0f, 0.0f, mCarousel.size.x, mCarousel.size.y, mCarousel.color,
@@ -493,7 +493,7 @@ void SystemView::renderCarousel(const glm::mat4& trans)
 
     // Draw logos.
     // Note: logoSpacing will also include the size of the logo itself.
-    glm::vec2 logoSpacing(0.0f, 0.0f);
+    glm::vec2 logoSpacing{};
     float xOff = 0.0f;
     float yOff = 0.0f;
 
@@ -569,9 +569,9 @@ void SystemView::renderCarousel(const glm::mat4& trans)
         while (index >= static_cast<int>(mEntries.size()))
             index -= static_cast<int>(mEntries.size());
 
-        glm::mat4 logoTrans = carouselTrans;
+        glm::mat4 logoTrans{carouselTrans};
         logoTrans = glm::translate(
-            logoTrans, glm::vec3(i * logoSpacing.x + xOff, i * logoSpacing.y + yOff, 0.0f));
+            logoTrans, glm::vec3{i * logoSpacing.x + xOff, i * logoSpacing.y + yOff, 0.0f});
 
         float distance = i - mCamOffset;
 
@@ -600,10 +600,10 @@ void SystemView::renderExtras(const glm::mat4& trans, float lower, float upper)
     int extrasCenter = static_cast<int>(mExtrasCamOffset);
 
     // Adding texture loading buffers depending on scrolling speed and status.
-    int bufferIndex = getScrollingVelocity() + 1;
+    int bufferIndex{getScrollingVelocity() + 1};
 
-    Renderer::pushClipRect(Vector2i::Zero(),
-                           Vector2i(static_cast<int>(mSize.x), static_cast<int>(mSize.y)));
+    Renderer::pushClipRect(glm::ivec2{},
+                           glm::ivec2{static_cast<int>(mSize.x), static_cast<int>(mSize.y)});
 
     for (int i = extrasCenter + logoBuffersLeft[bufferIndex];
          i <= extrasCenter + logoBuffersRight[bufferIndex]; i++) {
@@ -615,17 +615,17 @@ void SystemView::renderExtras(const glm::mat4& trans, float lower, float upper)
 
         // Only render selected system when not showing.
         if (mShowing || index == mCursor) {
-            glm::mat4 extrasTrans = trans;
+            glm::mat4 extrasTrans{trans};
             if (mCarousel.type == HORIZONTAL || mCarousel.type == HORIZONTAL_WHEEL)
                 extrasTrans = glm::translate(
-                    extrasTrans, glm::vec3((i - mExtrasCamOffset) * mSize.x, 0.0f, 0.0f));
+                    extrasTrans, glm::vec3{(i - mExtrasCamOffset) * mSize.x, 0.0f, 0.0f});
             else
                 extrasTrans = glm::translate(
-                    extrasTrans, glm::vec3(0.0f, (i - mExtrasCamOffset) * mSize.y, 0.0f));
+                    extrasTrans, glm::vec3{0.0f, (i - mExtrasCamOffset) * mSize.y, 0.0f});
 
             Renderer::pushClipRect(
-                Vector2i(static_cast<int>(extrasTrans[3].x), static_cast<int>(extrasTrans[3].y)),
-                Vector2i(static_cast<int>(mSize.x), static_cast<int>(mSize.y)));
+                glm::ivec2{static_cast<int>(extrasTrans[3].x), static_cast<int>(extrasTrans[3].y)},
+                glm::ivec2{static_cast<int>(mSize.x), static_cast<int>(mSize.y)});
             SystemViewData data = mEntries.at(index).data;
             for (unsigned int j = 0; j < data.backgroundExtras.size(); j++) {
                 GuiComponent* extra = data.backgroundExtras[j];
diff --git a/es-app/src/views/UIModeController.h b/es-app/src/views/UIModeController.h
index f16c4257d..5fbc83721 100644
--- a/es-app/src/views/UIModeController.h
+++ b/es-app/src/views/UIModeController.h
@@ -58,9 +58,7 @@ private:
     int mPassKeyCounter;
 
     // These are Xbox button names, so they may be different in pracise on non-Xbox controllers.
-    const std::vector<std::string> mInputVals = {
-        "up", "down", "left", "right", "a", "b", "x", "y"
-    };
+    const std::vector<std::string> mInputVals = {"up", "down", "left", "right", "a", "b", "x", "y"};
 };
 
 #endif // ES_APP_VIEWS_UI_MODE_CONTROLLER_H
diff --git a/es-app/src/views/ViewController.cpp b/es-app/src/views/ViewController.cpp
index a0ebb2889..e4c337335 100644
--- a/es-app/src/views/ViewController.cpp
+++ b/es-app/src/views/ViewController.cpp
@@ -285,7 +285,7 @@ int ViewController::getSystemId(SystemData* system)
 void ViewController::restoreViewPosition()
 {
     if (mPreviousView) {
-        glm::vec3 restorePosition = mPreviousView->getPosition();
+        glm::vec3 restorePosition{mPreviousView->getPosition()};
         restorePosition.x = mWrapPreviousPositionX;
         mPreviousView->setPosition(restorePosition);
         mWrapPreviousPositionX = 0;
@@ -458,9 +458,9 @@ void ViewController::goToGameList(SystemData* system)
     // movements will be correct. This is accomplished by simply offsetting the X position
     // with the position of the first or last system plus the screen width.
     if (wrapFirstToLast) {
-        glm::vec3 currentPosition = mCurrentView->getPosition();
+        glm::vec3 currentPosition{mCurrentView->getPosition()};
         mWrapPreviousPositionX = currentPosition.x;
-        float offsetX = getGameListView(system)->getPosition().x;
+        float offsetX{getGameListView(system)->getPosition().x};
         // This is needed to move the camera in the correct direction if there are only two systems.
         if (SystemData::sSystemVector.size() == 2 && mNextSystem)
             offsetX -= Renderer::getScreenWidth();
@@ -472,9 +472,9 @@ void ViewController::goToGameList(SystemData* system)
         mWrappedViews = true;
     }
     else if (wrapLastToFirst) {
-        glm::vec3 currentPosition = mCurrentView->getPosition();
+        glm::vec3 currentPosition{mCurrentView->getPosition()};
         mWrapPreviousPositionX = currentPosition.x;
-        float offsetX = getGameListView(system)->getPosition().x;
+        float offsetX{getGameListView(system)->getPosition().x};
         if (SystemData::sSystemVector.size() == 2 && !mNextSystem)
             offsetX += Renderer::getScreenWidth();
         else
@@ -528,7 +528,7 @@ void ViewController::playViewTransition(bool instant)
 {
     mCancelledTransition = false;
 
-    glm::vec3 target {};
+    glm::vec3 target{};
     if (mCurrentView)
         target = mCurrentView->getPosition();
 
@@ -537,7 +537,7 @@ void ViewController::playViewTransition(bool instant)
     if (target == static_cast<glm::vec3>(-mCamera[3]) && !isAnimationPlaying(0))
         return;
 
-    std::string transition_style = Settings::getInstance()->getString("TransitionStyle");
+    std::string transition_style{Settings::getInstance()->getString("TransitionStyle")};
 
     if (instant || transition_style == "instant") {
         setAnimation(new LambdaAnimation(
@@ -854,15 +854,14 @@ void ViewController::update(int deltaTime)
 
 void ViewController::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = mCamera * parentTrans;
-    glm::mat4 transInverse;
-    transInverse = glm::inverse(trans);
+    glm::mat4 trans{mCamera * parentTrans};
+    glm::mat4 transInverse{glm::inverse(trans)};
 
     // Camera position, position + size.
-    glm::vec3 viewStart = transInverse[3];
-    glm::vec3 viewEnd = { std::fabs(trans[3].x) + static_cast<float>(Renderer::getScreenWidth()),
-                          std::fabs(trans[3].y) + static_cast<float>(Renderer::getScreenHeight()),
-                          0.0f };
+    glm::vec3 viewStart{transInverse[3]};
+    glm::vec3 viewEnd{std::fabs(trans[3].x) + static_cast<float>(Renderer::getScreenWidth()),
+                      std::fabs(trans[3].y) + static_cast<float>(Renderer::getScreenHeight()),
+                      0.0f};
 
     // Keep track of UI mode changes.
     UIModeController::getInstance()->monitorUIMode();
@@ -877,9 +876,9 @@ void ViewController::render(const glm::mat4& parentTrans)
         // Same thing as for the system view, limit the rendering only to what needs to be drawn.
         if (it->second == mCurrentView || (it->second == mPreviousView && isCameraMoving())) {
             // Clipping.
-            glm::vec3 guiStart = it->second->getPosition();
-            glm::vec3 guiEnd = it->second->getPosition() +
-                               glm::vec3(it->second->getSize().x, it->second->getSize().y, 0.0f);
+            glm::vec3 guiStart{it->second->getPosition()};
+            glm::vec3 guiEnd{it->second->getPosition() +
+                             glm::vec3{it->second->getSize().x, it->second->getSize().y, 0.0f}};
 
             if (guiEnd.x >= viewStart.x && guiEnd.y >= viewStart.y && guiStart.x <= viewEnd.x &&
                 guiStart.y <= viewEnd.y)
diff --git a/es-app/src/views/gamelist/DetailedGameListView.cpp b/es-app/src/views/gamelist/DetailedGameListView.cpp
index e333e3203..cb18d2921 100644
--- a/es-app/src/views/gamelist/DetailedGameListView.cpp
+++ b/es-app/src/views/gamelist/DetailedGameListView.cpp
@@ -145,10 +145,9 @@ void DetailedGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& them
     initMDLabels();
     std::vector<TextComponent*> labels = getMDLabels();
     assert(labels.size() == 8);
-    std::vector<std::string> lblElements = { "md_lbl_rating",     "md_lbl_releasedate",
-                                             "md_lbl_developer",  "md_lbl_publisher",
-                                             "md_lbl_genre",      "md_lbl_players",
-                                             "md_lbl_lastplayed", "md_lbl_playcount" };
+    std::vector<std::string> lblElements = {
+        "md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer",  "md_lbl_publisher",
+        "md_lbl_genre",  "md_lbl_players",     "md_lbl_lastplayed", "md_lbl_playcount"};
 
     for (unsigned int i = 0; i < labels.size(); i++)
         labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@@ -156,9 +155,9 @@ void DetailedGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& them
     initMDValues();
     std::vector<GuiComponent*> values = getMDValues();
     assert(values.size() == 8);
-    std::vector<std::string> valElements = { "md_rating",     "md_releasedate", "md_developer",
-                                             "md_publisher",  "md_genre",       "md_players",
-                                             "md_lastplayed", "md_playcount" };
+    std::vector<std::string> valElements = {"md_rating",     "md_releasedate", "md_developer",
+                                            "md_publisher",  "md_genre",       "md_players",
+                                            "md_lastplayed", "md_playcount"};
 
     for (unsigned int i = 0; i < values.size(); i++)
         values[i]->applyTheme(theme, getName(), valElements[i], ALL ^ ThemeFlags::TEXT);
@@ -172,7 +171,7 @@ void DetailedGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& them
 
     mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
     // If there is no position defined in the theme for gamelistInfo, then hide it.
-    if (mGamelistInfo.getPosition() == glm::vec3 {})
+    if (mGamelistInfo.getPosition() == glm::vec3{})
         mGamelistInfo.setVisible(false);
     else
         mGamelistInfo.setVisible(true);
@@ -187,21 +186,21 @@ void DetailedGameListView::initMDLabels()
     const unsigned int colCount = 2;
     const unsigned int rowCount = static_cast<int>(components.size() / 2);
 
-    glm::vec3 start(mSize.x * 0.01f, mSize.y * 0.625f, 0.0f);
+    glm::vec3 start{mSize.x * 0.01f, mSize.y * 0.625f, 0.0f};
 
     const float colSize = (mSize.x * 0.48f) / colCount;
     const float rowPadding = 0.01f * mSize.y;
 
     for (unsigned int i = 0; i < components.size(); i++) {
         const unsigned int row = i % rowCount;
-        glm::vec3 pos {};
+        glm::vec3 pos{};
         if (row == 0) {
-            pos = start + glm::vec3(colSize * (i / rowCount), 0.0f, 0.0f);
+            pos = start + glm::vec3{colSize * (i / rowCount), 0.0f, 0.0f};
         }
         else {
             // Work from the last component.
             GuiComponent* lc = components[i - 1];
-            pos = lc->getPosition() + glm::vec3(0.0f, lc->getSize().y + rowPadding, 0.0f);
+            pos = lc->getPosition() + glm::vec3{0.0f, lc->getSize().y + rowPadding, 0.0f};
         }
 
         components[i]->setFont(Font::get(FONT_SIZE_SMALL));
@@ -231,7 +230,7 @@ void DetailedGameListView::initMDValues()
     for (unsigned int i = 0; i < labels.size(); i++) {
         const float heightDiff = (labels[i]->getSize().y - values[i]->getSize().y) / 2.0f;
         values[i]->setPosition(labels[i]->getPosition() +
-                               glm::vec3(labels[i]->getSize().x, heightDiff, 0.0f));
+                               glm::vec3{labels[i]->getSize().x, heightDiff, 0.0f});
         values[i]->setSize(colSize - labels[i]->getSize().x, values[i]->getSize().y);
         values[i]->setDefaultZIndex(40.0f);
 
diff --git a/es-app/src/views/gamelist/GridGameListView.cpp b/es-app/src/views/gamelist/GridGameListView.cpp
index cb5331ff7..5744575f3 100644
--- a/es-app/src/views/gamelist/GridGameListView.cpp
+++ b/es-app/src/views/gamelist/GridGameListView.cpp
@@ -244,10 +244,9 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
     initMDLabels();
     std::vector<TextComponent*> labels = getMDLabels();
     assert(labels.size() == 8);
-    std::vector<std::string> lblElements = { "md_lbl_rating",     "md_lbl_releasedate",
-                                             "md_lbl_developer",  "md_lbl_publisher",
-                                             "md_lbl_genre",      "md_lbl_players",
-                                             "md_lbl_lastplayed", "md_lbl_playcount" };
+    std::vector<std::string> lblElements = {
+        "md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer",  "md_lbl_publisher",
+        "md_lbl_genre",  "md_lbl_players",     "md_lbl_lastplayed", "md_lbl_playcount"};
 
     for (unsigned int i = 0; i < labels.size(); i++)
         labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@@ -255,9 +254,9 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
     initMDValues();
     std::vector<GuiComponent*> values = getMDValues();
     assert(values.size() == 8);
-    std::vector<std::string> valElements = { "md_rating",     "md_releasedate", "md_developer",
-                                             "md_publisher",  "md_genre",       "md_players",
-                                             "md_lastplayed", "md_playcount" };
+    std::vector<std::string> valElements = {"md_rating",     "md_releasedate", "md_developer",
+                                            "md_publisher",  "md_genre",       "md_players",
+                                            "md_lastplayed", "md_playcount"};
 
     for (unsigned int i = 0; i < values.size(); i++)
         values[i]->applyTheme(theme, getName(), valElements[i], ALL ^ ThemeFlags::TEXT);
@@ -277,7 +276,7 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
 
     mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
     // If there is no position defined in the theme for gamelistInfo, then hide it.
-    if (mGamelistInfo.getPosition() == glm::vec3({}))
+    if (mGamelistInfo.getPosition() == glm::vec3{})
         mGamelistInfo.setVisible(false);
     else
         mGamelistInfo.setVisible(true);
@@ -298,21 +297,21 @@ void GridGameListView::initMDLabels()
     const unsigned int colCount = 2;
     const unsigned int rowCount = static_cast<int>(components.size() / 2);
 
-    glm::vec3 start(mSize.x * 0.01f, mSize.y * 0.625f, 0.0f);
+    glm::vec3 start{mSize.x * 0.01f, mSize.y * 0.625f, 0.0f};
 
     const float colSize = (mSize.x * 0.48f) / colCount;
     const float rowPadding = 0.01f * mSize.y;
 
     for (unsigned int i = 0; i < components.size(); i++) {
         const unsigned int row = i % rowCount;
-        glm::vec3 pos {};
+        glm::vec3 pos{};
         if (row == 0) {
-            pos = start + glm::vec3(colSize * (i / rowCount), 0.0f, 0.0f);
+            pos = start + glm::vec3{colSize * (i / rowCount), 0.0f, 0.0f};
         }
         else {
             // Work from the last component.
             GuiComponent* lc = components[i - 1];
-            pos = lc->getPosition() + glm::vec3(0.0f, lc->getSize().y + rowPadding, 0.0f);
+            pos = lc->getPosition() + glm::vec3{0.0f, lc->getSize().y + rowPadding, 0.0f};
         }
 
         components[i]->setFont(Font::get(FONT_SIZE_SMALL));
@@ -342,7 +341,7 @@ void GridGameListView::initMDValues()
     for (unsigned int i = 0; i < labels.size(); i++) {
         const float heightDiff = (labels[i]->getSize().y - values[i]->getSize().y) / 2.0f;
         values[i]->setPosition(labels[i]->getPosition() +
-                               glm::vec3(labels[i]->getSize().x, heightDiff, 0.0f));
+                               glm::vec3{labels[i]->getSize().x, heightDiff, 0.0f});
         values[i]->setSize(colSize - labels[i]->getSize().x, values[i]->getSize().y);
         values[i]->setDefaultZIndex(40.0f);
 
diff --git a/es-app/src/views/gamelist/IGameListView.cpp b/es-app/src/views/gamelist/IGameListView.cpp
index 6f129dd9f..6412b7b9b 100644
--- a/es-app/src/views/gamelist/IGameListView.cpp
+++ b/es-app/src/views/gamelist/IGameListView.cpp
@@ -62,15 +62,15 @@ HelpStyle IGameListView::getHelpStyle()
 
 void IGameListView::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     float scaleX = trans[0].x;
     float scaleY = trans[1].y;
 
-    Vector2i pos(static_cast<int>(std::round(trans[3].x)),
-                 static_cast<int>(std::round(trans[3].y)));
-    Vector2i size(static_cast<int>(std::round(mSize.x * scaleX)),
-                  static_cast<int>(std::round(mSize.y * scaleY)));
+    glm::ivec2 pos{static_cast<int>(std::round(trans[3].x)),
+                   static_cast<int>(std::round(trans[3].y))};
+    glm::ivec2 size{static_cast<int>(std::round(mSize.x * scaleX)),
+                    static_cast<int>(std::round(mSize.y * scaleY))};
 
     Renderer::pushClipRect(pos, size);
     renderChildren(trans);
diff --git a/es-app/src/views/gamelist/VideoGameListView.cpp b/es-app/src/views/gamelist/VideoGameListView.cpp
index ab4cd8012..6f986f995 100644
--- a/es-app/src/views/gamelist/VideoGameListView.cpp
+++ b/es-app/src/views/gamelist/VideoGameListView.cpp
@@ -167,10 +167,9 @@ void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
     initMDLabels();
     std::vector<TextComponent*> labels = getMDLabels();
     assert(labels.size() == 8);
-    std::vector<std::string> lblElements = { "md_lbl_rating",     "md_lbl_releasedate",
-                                             "md_lbl_developer",  "md_lbl_publisher",
-                                             "md_lbl_genre",      "md_lbl_players",
-                                             "md_lbl_lastplayed", "md_lbl_playcount" };
+    std::vector<std::string> lblElements = {
+        "md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer",  "md_lbl_publisher",
+        "md_lbl_genre",  "md_lbl_players",     "md_lbl_lastplayed", "md_lbl_playcount"};
 
     for (unsigned int i = 0; i < labels.size(); i++)
         labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@@ -178,9 +177,9 @@ void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
     initMDValues();
     std::vector<GuiComponent*> values = getMDValues();
     assert(values.size() == 8);
-    std::vector<std::string> valElements = { "md_rating",     "md_releasedate", "md_developer",
-                                             "md_publisher",  "md_genre",       "md_players",
-                                             "md_lastplayed", "md_playcount" };
+    std::vector<std::string> valElements = {"md_rating",     "md_releasedate", "md_developer",
+                                            "md_publisher",  "md_genre",       "md_players",
+                                            "md_lastplayed", "md_playcount"};
 
     for (unsigned int i = 0; i < values.size(); i++)
         values[i]->applyTheme(theme, getName(), valElements[i], ALL ^ ThemeFlags::TEXT);
@@ -194,7 +193,7 @@ void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
 
     mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
     // If there is no position defined in the theme for gamelistInfo, then hide it.
-    if (mGamelistInfo.getPosition() == glm::vec3({}))
+    if (mGamelistInfo.getPosition() == glm::vec3{})
         mGamelistInfo.setVisible(false);
     else
         mGamelistInfo.setVisible(true);
@@ -209,21 +208,21 @@ void VideoGameListView::initMDLabels()
     const unsigned int colCount = 2;
     const unsigned int rowCount = static_cast<int>(components.size() / 2);
 
-    glm::vec3 start(mSize.x * 0.01f, mSize.y * 0.625f, 0.0f);
+    glm::vec3 start{mSize.x * 0.01f, mSize.y * 0.625f, 0.0f};
 
     const float colSize = (mSize.x * 0.48f) / colCount;
     const float rowPadding = 0.01f * mSize.y;
 
     for (unsigned int i = 0; i < components.size(); i++) {
         const unsigned int row = i % rowCount;
-        glm::vec3 pos {};
+        glm::vec3 pos{};
         if (row == 0) {
-            pos = start + glm::vec3(colSize * (i / rowCount), 0.0f, 0.0f);
+            pos = start + glm::vec3{colSize * (i / rowCount), 0.0f, 0.0f};
         }
         else {
             // Work from the last component.
             GuiComponent* lc = components[i - 1];
-            pos = lc->getPosition() + glm::vec3(0.0f, lc->getSize().y + rowPadding, 0.0f);
+            pos = lc->getPosition() + glm::vec3{0.0f, lc->getSize().y + rowPadding, 0.0f};
         }
 
         components[i]->setFont(Font::get(FONT_SIZE_SMALL));
@@ -253,7 +252,7 @@ void VideoGameListView::initMDValues()
     for (unsigned int i = 0; i < labels.size(); i++) {
         const float heightDiff = (labels[i]->getSize().y - values[i]->getSize().y) / 2.0f;
         values[i]->setPosition(labels[i]->getPosition() +
-                               glm::vec3(labels[i]->getSize().x, heightDiff, 0.0f));
+                               glm::vec3{labels[i]->getSize().x, heightDiff, 0.0f});
         values[i]->setSize(colSize - labels[i]->getSize().x, values[i]->getSize().y);
         values[i]->setDefaultZIndex(40.0f);
 
diff --git a/es-core/src/GuiComponent.cpp b/es-core/src/GuiComponent.cpp
index 14848b379..d2e55030b 100644
--- a/es-core/src/GuiComponent.cpp
+++ b/es-core/src/GuiComponent.cpp
@@ -83,7 +83,7 @@ void GuiComponent::render(const glm::mat4& parentTrans)
     if (!isVisible())
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
     renderChildren(trans);
 }
 
@@ -95,26 +95,26 @@ void GuiComponent::renderChildren(const glm::mat4& transform) const
 
 void GuiComponent::setPosition(float x, float y, float z)
 {
-    mPosition = glm::vec3(x, y, z);
+    mPosition = glm::vec3{x, y, z};
     onPositionChanged();
 }
 
 void GuiComponent::setOrigin(float x, float y)
 {
-    mOrigin = glm::vec2(x, y);
+    mOrigin = glm::vec2{x, y};
     onOriginChanged();
 }
 
 void GuiComponent::setSize(float w, float h)
 {
-    mSize = glm::vec2(w, h);
+    mSize = glm::vec2{w, h};
     onSizeChanged();
 }
 
 glm::vec2 GuiComponent::getCenter() const
 {
-    return glm::vec2(mPosition.x - (getSize().x * mOrigin.x) + getSize().x / 2.0f,
-                     mPosition.y - (getSize().y * mOrigin.y) + getSize().y / 2.0f);
+    return glm::vec2{mPosition.x - (getSize().x * mOrigin.x) + getSize().x / 2.0f,
+                     mPosition.y - (getSize().y * mOrigin.y) + getSize().y / 2.0f};
 }
 
 void GuiComponent::addChild(GuiComponent* cmp)
@@ -177,27 +177,27 @@ const glm::mat4& GuiComponent::getTransform()
     mTransform = glm::translate(mTransform, mPosition);
 
     if (mScale != 1.0f)
-        mTransform = glm::scale(mTransform, glm::vec3(mScale));
+        mTransform = glm::scale(mTransform, glm::vec3{mScale});
 
     if (mRotation != 0.0f) {
         // Calculate offset as difference between origin and rotation origin.
-        glm::vec2 rotationSize = getRotationSize();
-        float xOff = (mOrigin.x - mRotationOrigin.x) * rotationSize.x;
-        float yOff = (mOrigin.y - mRotationOrigin.y) * rotationSize.y;
+        glm::vec2 rotationSize{getRotationSize()};
+        float xOff{(mOrigin.x - mRotationOrigin.x) * rotationSize.x};
+        float yOff{(mOrigin.y - mRotationOrigin.y) * rotationSize.y};
 
         // Transform to offset point.
         if (xOff != 0.0f || yOff != 0.0f)
-            mTransform = glm::translate(mTransform, glm::vec3(xOff * -1.0f, yOff * -1.0f, 0.0f));
+            mTransform = glm::translate(mTransform, glm::vec3{xOff * -1.0f, yOff * -1.0f, 0.0f});
 
         // Apply rotation transform.
-        mTransform = glm::rotate(mTransform, mRotation, glm::vec3(0.0f, 0.0f, 1.0f));
+        mTransform = glm::rotate(mTransform, mRotation, glm::vec3{0.0f, 0.0f, 1.0f});
 
         // Transform back to original point.
         if (xOff != 0.0f || yOff != 0.0f)
-            mTransform = glm::translate(mTransform, glm::vec3(xOff, yOff, 0.0f));
+            mTransform = glm::translate(mTransform, glm::vec3{xOff, yOff, 0.0f});
     }
     mTransform = glm::translate(
-        mTransform, glm::vec3(mOrigin.x * mSize.x * -1.0f, mOrigin.y * mSize.y * -1.0f, 0.0f));
+        mTransform, glm::vec3{mOrigin.x * mSize.x * -1.0f, mOrigin.y * mSize.y * -1.0f, 0.0f});
 
     return mTransform;
 }
@@ -302,9 +302,9 @@ void GuiComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
                               const std::string& element,
                               unsigned int properties)
 {
-    glm::vec2 scale = getParent() ? getParent()->getSize() :
-                                    glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
-                                              static_cast<float>(Renderer::getScreenHeight()));
+    glm::vec2 scale{getParent() ? getParent()->getSize() :
+                                  glm::vec2{static_cast<float>(Renderer::getScreenWidth()),
+                                            static_cast<float>(Renderer::getScreenHeight())}};
 
     const ThemeData::ThemeElement* elem = theme->getElement(view, element, "");
     if (!elem)
@@ -312,8 +312,8 @@ void GuiComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
 
     using namespace ThemeFlags;
     if (properties & POSITION && elem->has("pos")) {
-        glm::vec2 denormalized = elem->get<glm::vec2>("pos") * scale;
-        setPosition(glm::vec3(denormalized.x, denormalized.y, 0.0f));
+        glm::vec2 denormalized{elem->get<glm::vec2>("pos") * scale};
+        setPosition(glm::vec3{denormalized.x, denormalized.y, 0.0f});
     }
 
     if (properties & ThemeFlags::SIZE && elem->has("size"))
diff --git a/es-core/src/GuiComponent.h b/es-core/src/GuiComponent.h
index 658418d13..ce506cc2d 100644
--- a/es-core/src/GuiComponent.h
+++ b/es-core/src/GuiComponent.h
@@ -58,7 +58,7 @@ public:
     // By default, just calls renderChildren(parentTrans * getTransform())
     // Normally the following steps are required:
     // 1. Calculate the new transform that your component will draw at
-    //    glm::mat4 trans = parentTrans * getTransform();
+    //    glm::mat4 trans {parentTrans * getTransform()};
     // 2. Set the renderer to use that new transform as the model matrix
     //    Renderer::setMatrix(trans);
     // 3. Draw your component
@@ -83,7 +83,7 @@ public:
     // (e.g. (0, 0) is top left, (0.5, 0.5) is the center.)
     void setRotationOrigin(float originX, float originY)
     {
-        mRotationOrigin = glm::vec2(originX, originY);
+        mRotationOrigin = glm::vec2{originX, originY};
     }
     void setRotationOrigin(glm::vec2 origin) { setRotationOrigin(origin.x, origin.y); }
 
diff --git a/es-core/src/HelpStyle.cpp b/es-core/src/HelpStyle.cpp
index 866ef4684..2a6cb917a 100644
--- a/es-core/src/HelpStyle.cpp
+++ b/es-core/src/HelpStyle.cpp
@@ -14,8 +14,8 @@
 HelpStyle::HelpStyle()
 {
     position =
-        glm::vec2(Renderer::getScreenWidth() * 0.012f, Renderer::getScreenHeight() * 0.9515f);
-    origin = glm::vec2(0.0f, 0.0f);
+        glm::vec2{Renderer::getScreenWidth() * 0.012f, Renderer::getScreenHeight() * 0.9515f};
+    origin = glm::vec2{};
     iconColor = 0x777777FF;
     textColor = 0x777777FF;
 
@@ -33,8 +33,8 @@ void HelpStyle::applyTheme(const std::shared_ptr<ThemeData>& theme, const std::s
 
     if (elem->has("pos"))
         position = elem->get<glm::vec2>("pos") *
-                   glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
-                             static_cast<float>(Renderer::getScreenHeight()));
+                   glm::vec2{static_cast<float>(Renderer::getScreenWidth()),
+                             static_cast<float>(Renderer::getScreenHeight())};
 
     if (elem->has("origin"))
         origin = elem->get<glm::vec2>("origin");
diff --git a/es-core/src/Log.h b/es-core/src/Log.h
index da45efd9f..9d98951a0 100644
--- a/es-core/src/Log.h
+++ b/es-core/src/Log.h
@@ -49,12 +49,11 @@ protected:
     std::ostringstream os;
 
 private:
-    std::map<LogLevel, std::string> logLevelMap { // Log level indicators.
-                                                  { LogError, "Error" },
-                                                  { LogWarning, "Warn" },
-                                                  { LogInfo, "Info" },
-                                                  { LogDebug, "Debug" }
-    };
+    std::map<LogLevel, std::string> logLevelMap{// Log level indicators.
+                                                {LogError, "Error"},
+                                                {LogWarning, "Warn"},
+                                                {LogInfo, "Info"},
+                                                {LogDebug, "Debug"}};
 
     static LogLevel reportingLevel;
     LogLevel messageLevel;
diff --git a/es-core/src/MameNames.cpp b/es-core/src/MameNames.cpp
index 30b1f4748..a3ff474e3 100644
--- a/es-core/src/MameNames.cpp
+++ b/es-core/src/MameNames.cpp
@@ -68,8 +68,8 @@ MameNames::MameNames()
 
     for (pugi::xml_node gameNode = doc.child("game"); gameNode;
          gameNode = gameNode.next_sibling("game")) {
-        NamePair namePair = { gameNode.child("mamename").text().get(),
-                              gameNode.child("realname").text().get() };
+        NamePair namePair = {gameNode.child("mamename").text().get(),
+                             gameNode.child("realname").text().get()};
         mNamePairs.push_back(namePair);
     }
 
diff --git a/es-core/src/Platform.cpp b/es-core/src/Platform.cpp
index e0a70729c..8319555ba 100644
--- a/es-core/src/Platform.cpp
+++ b/es-core/src/Platform.cpp
@@ -139,7 +139,7 @@ int launchGameUnix(const std::string& cmd_utf8, bool runInBackground)
 int launchGameWindows(const std::wstring& cmd_utf16, bool runInBackground, bool hideWindow)
 {
 #if defined(_WIN64)
-    STARTUPINFOW si {};
+    STARTUPINFOW si{};
     PROCESS_INFORMATION pi;
 
     si.cb = sizeof(si);
diff --git a/es-core/src/Settings.cpp b/es-core/src/Settings.cpp
index 1d1822a54..633a25c9f 100644
--- a/es-core/src/Settings.cpp
+++ b/es-core/src/Settings.cpp
@@ -97,161 +97,161 @@ void Settings::setDefaults()
     //
 
     // Scraper.
-    mStringMap["Scraper"] = { "screenscraper", "screenscraper" };
-    mBoolMap["ScraperUseAccountScreenScraper"] = { false, false };
-    mStringMap["ScraperUsernameScreenScraper"] = { "", "" };
-    mStringMap["ScraperPasswordScreenScraper"] = { "", "" };
+    mStringMap["Scraper"] = {"screenscraper", "screenscraper"};
+    mBoolMap["ScraperUseAccountScreenScraper"] = {false, false};
+    mStringMap["ScraperUsernameScreenScraper"] = {"", ""};
+    mStringMap["ScraperPasswordScreenScraper"] = {"", ""};
 
-    mBoolMap["ScrapeGameNames"] = { true, true };
-    mBoolMap["ScrapeRatings"] = { true, true };
-    mBoolMap["ScrapeMetadata"] = { true, true };
-    mBoolMap["ScrapeVideos"] = { true, true };
-    mBoolMap["ScrapeScreenshots"] = { true, true };
-    mBoolMap["ScrapeCovers"] = { true, true };
-    mBoolMap["ScrapeMarquees"] = { true, true };
-    mBoolMap["Scrape3DBoxes"] = { true, true };
+    mBoolMap["ScrapeGameNames"] = {true, true};
+    mBoolMap["ScrapeRatings"] = {true, true};
+    mBoolMap["ScrapeMetadata"] = {true, true};
+    mBoolMap["ScrapeVideos"] = {true, true};
+    mBoolMap["ScrapeScreenshots"] = {true, true};
+    mBoolMap["ScrapeCovers"] = {true, true};
+    mBoolMap["ScrapeMarquees"] = {true, true};
+    mBoolMap["Scrape3DBoxes"] = {true, true};
 
-    mStringMap["MiximageResolution"] = { "1280x960", "1280x960" };
-    mStringMap["MiximageScreenshotScaling"] = { "sharp", "sharp" };
-    mBoolMap["MiximageGenerate"] = { true, true };
-    mBoolMap["MiximageOverwrite"] = { true, true };
-    mBoolMap["MiximageRemoveLetterboxes"] = { true, true };
-    mBoolMap["MiximageRemovePillarboxes"] = { true, true };
-    mBoolMap["MiximageIncludeMarquee"] = { true, true };
-    mBoolMap["MiximageIncludeBox"] = { true, true };
-    mBoolMap["MiximageCoverFallback"] = { true, true };
+    mStringMap["MiximageResolution"] = {"1280x960", "1280x960"};
+    mStringMap["MiximageScreenshotScaling"] = {"sharp", "sharp"};
+    mBoolMap["MiximageGenerate"] = {true, true};
+    mBoolMap["MiximageOverwrite"] = {true, true};
+    mBoolMap["MiximageRemoveLetterboxes"] = {true, true};
+    mBoolMap["MiximageRemovePillarboxes"] = {true, true};
+    mBoolMap["MiximageIncludeMarquee"] = {true, true};
+    mBoolMap["MiximageIncludeBox"] = {true, true};
+    mBoolMap["MiximageCoverFallback"] = {true, true};
 
-    mStringMap["ScraperRegion"] = { "eu", "eu" };
-    mStringMap["ScraperLanguage"] = { "en", "en" };
-    mBoolMap["ScraperOverwriteData"] = { true, true };
-    mBoolMap["ScraperHaltOnInvalidMedia"] = { true, true };
-    mBoolMap["ScraperSearchMetadataName"] = { true, true };
-    mBoolMap["ScraperInteractive"] = { true, true };
-    mBoolMap["ScraperSemiautomatic"] = { true, true };
-    mBoolMap["ScraperRespectExclusions"] = { true, true };
-    mBoolMap["ScraperExcludeRecursively"] = { true, true };
-    mBoolMap["ScraperIncludeFolders"] = { false, false };
-    mBoolMap["ScraperRetryPeerVerification"] = { false, false };
+    mStringMap["ScraperRegion"] = {"eu", "eu"};
+    mStringMap["ScraperLanguage"] = {"en", "en"};
+    mBoolMap["ScraperOverwriteData"] = {true, true};
+    mBoolMap["ScraperHaltOnInvalidMedia"] = {true, true};
+    mBoolMap["ScraperSearchMetadataName"] = {true, true};
+    mBoolMap["ScraperInteractive"] = {true, true};
+    mBoolMap["ScraperSemiautomatic"] = {true, true};
+    mBoolMap["ScraperRespectExclusions"] = {true, true};
+    mBoolMap["ScraperExcludeRecursively"] = {true, true};
+    mBoolMap["ScraperIncludeFolders"] = {false, false};
+    mBoolMap["ScraperRetryPeerVerification"] = {false, false};
 
     // UI settings.
-    mStringMap["StartupSystem"] = { "", "" };
-    mStringMap["GamelistViewStyle"] = { "automatic", "automatic" };
-    mStringMap["TransitionStyle"] = { "slide", "slide" };
-    mStringMap["ThemeSet"] = { "rbsimple-DE", "rbsimple-DE" };
-    mStringMap["UIMode"] = { "full", "full" };
-    mStringMap["DefaultSortOrder"] = { "filename, ascending", "filename, ascending" };
-    mStringMap["MenuOpeningEffect"] = { "scale-up", "scale-up" };
-    mStringMap["LaunchScreenDuration"] = { "normal", "normal" };
-    mBoolMap["MenuBlurBackground"] = { true, true };
-    mBoolMap["GamelistVideoPillarbox"] = { true, true };
-    mBoolMap["GamelistVideoScanlines"] = { false, false };
-    mBoolMap["FoldersOnTop"] = { true, true };
-    mBoolMap["FavoritesFirst"] = { true, true };
-    mBoolMap["FavoritesStar"] = { true, true };
-    mBoolMap["SpecialCharsASCII"] = { false, false };
-    mBoolMap["ListScrollOverlay"] = { false, false };
-    mBoolMap["FavoritesAddButton"] = { true, true };
-    mBoolMap["RandomAddButton"] = { false, false };
-    mBoolMap["GamelistFilters"] = { true, true };
-    mBoolMap["QuickSystemSelect"] = { true, true };
-    mBoolMap["ShowHelpPrompts"] = { true, true };
-    mBoolMap["PlayVideosImmediately"] = { false, false };
-    mBoolMap["EnableMenuKidMode"] = { false, false };
+    mStringMap["StartupSystem"] = {"", ""};
+    mStringMap["GamelistViewStyle"] = {"automatic", "automatic"};
+    mStringMap["TransitionStyle"] = {"slide", "slide"};
+    mStringMap["ThemeSet"] = {"rbsimple-DE", "rbsimple-DE"};
+    mStringMap["UIMode"] = {"full", "full"};
+    mStringMap["DefaultSortOrder"] = {"filename, ascending", "filename, ascending"};
+    mStringMap["MenuOpeningEffect"] = {"scale-up", "scale-up"};
+    mStringMap["LaunchScreenDuration"] = {"normal", "normal"};
+    mBoolMap["MenuBlurBackground"] = {true, true};
+    mBoolMap["GamelistVideoPillarbox"] = {true, true};
+    mBoolMap["GamelistVideoScanlines"] = {false, false};
+    mBoolMap["FoldersOnTop"] = {true, true};
+    mBoolMap["FavoritesFirst"] = {true, true};
+    mBoolMap["FavoritesStar"] = {true, true};
+    mBoolMap["SpecialCharsASCII"] = {false, false};
+    mBoolMap["ListScrollOverlay"] = {false, false};
+    mBoolMap["FavoritesAddButton"] = {true, true};
+    mBoolMap["RandomAddButton"] = {false, false};
+    mBoolMap["GamelistFilters"] = {true, true};
+    mBoolMap["QuickSystemSelect"] = {true, true};
+    mBoolMap["ShowHelpPrompts"] = {true, true};
+    mBoolMap["PlayVideosImmediately"] = {false, false};
+    mBoolMap["EnableMenuKidMode"] = {false, false};
 
     // UI settings -> media viewer settings.
-    mBoolMap["MediaViewerKeepVideoRunning"] = { true, true };
-    mBoolMap["MediaViewerStretchVideos"] = { false, false };
-    mBoolMap["MediaViewerVideoScanlines"] = { true, true };
-    mBoolMap["MediaViewerVideoBlur"] = { false, false };
-    mBoolMap["MediaViewerScreenshotScanlines"] = { true, true };
+    mBoolMap["MediaViewerKeepVideoRunning"] = {true, true};
+    mBoolMap["MediaViewerStretchVideos"] = {false, false};
+    mBoolMap["MediaViewerVideoScanlines"] = {true, true};
+    mBoolMap["MediaViewerVideoBlur"] = {false, false};
+    mBoolMap["MediaViewerScreenshotScanlines"] = {true, true};
 
     // UI settings -> screensaver settings.
-    mIntMap["ScreensaverTimer"] = { 5 * 60 * 1000, 5 * 60 * 1000 }; // 5 minutes.
-    mStringMap["ScreensaverType"] = { "video", "video" };
-    mBoolMap["ScreensaverControls"] = { true, true };
+    mIntMap["ScreensaverTimer"] = {5 * 60 * 1000, 5 * 60 * 1000}; // 5 minutes.
+    mStringMap["ScreensaverType"] = {"video", "video"};
+    mBoolMap["ScreensaverControls"] = {true, true};
 
     // UI settings -> screensaver settings -> slideshow screensaver settings.
-    mIntMap["ScreensaverSwapImageTimeout"] = { 10000, 10000 };
-    mBoolMap["ScreensaverStretchImages"] = { false, false };
-    mBoolMap["ScreensaverSlideshowGameInfo"] = { true, true };
-    mBoolMap["ScreensaverSlideshowScanlines"] = { true, true };
-    mBoolMap["ScreensaverSlideshowCustomImages"] = { false, false };
-    mBoolMap["ScreensaverSlideshowRecurse"] = { false, false };
-    mStringMap["ScreensaverSlideshowImageDir"] = { "~/.emulationstation/slideshow/custom_images",
-                                                   "~/.emulationstation/slideshow/custom_images" };
+    mIntMap["ScreensaverSwapImageTimeout"] = {10000, 10000};
+    mBoolMap["ScreensaverStretchImages"] = {false, false};
+    mBoolMap["ScreensaverSlideshowGameInfo"] = {true, true};
+    mBoolMap["ScreensaverSlideshowScanlines"] = {true, true};
+    mBoolMap["ScreensaverSlideshowCustomImages"] = {false, false};
+    mBoolMap["ScreensaverSlideshowRecurse"] = {false, false};
+    mStringMap["ScreensaverSlideshowImageDir"] = {"~/.emulationstation/slideshow/custom_images",
+                                                  "~/.emulationstation/slideshow/custom_images"};
 
     // UI settings -> screensaver settings -> video screensaver settings.
-    mIntMap["ScreensaverSwapVideoTimeout"] = { 0, 0 };
-    mBoolMap["ScreensaverStretchVideos"] = { false, false };
-    mBoolMap["ScreensaverVideoGameInfo"] = { true, true };
-    mBoolMap["ScreensaverVideoScanlines"] = { true, true };
-    mBoolMap["ScreensaverVideoBlur"] = { false, false };
+    mIntMap["ScreensaverSwapVideoTimeout"] = {0, 0};
+    mBoolMap["ScreensaverStretchVideos"] = {false, false};
+    mBoolMap["ScreensaverVideoGameInfo"] = {true, true};
+    mBoolMap["ScreensaverVideoScanlines"] = {true, true};
+    mBoolMap["ScreensaverVideoBlur"] = {false, false};
 
     // Sound settings.
-    mIntMap["SoundVolumeNavigation"] = { 80, 80 };
-    mIntMap["SoundVolumeVideos"] = { 100, 100 };
-    mBoolMap["GamelistVideoAudio"] = { true, true };
-    mBoolMap["MediaViewerVideoAudio"] = { true, true };
-    mBoolMap["ScreensaverVideoAudio"] = { false, false };
-    mBoolMap["NavigationSounds"] = { true, true };
+    mIntMap["SoundVolumeNavigation"] = {80, 80};
+    mIntMap["SoundVolumeVideos"] = {100, 100};
+    mBoolMap["GamelistVideoAudio"] = {true, true};
+    mBoolMap["MediaViewerVideoAudio"] = {true, true};
+    mBoolMap["ScreensaverVideoAudio"] = {false, false};
+    mBoolMap["NavigationSounds"] = {true, true};
 
     // Input device settings.
-    mStringMap["InputControllerType"] = { "xbox", "xbox" };
-    mBoolMap["InputOnlyFirstController"] = { false, false };
+    mStringMap["InputControllerType"] = {"xbox", "xbox"};
+    mBoolMap["InputOnlyFirstController"] = {false, false};
 
     // Game collection settings.
-    mStringMap["CollectionSystemsAuto"] = { "", "" };
-    mStringMap["CollectionSystemsCustom"] = { "", "" };
-    mBoolMap["FavFirstCustom"] = { false, false };
-    mBoolMap["FavStarCustom"] = { false, false };
-    mBoolMap["UseCustomCollectionsSystem"] = { true, true };
-    mBoolMap["CollectionShowSystemInfo"] = { true, true };
+    mStringMap["CollectionSystemsAuto"] = {"", ""};
+    mStringMap["CollectionSystemsCustom"] = {"", ""};
+    mBoolMap["FavFirstCustom"] = {false, false};
+    mBoolMap["FavStarCustom"] = {false, false};
+    mBoolMap["UseCustomCollectionsSystem"] = {true, true};
+    mBoolMap["CollectionShowSystemInfo"] = {true, true};
 
 // Other settings.
 #if defined(_RPI_)
-    mIntMap["MaxVRAM"] = { 80, 80 };
+    mIntMap["MaxVRAM"] = {80, 80};
 #else
-    mIntMap["MaxVRAM"] = { 256, 256 };
+    mIntMap["MaxVRAM"] = {256, 256};
 #endif
-    mIntMap["DisplayIndex"] = { 1, 1 };
+    mIntMap["DisplayIndex"] = {1, 1};
 #if defined(__unix__)
-    mStringMap["FullscreenMode"] = { "normal", "normal" };
+    mStringMap["FullscreenMode"] = {"normal", "normal"};
 #endif
 #if defined(BUILD_VLC_PLAYER)
 #if defined(_RPI_)
     // As the FFmpeg video player is not HW accelerated, use VLC as default on this weak device.
-    mStringMap["VideoPlayer"] = { "vlc", "vlc" };
+    mStringMap["VideoPlayer"] = {"vlc", "vlc"};
 #else
-    mStringMap["VideoPlayer"] = { "ffmpeg", "ffmpeg" };
+    mStringMap["VideoPlayer"] = {"ffmpeg", "ffmpeg"};
 #endif
 #endif
-    mStringMap["ExitButtonCombo"] = { "F4", "F4" };
-    mStringMap["SaveGamelistsMode"] = { "always", "always" };
+    mStringMap["ExitButtonCombo"] = {"F4", "F4"};
+    mStringMap["SaveGamelistsMode"] = {"always", "always"};
 #if defined(_WIN64)
-    mBoolMap["HideTaskbar"] = { false, false };
+    mBoolMap["HideTaskbar"] = {false, false};
 #endif
-    mBoolMap["RunInBackground"] = { false, false };
+    mBoolMap["RunInBackground"] = {false, false};
 #if defined(_WIN64)
-    mBoolMap["LaunchWorkaround"] = { true, true };
+    mBoolMap["LaunchWorkaround"] = {true, true};
 #endif
-    mStringMap["MediaDirectory"] = { "", "" };
+    mStringMap["MediaDirectory"] = {"", ""};
 #if !defined(_RPI_)
-    mBoolMap["VideoHardwareDecoding"] = { false, false };
+    mBoolMap["VideoHardwareDecoding"] = {false, false};
 #endif
-    mBoolMap["VideoUpscaleFrameRate"] = { false, false };
-    mBoolMap["LaunchCommandOverride"] = { true, true };
-    mBoolMap["ShowHiddenFiles"] = { true, true };
-    mBoolMap["ShowHiddenGames"] = { true, true };
-    mBoolMap["CustomEventScripts"] = { false, false };
-    mBoolMap["ParseGamelistOnly"] = { false, false };
+    mBoolMap["VideoUpscaleFrameRate"] = {false, false};
+    mBoolMap["LaunchCommandOverride"] = {true, true};
+    mBoolMap["ShowHiddenFiles"] = {true, true};
+    mBoolMap["ShowHiddenGames"] = {true, true};
+    mBoolMap["CustomEventScripts"] = {false, false};
+    mBoolMap["ParseGamelistOnly"] = {false, false};
 #if defined(__unix__)
-    mBoolMap["DisableComposition"] = { true, true };
+    mBoolMap["DisableComposition"] = {true, true};
 #endif
-    mBoolMap["DisplayGPUStatistics"] = { false, false };
+    mBoolMap["DisplayGPUStatistics"] = {false, false};
 // macOS requires root privileges to reboot and power off so it doesn't make much
 // sense to enable this setting and menu entry for that operating system.
 #if !defined(__APPLE__)
-    mBoolMap["ShowQuitMenu"] = { false, false };
+    mBoolMap["ShowQuitMenu"] = {false, false};
 #endif
 
     //
@@ -259,45 +259,45 @@ void Settings::setDefaults()
     //
 
     // Options listed using --help
-    mBoolMap["Debug"] = { false, false };
-    mBoolMap["ForceFull"] = { false, false };
-    mBoolMap["ForceKid"] = { false, false };
-    mBoolMap["ForceKiosk"] = { false, false };
-    mBoolMap["IgnoreGamelist"] = { false, false };
-    mBoolMap["SplashScreen"] = { true, true };
-    mBoolMap["VSync"] = { true, true };
+    mBoolMap["Debug"] = {false, false};
+    mBoolMap["ForceFull"] = {false, false};
+    mBoolMap["ForceKid"] = {false, false};
+    mBoolMap["ForceKiosk"] = {false, false};
+    mBoolMap["IgnoreGamelist"] = {false, false};
+    mBoolMap["SplashScreen"] = {true, true};
+    mBoolMap["VSync"] = {true, true};
 #if !defined(_WIN64)
-    mBoolMap["Windowed"] = { false, false };
+    mBoolMap["Windowed"] = {false, false};
 #endif
-    mIntMap["WindowWidth"] = { 0, 0 };
-    mIntMap["WindowHeight"] = { 0, 0 };
-    mIntMap["ScreenWidth"] = { 0, 0 };
+    mIntMap["WindowWidth"] = {0, 0};
+    mIntMap["WindowHeight"] = {0, 0};
+    mIntMap["ScreenWidth"] = {0, 0};
 
     // Undocumented options.
-    mIntMap["ScreenHeight"] = { 0, 0 };
-    mIntMap["ScreenOffsetX"] = { 0, 0 };
-    mIntMap["ScreenOffsetY"] = { 0, 0 };
-    mIntMap["ScreenRotate"] = { 0, 0 };
+    mIntMap["ScreenHeight"] = {0, 0};
+    mIntMap["ScreenOffsetX"] = {0, 0};
+    mIntMap["ScreenOffsetY"] = {0, 0};
+    mIntMap["ScreenRotate"] = {0, 0};
 
     //
     // Settings that can be changed in es_settings.xml
     // but that are not configurable via the GUI.
     //
 
-    mBoolMap["DebugSkipInputLogging"] = { false, false };
-    mStringMap["ROMDirectory"] = { "", "" };
-    mStringMap["UIMode_passkey"] = { "uuddlrlrba", "uuddlrlrba" };
+    mBoolMap["DebugSkipInputLogging"] = {false, false};
+    mStringMap["ROMDirectory"] = {"", ""};
+    mStringMap["UIMode_passkey"] = {"uuddlrlrba", "uuddlrlrba"};
 
     //
     // Hardcoded or program-internal settings.
     //
 
-    mStringMap["ApplicationVersion"] = { "", "" };
-    mBoolMap["DebugGrid"] = { false, false };
-    mBoolMap["DebugText"] = { false, false };
-    mBoolMap["DebugImage"] = { false, false };
-    mBoolMap["SplashScreenProgress"] = { true, true };
-    mIntMap["ScraperFilter"] = { 0, 0 };
+    mStringMap["ApplicationVersion"] = {"", ""};
+    mBoolMap["DebugGrid"] = {false, false};
+    mBoolMap["DebugText"] = {false, false};
+    mBoolMap["DebugImage"] = {false, false};
+    mBoolMap["SplashScreenProgress"] = {true, true};
+    mIntMap["ScraperFilter"] = {0, 0};
 }
 
 template <typename K, typename V>
diff --git a/es-core/src/ThemeData.cpp b/es-core/src/ThemeData.cpp
index 6bf6cda30..2af478067 100644
--- a/es-core/src/ThemeData.cpp
+++ b/es-core/src/ThemeData.cpp
@@ -21,178 +21,175 @@
 #include <algorithm>
 #include <pugixml.hpp>
 
-std::vector<std::string> ThemeData::sSupportedViews { { "all" },      { "system" }, { "basic" },
-                                                      { "detailed" }, { "grid" },   { "video" } };
-std::vector<std::string> ThemeData::sSupportedFeatures {
-    { "navigationsounds" }, { "video" }, { "carousel" }, { "z-index" }, { "visible" }
-};
+std::vector<std::string> ThemeData::sSupportedViews{{"all"},      {"system"}, {"basic"},
+                                                    {"detailed"}, {"grid"},   {"video"}};
+std::vector<std::string> ThemeData::sSupportedFeatures{
+    {"navigationsounds"}, {"video"}, {"carousel"}, {"z-index"}, {"visible"}};
 
-std::map<std::string, std::map<std::string, ThemeData::ElementPropertyType>>
-    ThemeData::sElementMap {
-        { "image",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "maxSize", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "rotation", FLOAT },
-            { "rotationOrigin", NORMALIZED_PAIR },
-            { "path", PATH },
-            { "default", PATH },
-            { "tile", BOOLEAN },
-            { "color", COLOR },
-            { "colorEnd", COLOR },
-            { "gradientType", STRING },
-            { "visible", BOOLEAN },
-            { "zIndex", FLOAT } } },
-        { "imagegrid",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "margin", NORMALIZED_PAIR },
-            { "padding", NORMALIZED_RECT },
-            { "autoLayout", NORMALIZED_PAIR },
-            { "autoLayoutSelectedZoom", FLOAT },
-            { "gameImage", PATH },
-            { "folderImage", PATH },
-            { "imageSource", STRING },
-            { "scrollDirection", STRING },
-            { "centerSelection", BOOLEAN },
-            { "scrollLoop", BOOLEAN },
-            { "animate", BOOLEAN },
-            { "zIndex", FLOAT } } },
-        { "gridtile",
-          { { "size", NORMALIZED_PAIR },
-            { "padding", NORMALIZED_PAIR },
-            { "imageColor", COLOR },
-            { "backgroundImage", PATH },
-            { "backgroundCornerSize", NORMALIZED_PAIR },
-            { "backgroundColor", COLOR },
-            { "backgroundCenterColor", COLOR },
-            { "backgroundEdgeColor", COLOR } } },
-        { "text",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "rotation", FLOAT },
-            { "rotationOrigin", NORMALIZED_PAIR },
-            { "text", STRING },
-            { "backgroundColor", COLOR },
-            { "fontPath", PATH },
-            { "fontSize", FLOAT },
-            { "color", COLOR },
-            { "alignment", STRING },
-            { "forceUppercase", BOOLEAN },
-            { "lineSpacing", FLOAT },
-            { "value", STRING },
-            { "visible", BOOLEAN },
-            { "zIndex", FLOAT } } },
-        { "textlist",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "selectorHeight", FLOAT },
-            { "selectorOffsetY", FLOAT },
-            { "selectorColor", COLOR },
-            { "selectorColorEnd", COLOR },
-            { "selectorGradientType", STRING },
-            { "selectorImagePath", PATH },
-            { "selectorImageTile", BOOLEAN },
-            { "selectedColor", COLOR },
-            { "primaryColor", COLOR },
-            { "secondaryColor", COLOR },
-            { "fontPath", PATH },
-            { "fontSize", FLOAT },
-            { "scrollSound", PATH }, // For backward compatibility with old themes.
-            { "alignment", STRING },
-            { "horizontalMargin", FLOAT },
-            { "forceUppercase", BOOLEAN },
-            { "lineSpacing", FLOAT },
-            { "zIndex", FLOAT } } },
-        { "container",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "visible", BOOLEAN },
-            { "zIndex", FLOAT } } },
-        { "ninepatch",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "path", PATH },
-            { "visible", BOOLEAN },
-            { "zIndex", FLOAT } } },
-        { "datetime",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "rotation", FLOAT },
-            { "rotationOrigin", NORMALIZED_PAIR },
-            { "backgroundColor", COLOR },
-            { "fontPath", PATH },
-            { "fontSize", FLOAT },
-            { "color", COLOR },
-            { "alignment", STRING },
-            { "forceUppercase", BOOLEAN },
-            { "lineSpacing", FLOAT },
-            { "value", STRING },
-            { "format", STRING },
-            { "displayRelative", BOOLEAN },
-            { "visible", BOOLEAN },
-            { "zIndex", FLOAT } } },
-        { "rating",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "rotation", FLOAT },
-            { "rotationOrigin", NORMALIZED_PAIR },
-            { "color", COLOR },
-            { "filledPath", PATH },
-            { "unfilledPath", PATH },
-            { "visible", BOOLEAN },
-            { "zIndex", FLOAT } } },
-        { "sound", { { "path", PATH } } },
-        { "helpsystem",
-          { { "pos", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "textColor", COLOR },
-            { "iconColor", COLOR },
-            { "fontPath", PATH },
-            { "fontSize", FLOAT } } },
-        { "navigationsounds",
-          { { "systembrowseSound", PATH },
-            { "quicksysselectSound", PATH },
-            { "selectSound", PATH },
-            { "backSound", PATH },
-            { "scrollSound", PATH },
-            { "favoriteSound", PATH },
-            { "launchSound", PATH } } },
-        { "video",
-          { { "pos", NORMALIZED_PAIR },
-            { "size", NORMALIZED_PAIR },
-            { "maxSize", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "rotation", FLOAT },
-            { "rotationOrigin", NORMALIZED_PAIR },
-            { "default", PATH },
-            { "delay", FLOAT },
-            { "visible", BOOLEAN },
-            { "zIndex", FLOAT },
-            { "showSnapshotNoVideo", BOOLEAN },
-            { "showSnapshotDelay", BOOLEAN } } },
-        { "carousel",
-          { { "type", STRING },
-            { "size", NORMALIZED_PAIR },
-            { "pos", NORMALIZED_PAIR },
-            { "origin", NORMALIZED_PAIR },
-            { "color", COLOR },
-            { "colorEnd", COLOR },
-            { "gradientType", STRING },
-            { "logoScale", FLOAT },
-            { "logoRotation", FLOAT },
-            { "logoRotationOrigin", NORMALIZED_PAIR },
-            { "logoSize", NORMALIZED_PAIR },
-            { "logoAlignment", STRING },
-            { "maxLogoCount", FLOAT },
-            { "zIndex", FLOAT } } }
-    };
+std::map<std::string, std::map<std::string, ThemeData::ElementPropertyType>> ThemeData::sElementMap{
+    {"image",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"maxSize", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"rotation", FLOAT},
+      {"rotationOrigin", NORMALIZED_PAIR},
+      {"path", PATH},
+      {"default", PATH},
+      {"tile", BOOLEAN},
+      {"color", COLOR},
+      {"colorEnd", COLOR},
+      {"gradientType", STRING},
+      {"visible", BOOLEAN},
+      {"zIndex", FLOAT}}},
+    {"imagegrid",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"margin", NORMALIZED_PAIR},
+      {"padding", NORMALIZED_RECT},
+      {"autoLayout", NORMALIZED_PAIR},
+      {"autoLayoutSelectedZoom", FLOAT},
+      {"gameImage", PATH},
+      {"folderImage", PATH},
+      {"imageSource", STRING},
+      {"scrollDirection", STRING},
+      {"centerSelection", BOOLEAN},
+      {"scrollLoop", BOOLEAN},
+      {"animate", BOOLEAN},
+      {"zIndex", FLOAT}}},
+    {"gridtile",
+     {{"size", NORMALIZED_PAIR},
+      {"padding", NORMALIZED_PAIR},
+      {"imageColor", COLOR},
+      {"backgroundImage", PATH},
+      {"backgroundCornerSize", NORMALIZED_PAIR},
+      {"backgroundColor", COLOR},
+      {"backgroundCenterColor", COLOR},
+      {"backgroundEdgeColor", COLOR}}},
+    {"text",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"rotation", FLOAT},
+      {"rotationOrigin", NORMALIZED_PAIR},
+      {"text", STRING},
+      {"backgroundColor", COLOR},
+      {"fontPath", PATH},
+      {"fontSize", FLOAT},
+      {"color", COLOR},
+      {"alignment", STRING},
+      {"forceUppercase", BOOLEAN},
+      {"lineSpacing", FLOAT},
+      {"value", STRING},
+      {"visible", BOOLEAN},
+      {"zIndex", FLOAT}}},
+    {"textlist",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"selectorHeight", FLOAT},
+      {"selectorOffsetY", FLOAT},
+      {"selectorColor", COLOR},
+      {"selectorColorEnd", COLOR},
+      {"selectorGradientType", STRING},
+      {"selectorImagePath", PATH},
+      {"selectorImageTile", BOOLEAN},
+      {"selectedColor", COLOR},
+      {"primaryColor", COLOR},
+      {"secondaryColor", COLOR},
+      {"fontPath", PATH},
+      {"fontSize", FLOAT},
+      {"scrollSound", PATH}, // For backward compatibility with old themes.
+      {"alignment", STRING},
+      {"horizontalMargin", FLOAT},
+      {"forceUppercase", BOOLEAN},
+      {"lineSpacing", FLOAT},
+      {"zIndex", FLOAT}}},
+    {"container",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"visible", BOOLEAN},
+      {"zIndex", FLOAT}}},
+    {"ninepatch",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"path", PATH},
+      {"visible", BOOLEAN},
+      {"zIndex", FLOAT}}},
+    {"datetime",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"rotation", FLOAT},
+      {"rotationOrigin", NORMALIZED_PAIR},
+      {"backgroundColor", COLOR},
+      {"fontPath", PATH},
+      {"fontSize", FLOAT},
+      {"color", COLOR},
+      {"alignment", STRING},
+      {"forceUppercase", BOOLEAN},
+      {"lineSpacing", FLOAT},
+      {"value", STRING},
+      {"format", STRING},
+      {"displayRelative", BOOLEAN},
+      {"visible", BOOLEAN},
+      {"zIndex", FLOAT}}},
+    {"rating",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"rotation", FLOAT},
+      {"rotationOrigin", NORMALIZED_PAIR},
+      {"color", COLOR},
+      {"filledPath", PATH},
+      {"unfilledPath", PATH},
+      {"visible", BOOLEAN},
+      {"zIndex", FLOAT}}},
+    {"sound", {{"path", PATH}}},
+    {"helpsystem",
+     {{"pos", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"textColor", COLOR},
+      {"iconColor", COLOR},
+      {"fontPath", PATH},
+      {"fontSize", FLOAT}}},
+    {"navigationsounds",
+     {{"systembrowseSound", PATH},
+      {"quicksysselectSound", PATH},
+      {"selectSound", PATH},
+      {"backSound", PATH},
+      {"scrollSound", PATH},
+      {"favoriteSound", PATH},
+      {"launchSound", PATH}}},
+    {"video",
+     {{"pos", NORMALIZED_PAIR},
+      {"size", NORMALIZED_PAIR},
+      {"maxSize", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"rotation", FLOAT},
+      {"rotationOrigin", NORMALIZED_PAIR},
+      {"default", PATH},
+      {"delay", FLOAT},
+      {"visible", BOOLEAN},
+      {"zIndex", FLOAT},
+      {"showSnapshotNoVideo", BOOLEAN},
+      {"showSnapshotDelay", BOOLEAN}}},
+    {"carousel",
+     {{"type", STRING},
+      {"size", NORMALIZED_PAIR},
+      {"pos", NORMALIZED_PAIR},
+      {"origin", NORMALIZED_PAIR},
+      {"color", COLOR},
+      {"colorEnd", COLOR},
+      {"gradientType", STRING},
+      {"logoScale", FLOAT},
+      {"logoRotation", FLOAT},
+      {"logoRotationOrigin", NORMALIZED_PAIR},
+      {"logoSize", NORMALIZED_PAIR},
+      {"logoAlignment", STRING},
+      {"maxLogoCount", FLOAT},
+      {"zIndex", FLOAT}}}};
 
 #define MINIMUM_THEME_FORMAT_VERSION 3
 #define CURRENT_THEME_FORMAT_VERSION 6
@@ -454,16 +451,16 @@ void ThemeData::parseElement(const pugi::xml_node& root,
 
                 auto splits = Utils::String::delimitedStringToVector(str, " ");
                 if (splits.size() == 2) {
-                    val = glm::vec4(static_cast<float>(atof(splits.at(0).c_str())),
+                    val = glm::vec4{static_cast<float>(atof(splits.at(0).c_str())),
                                     static_cast<float>(atof(splits.at(1).c_str())),
                                     static_cast<float>(atof(splits.at(0).c_str())),
-                                    static_cast<float>(atof(splits.at(1).c_str())));
+                                    static_cast<float>(atof(splits.at(1).c_str()))};
                 }
                 else if (splits.size() == 4) {
-                    val = glm::vec4(static_cast<float>(atof(splits.at(0).c_str())),
+                    val = glm::vec4{static_cast<float>(atof(splits.at(0).c_str())),
                                     static_cast<float>(atof(splits.at(1).c_str())),
                                     static_cast<float>(atof(splits.at(2).c_str())),
-                                    static_cast<float>(atof(splits.at(3).c_str())));
+                                    static_cast<float>(atof(splits.at(3).c_str()))};
                 }
 
                 element.properties[node.name()] = val;
@@ -475,11 +472,11 @@ void ThemeData::parseElement(const pugi::xml_node& root,
                     throw error << "invalid normalized pair (property \"" << node.name()
                                 << "\", value \"" << str.c_str() << "\")";
 
-                std::string first = str.substr(0, divider);
-                std::string second = str.substr(divider, std::string::npos);
+                std::string first{str.substr(0, divider)};
+                std::string second{str.substr(divider, std::string::npos)};
 
-                glm::vec2 val(static_cast<float>(atof(first.c_str())),
-                              static_cast<float>(atof(second.c_str())));
+                glm::vec2 val{static_cast<float>(atof(first.c_str())),
+                              static_cast<float>(atof(second.c_str()))};
 
                 element.properties[node.name()] = val;
                 break;
@@ -643,7 +640,7 @@ std::map<std::string, ThemeSet> ThemeData::getThemeSets()
         for (Utils::FileSystem::stringList::const_iterator it = dirContent.cbegin();
              it != dirContent.cend(); it++) {
             if (Utils::FileSystem::isDirectory(*it)) {
-                ThemeSet set = { *it };
+                ThemeSet set = {*it};
                 sets[set.getName()] = set;
             }
         }
diff --git a/es-core/src/ThemeData.h b/es-core/src/ThemeData.h
index 5c2e41dac..70f3193a1 100644
--- a/es-core/src/ThemeData.h
+++ b/es-core/src/ThemeData.h
@@ -105,8 +105,8 @@ public:
             void operator=(const glm::vec4& value)
             {
                 r = value;
-                const glm::vec4 initVector = value;
-                v = glm::vec2(initVector.x, initVector.y);
+                const glm::vec4 initVector{value};
+                v = glm::vec2{initVector.x, initVector.y};
             }
             void operator=(const glm::vec2& value) { v = value; }
             void operator=(const std::string& value) { s = value; }
diff --git a/es-core/src/Window.cpp b/es-core/src/Window.cpp
index 84fa29c33..352ba08f5 100644
--- a/es-core/src/Window.cpp
+++ b/es-core/src/Window.cpp
@@ -349,7 +349,7 @@ void Window::update(int deltaTime)
 
 void Window::render()
 {
-    glm::mat4 trans = Renderer::getIdentity();
+    glm::mat4 trans{Renderer::getIdentity()};
 
     mRenderedHelpPrompts = false;
 
@@ -475,9 +475,9 @@ void Window::render()
             if (Settings::getInstance()->getString("MenuOpeningEffect") == "scale-up") {
                 if (mTopScale < 1.0f) {
                     mTopScale = Math::clamp(mTopScale + 0.07f, 0.0f, 1.0f);
-                    glm::vec2 topCenter = top->getCenter();
-                    top->setOrigin({ 0.5f, 0.5f });
-                    top->setPosition({ topCenter.x, topCenter.y, 0.0f });
+                    glm::vec2 topCenter{top->getCenter()};
+                    top->setOrigin({0.5f, 0.5f});
+                    top->setPosition({topCenter.x, topCenter.y, 0.0f});
                     top->setScale(mTopScale);
                 }
             }
@@ -499,7 +499,7 @@ void Window::render()
                            static_cast<float>(Renderer::getScreenHeight()),
                            0x00000000 | mListScrollOpacity, 0x00000000 | mListScrollOpacity);
 
-        glm::vec2 offset = mListScrollFont->sizeText(mListScrollText);
+        glm::vec2 offset{mListScrollFont->sizeText(mListScrollText)};
         offset.x = (Renderer::getScreenWidth() - offset.x) * 0.5f;
         offset.y = (Renderer::getScreenHeight() - offset.y) * 0.5f;
 
@@ -558,7 +558,7 @@ void Window::render()
 
 void Window::renderLoadingScreen(std::string text)
 {
-    glm::mat4 trans = Renderer::getIdentity();
+    glm::mat4 trans{Renderer::getIdentity()};
     Renderer::setMatrix(trans);
     Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
                        static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
@@ -575,7 +575,7 @@ void Window::renderLoadingScreen(std::string text)
 
     float x = std::round((Renderer::getScreenWidth() - cache->metrics.size.x) / 2.0f);
     float y = std::round(Renderer::getScreenHeight() * 0.835f);
-    trans = glm::translate(trans, glm::vec3(x, y, 0.0f));
+    trans = glm::translate(trans, glm::vec3{x, y, 0.0f});
     Renderer::setMatrix(trans);
     font->renderTextCache(cache);
     delete cache;
@@ -634,17 +634,17 @@ void Window::setHelpPrompts(const std::vector<HelpPrompt>& prompts, const HelpSt
     // Sort prompts so it goes [dpad_all] [dpad_u/d] [dpad_l/r] [a/b/x/y/l/r] [start/back].
     std::sort(addPrompts.begin(), addPrompts.end(),
               [](const HelpPrompt& a, const HelpPrompt& b) -> bool {
-                  static const std::vector<std::string> map = { "up/down/left/right",
-                                                                "up/down",
-                                                                "left/right",
-                                                                "a",
-                                                                "b",
-                                                                "x",
-                                                                "y",
-                                                                "l",
-                                                                "r",
-                                                                "start",
-                                                                "back" };
+                  static const std::vector<std::string> map = {"up/down/left/right",
+                                                               "up/down",
+                                                               "left/right",
+                                                               "a",
+                                                               "b",
+                                                               "x",
+                                                               "y",
+                                                               "l",
+                                                               "r",
+                                                               "start",
+                                                               "back"};
                   int i = 0;
                   int aVal = 0;
                   int bVal = 0;
diff --git a/es-core/src/components/BusyComponent.cpp b/es-core/src/components/BusyComponent.cpp
index f0db6f0be..4c66ac453 100644
--- a/es-core/src/components/BusyComponent.cpp
+++ b/es-core/src/components/BusyComponent.cpp
@@ -14,18 +14,18 @@
 
 // Animation definition.
 AnimationFrame BUSY_ANIMATION_FRAMES[] = {
-    { ":/graphics/busy_0.svg", 300 },
-    { ":/graphics/busy_1.svg", 300 },
-    { ":/graphics/busy_2.svg", 300 },
-    { ":/graphics/busy_3.svg", 300 },
+    {":/graphics/busy_0.svg", 300},
+    {":/graphics/busy_1.svg", 300},
+    {":/graphics/busy_2.svg", 300},
+    {":/graphics/busy_3.svg", 300},
 };
 
-const AnimationDef BUSY_ANIMATION_DEF = { BUSY_ANIMATION_FRAMES, 4, true };
+const AnimationDef BUSY_ANIMATION_DEF = {BUSY_ANIMATION_FRAMES, 4, true};
 
 BusyComponent::BusyComponent(Window* window)
     : GuiComponent(window)
     , mBackground(window, ":/graphics/frame.png")
-    , mGrid(window, Vector2i(5, 3))
+    , mGrid(window, glm::ivec2{5, 3})
 {
     mAnimation = std::make_shared<AnimatedImageComponent>(mWindow);
     mAnimation->load(&BUSY_ANIMATION_DEF);
@@ -33,8 +33,8 @@ BusyComponent::BusyComponent(Window* window)
                                             0x777777FF);
 
     // Col 0 = animation, col 1 = spacer, col 2 = text.
-    mGrid.setEntry(mAnimation, Vector2i(1, 1), false, true);
-    mGrid.setEntry(mText, Vector2i(3, 1), false, true);
+    mGrid.setEntry(mAnimation, glm::ivec2{1, 1}, false, true);
+    mGrid.setEntry(mText, glm::ivec2{3, 1}, false, true);
 
     addChild(&mBackground);
     addChild(&mGrid);
@@ -58,11 +58,11 @@ void BusyComponent::onSizeChanged()
 
     mGrid.setRowHeightPerc(1, textHeight / mSize.y);
 
-    mBackground.setCornerSize({ 16.0f * Renderer::getScreenWidthModifier(),
-                                16.0f * Renderer::getScreenHeightModifier() });
-    mBackground.fitTo(glm::vec2(mGrid.getColWidth(1) + mGrid.getColWidth(2) + mGrid.getColWidth(3),
-                                textHeight + (2.0f * Renderer::getScreenHeightModifier())),
-                      mAnimation->getPosition(), glm::vec2(0.0f, 0.0f));
+    mBackground.setCornerSize(
+        {16.0f * Renderer::getScreenWidthModifier(), 16.0f * Renderer::getScreenHeightModifier()});
+    mBackground.fitTo(glm::vec2{mGrid.getColWidth(1) + mGrid.getColWidth(2) + mGrid.getColWidth(3),
+                                textHeight + (2.0f * Renderer::getScreenHeightModifier())},
+                      mAnimation->getPosition(), glm::vec2{});
 }
 
 void BusyComponent::reset()
diff --git a/es-core/src/components/ButtonComponent.cpp b/es-core/src/components/ButtonComponent.cpp
index 81c7eb929..6ba641495 100644
--- a/es-core/src/components/ButtonComponent.cpp
+++ b/es-core/src/components/ButtonComponent.cpp
@@ -32,7 +32,7 @@ ButtonComponent::ButtonComponent(Window* window,
 void ButtonComponent::onSizeChanged()
 {
     // Fit to mBox.
-    mBox.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBox.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 }
 
 bool ButtonComponent::input(InputConfig* config, Input input)
@@ -95,13 +95,13 @@ void ButtonComponent::updateImage()
 
 void ButtonComponent::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     mBox.render(trans);
 
     if (mTextCache) {
-        glm::vec3 centerOffset((mSize.x - mTextCache->metrics.size.x) / 2.0f,
-                               (mSize.y - mTextCache->metrics.size.y) / 2.0f, 0.0f);
+        glm::vec3 centerOffset{(mSize.x - mTextCache->metrics.size.x) / 2.0f,
+                               (mSize.y - mTextCache->metrics.size.y) / 2.0f, 0.0f};
         trans = glm::translate(trans, centerOffset);
 
         if (Settings::getInstance()->getBool("DebugText")) {
diff --git a/es-core/src/components/ComponentGrid.cpp b/es-core/src/components/ComponentGrid.cpp
index 616804cea..496cda1fd 100644
--- a/es-core/src/components/ComponentGrid.cpp
+++ b/es-core/src/components/ComponentGrid.cpp
@@ -12,21 +12,21 @@
 
 using namespace GridFlags;
 
-ComponentGrid::ComponentGrid(Window* window, const Vector2i& gridDimensions)
+ComponentGrid::ComponentGrid(Window* window, const glm::ivec2& gridDimensions)
     : GuiComponent(window)
     , mGridSize(gridDimensions)
     , mCursor(0, 0)
 {
-    assert(gridDimensions.x() > 0 && gridDimensions.y() > 0);
+    assert(gridDimensions.x > 0 && gridDimensions.y > 0);
 
-    mCells.reserve(gridDimensions.x() * gridDimensions.y());
+    mCells.reserve(gridDimensions.x * gridDimensions.y);
 
-    mColWidths = new float[gridDimensions.x()];
-    mRowHeights = new float[gridDimensions.y()];
+    mColWidths = new float[gridDimensions.x];
+    mRowHeights = new float[gridDimensions.y];
 
-    for (int x = 0; x < gridDimensions.x(); x++)
+    for (int x = 0; x < gridDimensions.x; x++)
         mColWidths[x] = 0;
-    for (int y = 0; y < gridDimensions.y(); y++)
+    for (int y = 0; y < gridDimensions.y; y++)
         mRowHeights[y] = 0;
 }
 
@@ -44,7 +44,7 @@ float ComponentGrid::getColWidth(int col)
     // Calculate automatic width.
     float freeWidthPerc = 1;
     int between = 0;
-    for (int x = 0; x < mGridSize.x(); x++) {
+    for (int x = 0; x < mGridSize.x; x++) {
         freeWidthPerc -= mColWidths[x]; // If it's 0 it won't do anything.
         if (mColWidths[x] == 0)
             between++;
@@ -61,7 +61,7 @@ float ComponentGrid::getRowHeight(int row)
     // Calculate automatic height.
     float freeHeightPerc = 1;
     int between = 0;
-    for (int y = 0; y < mGridSize.y(); y++) {
+    for (int y = 0; y < mGridSize.y; y++) {
         freeHeightPerc -= mRowHeights[y]; // If it's 0 it won't do anything.
         if (mRowHeights[y] == 0)
             between++;
@@ -72,7 +72,7 @@ float ComponentGrid::getRowHeight(int row)
 
 void ComponentGrid::setColWidthPerc(int col, float width, bool update)
 {
-    assert(col >= 0 && col < mGridSize.x());
+    assert(col >= 0 && col < mGridSize.x);
     mColWidths[col] = width;
 
     if (update)
@@ -82,7 +82,7 @@ void ComponentGrid::setColWidthPerc(int col, float width, bool update)
 void ComponentGrid::setRowHeightPerc(int row, float height, bool update)
 {
     assert(height >= 0 && height <= 1);
-    assert(row >= 0 && row < mGridSize.y());
+    assert(row >= 0 && row < mGridSize.y);
     mRowHeights[row] = height;
 
     if (update)
@@ -90,14 +90,14 @@ void ComponentGrid::setRowHeightPerc(int row, float height, bool update)
 }
 
 void ComponentGrid::setEntry(const std::shared_ptr<GuiComponent>& comp,
-                             const Vector2i& pos,
+                             const glm::ivec2& pos,
                              bool canFocus,
                              bool resize,
-                             const Vector2i& size,
+                             const glm::ivec2& size,
                              unsigned int border,
                              GridFlags::UpdateType updateType)
 {
-    assert(pos.x() >= 0 && pos.x() < mGridSize.x() && pos.y() >= 0 && pos.y() < mGridSize.y());
+    assert(pos.x >= 0 && pos.x < mGridSize.x && pos.y >= 0 && pos.y < mGridSize.y);
     assert(comp != nullptr);
     assert(comp->getParent() == nullptr);
 
@@ -132,20 +132,20 @@ bool ComponentGrid::removeEntry(const std::shared_ptr<GuiComponent>& comp)
 void ComponentGrid::updateCellComponent(const GridEntry& cell)
 {
     // Size.
-    glm::vec2 size(0.0f, 0.0f);
-    for (int x = cell.pos.x(); x < cell.pos.x() + cell.dim.x(); x++)
+    glm::vec2 size{0.0f};
+    for (int x = cell.pos.x; x < cell.pos.x + cell.dim.x; x++)
         size.x += getColWidth(x);
-    for (int y = cell.pos.y(); y < cell.pos.y() + cell.dim.y(); y++)
+    for (int y = cell.pos.y; y < cell.pos.y + cell.dim.y; y++)
         size.y += getRowHeight(y);
 
     if (cell.resize)
         cell.component->setSize(size);
 
     // Find top left corner.
-    glm::vec3 pos {};
-    for (int x = 0; x < cell.pos.x(); x++)
+    glm::vec3 pos{};
+    for (int x = 0; x < cell.pos.x; x++)
         pos.x += getColWidth(x);
-    for (int y = 0; y < cell.pos.y(); y++)
+    for (int y = 0; y < cell.pos.y; y++)
         pos.y += getRowHeight(y);
 
     // Center component.
@@ -169,18 +169,18 @@ void ComponentGrid::updateSeparators()
             continue;
 
         // Find component position + size.
-        pos = glm::vec2(0.0f, 0.0f);
-        size = glm::vec2(0.0f, 0.0f);
-        for (int x = 0; x < it->pos.x(); x++)
+        pos = glm::vec2{};
+        size = glm::vec2{};
+        for (int x = 0; x < it->pos.x; x++)
             pos[0] += getColWidth(x);
-        for (int y = 0; y < it->pos.y(); y++)
+        for (int y = 0; y < it->pos.y; y++)
             pos[1] += getRowHeight(y);
-        for (int x = it->pos.x(); x < it->pos.x() + it->dim.x(); x++)
+        for (int x = it->pos.x; x < it->pos.x + it->dim.x; x++)
             size[0] += getColWidth(x);
-        for (int y = it->pos.y(); y < it->pos.y() + it->dim.y(); y++)
+        for (int y = it->pos.y; y < it->pos.y + it->dim.y; y++)
             size[1] += getRowHeight(y);
 
-        if (size == glm::vec2({}))
+        if (size == glm::vec2{})
             return;
 
         if (it->border & BORDER_TOP || drawAll) {
@@ -228,13 +228,13 @@ void ComponentGrid::onSizeChanged()
 
 const ComponentGrid::GridEntry* ComponentGrid::getCellAt(int x, int y) const
 {
-    assert(x >= 0 && x < mGridSize.x() && y >= 0 && y < mGridSize.y());
+    assert(x >= 0 && x < mGridSize.x && y >= 0 && y < mGridSize.y);
 
     for (auto it = mCells.cbegin(); it != mCells.cend(); it++) {
-        int xmin = it->pos.x();
-        int xmax = xmin + it->dim.x();
-        int ymin = it->pos.y();
-        int ymax = ymin + it->dim.y();
+        int xmin = it->pos.x;
+        int xmax = xmin + it->dim.x;
+        int ymin = it->pos.y;
+        int ymax = ymin + it->dim.y;
 
         if (x >= xmin && y >= ymin && x < xmax && y < ymax)
             return &(*it);
@@ -253,16 +253,16 @@ bool ComponentGrid::input(InputConfig* config, Input input)
         return false;
 
     if (config->isMappedLike("down", input))
-        return moveCursor(Vector2i(0, 1));
+        return moveCursor(glm::ivec2{0, 1});
 
     if (config->isMappedLike("up", input))
-        return moveCursor(Vector2i(0, -1));
+        return moveCursor(glm::ivec2{0, -1});
 
     if (config->isMappedLike("left", input))
-        return moveCursor(Vector2i(-1, 0));
+        return moveCursor(glm::ivec2{-1, 0});
 
     if (config->isMappedLike("right", input))
-        return moveCursor(Vector2i(1, 0));
+        return moveCursor(glm::ivec2{1, 0});
 
     return false;
 }
@@ -274,7 +274,7 @@ void ComponentGrid::resetCursor()
 
     for (auto it = mCells.cbegin(); it != mCells.cend(); it++) {
         if (it->canFocus) {
-            Vector2i origCursor = mCursor;
+            glm::ivec2 origCursor = mCursor;
             mCursor = it->pos;
             onCursorMoved(origCursor, mCursor);
             break;
@@ -282,23 +282,22 @@ void ComponentGrid::resetCursor()
     }
 }
 
-bool ComponentGrid::moveCursor(Vector2i dir)
+bool ComponentGrid::moveCursor(glm::ivec2 dir)
 {
-    assert(dir.x() || dir.y());
+    assert(dir.x || dir.y);
 
-    const Vector2i origCursor = mCursor;
+    const glm::ivec2 origCursor{mCursor};
     const GridEntry* currentCursorEntry = getCellAt(mCursor);
-    Vector2i searchAxis(dir.x() == 0, dir.y() == 0);
+    glm::ivec2 searchAxis(dir.x == 0, dir.y == 0);
 
-    while (mCursor.x() >= 0 && mCursor.y() >= 0 && mCursor.x() < mGridSize.x() &&
-           mCursor.y() < mGridSize.y()) {
+    while (mCursor.x >= 0 && mCursor.y >= 0 && mCursor.x < mGridSize.x && mCursor.y < mGridSize.y) {
         mCursor = mCursor + dir;
-        Vector2i curDirPos = mCursor;
+        glm::ivec2 curDirPos{mCursor};
         const GridEntry* cursorEntry;
 
         // Spread out on search axis+
-        while (mCursor.x() < mGridSize.x() && mCursor.y() < mGridSize.y() && mCursor.x() >= 0 &&
-               mCursor.y() >= 0) {
+        while (mCursor.x < mGridSize.x && mCursor.y < mGridSize.y && mCursor.x >= 0 &&
+               mCursor.y >= 0) {
             cursorEntry = getCellAt(mCursor);
             if (cursorEntry && cursorEntry->canFocus && cursorEntry != currentCursorEntry) {
                 onCursorMoved(origCursor, mCursor);
@@ -309,8 +308,8 @@ bool ComponentGrid::moveCursor(Vector2i dir)
 
         // Now again on search axis-
         mCursor = curDirPos;
-        while (mCursor.x() >= 0 && mCursor.y() >= 0 && mCursor.x() < mGridSize.x() &&
-               mCursor.y() < mGridSize.y()) {
+        while (mCursor.x >= 0 && mCursor.y >= 0 && mCursor.x < mGridSize.x &&
+               mCursor.y < mGridSize.y) {
             cursorEntry = getCellAt(mCursor);
 
             if (cursorEntry && cursorEntry->canFocus && cursorEntry != currentCursorEntry) {
@@ -361,7 +360,7 @@ void ComponentGrid::update(int deltaTime)
 
 void ComponentGrid::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     renderChildren(trans);
 
@@ -380,7 +379,7 @@ void ComponentGrid::textInput(const std::string& text)
         selectedEntry->component->textInput(text);
 }
 
-void ComponentGrid::onCursorMoved(Vector2i from, Vector2i to)
+void ComponentGrid::onCursorMoved(glm::ivec2 from, glm::ivec2 to)
 {
     const GridEntry* cell = getCellAt(from);
     if (cell)
@@ -397,7 +396,7 @@ void ComponentGrid::setCursorTo(const std::shared_ptr<GuiComponent>& comp)
 {
     for (auto it = mCells.cbegin(); it != mCells.cend(); it++) {
         if (it->component == comp) {
-            Vector2i oldCursor = mCursor;
+            glm::ivec2 oldCursor{mCursor};
             mCursor = it->pos;
             onCursorMoved(oldCursor, mCursor);
             return;
@@ -415,8 +414,8 @@ std::vector<HelpPrompt> ComponentGrid::getHelpPrompts()
     if (e)
         prompts = e->component->getHelpPrompts();
 
-    bool canScrollVert = mGridSize.y() > 1;
-    bool canScrollHoriz = mGridSize.x() > 1;
+    bool canScrollVert = mGridSize.y > 1;
+    bool canScrollHoriz = mGridSize.x > 1;
     for (auto it = prompts.cbegin(); it != prompts.cend(); it++) {
         if (it->first == "up/down/left/right") {
             canScrollHoriz = false;
diff --git a/es-core/src/components/ComponentGrid.h b/es-core/src/components/ComponentGrid.h
index 8d0b8a86a..c52e8271a 100644
--- a/es-core/src/components/ComponentGrid.h
+++ b/es-core/src/components/ComponentGrid.h
@@ -10,7 +10,6 @@
 #define ES_CORE_COMPONENTS_COMPONENT_GRID_H
 
 #include "GuiComponent.h"
-#include "math/Vector2i.h"
 #include "renderers/Renderer.h"
 
 namespace GridFlags
@@ -34,16 +33,16 @@ namespace GridFlags
 class ComponentGrid : public GuiComponent
 {
 public:
-    ComponentGrid(Window* window, const Vector2i& gridDimensions);
+    ComponentGrid(Window* window, const glm::ivec2& gridDimensions);
     virtual ~ComponentGrid();
 
     bool removeEntry(const std::shared_ptr<GuiComponent>& comp);
 
     void setEntry(const std::shared_ptr<GuiComponent>& comp,
-                  const Vector2i& pos,
+                  const glm::ivec2& pos,
                   bool canFocus,
                   bool resize = true,
-                  const Vector2i& size = Vector2i(1, 1),
+                  const glm::ivec2& size = glm::ivec2{1, 1},
                   unsigned int border = GridFlags::BORDER_NONE,
                   GridFlags::UpdateType updateType = GridFlags::UPDATE_ALWAYS);
 
@@ -65,7 +64,7 @@ public:
     // Dito.
     void setRowHeightPerc(int row, float height, bool update = true);
 
-    bool moveCursor(Vector2i dir);
+    bool moveCursor(glm::ivec2 dir);
     void setCursorTo(const std::shared_ptr<GuiComponent>& comp);
 
     std::shared_ptr<GuiComponent> getSelectedComponent()
@@ -86,16 +85,16 @@ private:
     class GridEntry
     {
     public:
-        Vector2i pos;
-        Vector2i dim;
+        glm::ivec2 pos;
+        glm::ivec2 dim;
         std::shared_ptr<GuiComponent> component;
         bool canFocus;
         bool resize;
         GridFlags::UpdateType updateType;
         unsigned int border;
 
-        GridEntry(const Vector2i& p = Vector2i::Zero(),
-                  const Vector2i& d = Vector2i::Zero(),
+        GridEntry(const glm::ivec2& p = glm::ivec2{},
+                  const glm::ivec2& d = glm::ivec2{},
                   const std::shared_ptr<GuiComponent>& cmp = nullptr,
                   bool f = false,
                   bool r = true,
@@ -118,14 +117,14 @@ private:
     void updateCellComponent(const GridEntry& cell);
     void updateSeparators();
 
-    void onCursorMoved(Vector2i from, Vector2i to);
+    void onCursorMoved(glm::ivec2 from, glm::ivec2 to);
     const GridEntry* getCellAt(int x, int y) const;
-    const GridEntry* getCellAt(const Vector2i& pos) const { return getCellAt(pos.x(), pos.y()); }
+    const GridEntry* getCellAt(const glm::ivec2& pos) const { return getCellAt(pos.x, pos.y); }
 
     std::vector<std::vector<float>> mSeparators;
-    Vector2i mGridSize;
+    glm::ivec2 mGridSize;
     std::vector<GridEntry> mCells;
-    Vector2i mCursor;
+    glm::ivec2 mCursor;
 
     float* mRowHeights;
     float* mColWidths;
diff --git a/es-core/src/components/ComponentList.cpp b/es-core/src/components/ComponentList.cpp
index 948e193bd..ab58e661e 100644
--- a/es-core/src/components/ComponentList.cpp
+++ b/es-core/src/components/ComponentList.cpp
@@ -172,20 +172,20 @@ void ComponentList::render(const glm::mat4& parentTrans)
     if (!size())
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     // Clip everything to be inside our bounds.
-    glm::vec3 dim(mSize.x, mSize.y, 0.0f);
+    glm::vec3 dim{mSize.x, mSize.y, 0.0f};
     dim.x = (trans[0].x * dim.x + trans[3].x) - trans[3].x;
     dim.y = (trans[1].y * dim.y + trans[3].y) - trans[3].y;
 
     Renderer::pushClipRect(
-        Vector2i(static_cast<int>(std::round(trans[3].x)),
-                 static_cast<int>(std::round(trans[3].y))),
-        Vector2i(static_cast<int>(std::round(dim.x)), static_cast<int>(std::round(dim.y))));
+        glm::ivec2{static_cast<int>(std::round(trans[3].x)),
+                   static_cast<int>(std::round(trans[3].y))},
+        glm::ivec2{static_cast<int>(std::round(dim.x)), static_cast<int>(std::round(dim.y))});
 
     // Scroll the camera.
-    trans = glm::translate(trans, glm::vec3(0.0f, -std::round(mCameraOffset), 0.0f));
+    trans = glm::translate(trans, glm::vec3{0.0f, -std::round(mCameraOffset), 0.0f});
 
     // Draw our entries.
     std::vector<GuiComponent*> drawAfterCursor;
diff --git a/es-core/src/components/DateTimeEditComponent.cpp b/es-core/src/components/DateTimeEditComponent.cpp
index 9818b0ec3..5796f7621 100644
--- a/es-core/src/components/DateTimeEditComponent.cpp
+++ b/es-core/src/components/DateTimeEditComponent.cpp
@@ -156,7 +156,7 @@ void DateTimeEditComponent::update(int deltaTime)
 
 void DateTimeEditComponent::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     if (mTextCache) {
         std::shared_ptr<Font> font = getFont();
@@ -170,7 +170,7 @@ void DateTimeEditComponent::render(const glm::mat4& parentTrans)
         }
 
         // Vertically center.
-        glm::vec3 off(0.0f, (mSize.y - mTextCache->metrics.size.y) / 2.0f, 0.0f);
+        glm::vec3 off{0.0f, (mSize.y - mTextCache->metrics.size.y) / 2.0f, 0.0f};
 
         if (mAlignRight)
             off.x += referenceSize - mTextCache->metrics.size.x;
@@ -300,22 +300,22 @@ void DateTimeEditComponent::updateTextCache()
         return;
 
     // Year.
-    glm::vec2 start(0.0f, 0.0f);
-    glm::vec2 end = font->sizeText(dispString.substr(0, 4));
-    glm::vec2 diff = end - start;
-    mCursorBoxes.push_back(glm::vec4(start[0], start[1], diff[0], diff[1]));
+    glm::vec2 start{};
+    glm::vec2 end{font->sizeText(dispString.substr(0, 4))};
+    glm::vec2 diff{end - start};
+    mCursorBoxes.push_back(glm::vec4{start[0], start[1], diff[0], diff[1]});
 
     // Month.
     start[0] = font->sizeText(dispString.substr(0, 5)).x;
     end = font->sizeText(dispString.substr(0, 7));
     diff = end - start;
-    mCursorBoxes.push_back(glm::vec4(start[0], start[1], diff[0], diff[1]));
+    mCursorBoxes.push_back(glm::vec4{start[0], start[1], diff[0], diff[1]});
 
     // Day.
     start[0] = font->sizeText(dispString.substr(0, 8)).x;
     end = font->sizeText(dispString.substr(0, 10));
     diff = end - start;
-    mCursorBoxes.push_back(glm::vec4(start[0], start[1], diff[0], diff[1]));
+    mCursorBoxes.push_back(glm::vec4{start[0], start[1], diff[0], diff[1]});
 
     // The logic for handling time for 'mode = DISP_DATE_TIME' is missing, but
     // nobody will use it anyway so it's not worthwhile implementing.
diff --git a/es-core/src/components/GridTileComponent.cpp b/es-core/src/components/GridTileComponent.cpp
index 3269751d1..903520aaf 100644
--- a/es-core/src/components/GridTileComponent.cpp
+++ b/es-core/src/components/GridTileComponent.cpp
@@ -17,12 +17,12 @@ GridTileComponent::GridTileComponent(Window* window)
     , mBackground(window, ":/graphics/frame.png")
 {
     mDefaultProperties.mSize = getDefaultTileSize();
-    mDefaultProperties.mPadding = glm::vec2(16.0f * Renderer::getScreenWidthModifier(),
-                                            16.0f * Renderer::getScreenHeightModifier());
+    mDefaultProperties.mPadding = glm::vec2{16.0f * Renderer::getScreenWidthModifier(),
+                                            16.0f * Renderer::getScreenHeightModifier()};
     mDefaultProperties.mImageColor = 0xAAAAAABB;
     // Attempting to use frame.svg instead causes quite severe performance problems.
     mDefaultProperties.mBackgroundImage = ":/graphics/frame.png";
-    mDefaultProperties.mBackgroundCornerSize = glm::vec2(16.0f, 16.0f);
+    mDefaultProperties.mBackgroundCornerSize = glm::vec2{16.0f, 16.0f};
     mDefaultProperties.mBackgroundCenterColor = 0xAAAAEEFF;
     mDefaultProperties.mBackgroundEdgeColor = 0xAAAAEEFF;
 
@@ -52,7 +52,7 @@ GridTileComponent::GridTileComponent(Window* window)
 
 void GridTileComponent::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = getTransform() * parentTrans;
+    glm::mat4 trans{getTransform() * parentTrans};
 
     if (mVisible)
         renderChildren(trans);
@@ -76,8 +76,8 @@ void GridTileComponent::update(int deltaTime)
 
 void applyThemeToProperties(const ThemeData::ThemeElement* elem, GridTileProperties* properties)
 {
-    glm::vec2 screen(static_cast<float>(Renderer::getScreenWidth()),
-                     static_cast<float>(Renderer::getScreenHeight()));
+    glm::vec2 screen{static_cast<float>(Renderer::getScreenWidth()),
+                     static_cast<float>(Renderer::getScreenHeight())};
 
     if (elem->has("size"))
         properties->mSize = elem->get<glm::vec2>("size") * screen;
@@ -132,8 +132,8 @@ void GridTileComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
 
 glm::vec2 GridTileComponent::getDefaultTileSize()
 {
-    glm::vec2 screen = glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
-                                 static_cast<float>(Renderer::getScreenHeight()));
+    glm::vec2 screen{glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
+                               static_cast<float>(Renderer::getScreenHeight()))};
 
     return screen * 0.22f;
 }
@@ -186,7 +186,7 @@ void GridTileComponent::setSelected(bool selected,
             resize();
         }
         else {
-            mAnimPosition = glm::vec3(pPosition->x, pPosition->y, pPosition->z);
+            mAnimPosition = glm::vec3{pPosition->x, pPosition->y, pPosition->z};
 
             auto func = [this](float t) {
                 t -= 1;
diff --git a/es-core/src/components/HelpComponent.cpp b/es-core/src/components/HelpComponent.cpp
index 8f654c20a..d04218bab 100644
--- a/es-core/src/components/HelpComponent.cpp
+++ b/es-core/src/components/HelpComponent.cpp
@@ -19,7 +19,7 @@
 #define ICON_TEXT_SPACING 8.0f // Space between [icon] and [text] (px).
 #define ENTRY_SPACING 16.0f // Space between [text] and next [icon] (px).
 
-static std::map<std::string, std::string> sIconPathMap {};
+static std::map<std::string, std::string> sIconPathMap{};
 
 HelpComponent::HelpComponent(Window* window)
     : GuiComponent(window)
@@ -114,7 +114,7 @@ void HelpComponent::updateGrid()
     std::shared_ptr<Font>& font = mStyle.font;
 
     mGrid = std::make_shared<ComponentGrid>(mWindow,
-                                            Vector2i(static_cast<int>(mPrompts.size()) * 4, 1));
+                                            glm::ivec2{static_cast<int>(mPrompts.size()) * 4, 1});
 
     // [icon] [spacer1] [text] [spacer2]
 
@@ -148,11 +148,11 @@ void HelpComponent::updateGrid()
                                (ICON_TEXT_SPACING * Renderer::getScreenWidthModifier()) / width);
         mGrid->setColWidthPerc(col + 2, labels.at(i)->getSize().x / width);
 
-        mGrid->setEntry(icons.at(i), Vector2i(col, 0), false, false);
-        mGrid->setEntry(labels.at(i), Vector2i(col + 2, 0), false, false);
+        mGrid->setEntry(icons.at(i), glm::ivec2{col, 0}, false, false);
+        mGrid->setEntry(labels.at(i), glm::ivec2{col + 2, 0}, false, false);
     }
 
-    mGrid->setPosition({ mStyle.position.x, mStyle.position.y, 0.0f });
+    mGrid->setPosition({mStyle.position.x, mStyle.position.y, 0.0f});
     mGrid->setOrigin(mStyle.origin);
 }
 
@@ -189,7 +189,7 @@ void HelpComponent::setOpacity(unsigned char opacity)
 
 void HelpComponent::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     if (mGrid)
         mGrid->render(trans);
diff --git a/es-core/src/components/IList.h b/es-core/src/components/IList.h
index 8a573540d..566c34137 100644
--- a/es-core/src/components/IList.h
+++ b/es-core/src/components/IList.h
@@ -37,9 +37,9 @@ struct ScrollTierList {
 // Default scroll tiers.
 // clang-format off
 const ScrollTier QUICK_SCROLL_TIERS[] = {
-    { 500, 500 },
-    { 1200, 114 },
-    { 0, 16 }
+    {500, 500},
+    {1200, 114},
+    {0, 16}
 };
 const ScrollTierList LIST_SCROLL_STYLE_QUICK = {
     3,
@@ -47,8 +47,8 @@ const ScrollTierList LIST_SCROLL_STYLE_QUICK = {
 };
 
 const ScrollTier SLOW_SCROLL_TIERS[] = {
-    { 500, 500 },
-    { 0, 200 }
+    {500, 500},
+    {0, 200}
 };
 
 const ScrollTierList LIST_SCROLL_STYLE_SLOW = {
diff --git a/es-core/src/components/ImageComponent.cpp b/es-core/src/components/ImageComponent.cpp
index cb56ea754..88fb97f19 100644
--- a/es-core/src/components/ImageComponent.cpp
+++ b/es-core/src/components/ImageComponent.cpp
@@ -14,12 +14,12 @@
 #include "resources/TextureResource.h"
 #include "utils/CImgUtil.h"
 
-Vector2i ImageComponent::getTextureSize() const
+glm::ivec2 ImageComponent::getTextureSize() const
 {
     if (mTexture)
         return mTexture->getSize();
     else
-        return Vector2i::Zero();
+        return glm::ivec2{};
 }
 
 glm::vec2 ImageComponent::getSize() const
@@ -53,8 +53,8 @@ void ImageComponent::resize()
     if (!mTexture)
         return;
 
-    const glm::vec2 textureSize = mTexture->getSourceImageSize();
-    if (textureSize == glm::vec2({}))
+    const glm::vec2 textureSize{mTexture->getSourceImageSize()};
+    if (textureSize == glm::vec2{})
         return;
 
     if (mTexture->isTiled()) {
@@ -71,7 +71,7 @@ void ImageComponent::resize()
         if (mTargetIsMax) {
             mSize = textureSize;
 
-            glm::vec2 resizeScale((mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y));
+            glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
 
             if (resizeScale.x < resizeScale.y) {
                 // This will be mTargetSize.x. We can't exceed it, nor be lower than it.
@@ -90,7 +90,7 @@ void ImageComponent::resize()
         else if (mTargetIsMin) {
             mSize = textureSize;
 
-            glm::vec2 resizeScale((mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y));
+            glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
 
             if (resizeScale.x > resizeScale.y) {
                 mSize.x *= resizeScale.x;
@@ -114,7 +114,7 @@ void ImageComponent::resize()
         else {
             // If both components are set, we just stretch.
             // If no components are set, we don't resize at all.
-            mSize = mTargetSize == glm::vec2({}) ? textureSize : mTargetSize;
+            mSize = mTargetSize == glm::vec2{} ? textureSize : mTargetSize;
 
             // If only one component is set, we resize in a way that maintains aspect ratio.
             // For SVG rasterization, we always calculate width from rounded height (see
@@ -177,7 +177,7 @@ void ImageComponent::setImage(const std::shared_ptr<TextureResource>& texture)
 
 void ImageComponent::setResize(float width, float height)
 {
-    mTargetSize = glm::vec2(width, height);
+    mTargetSize = glm::vec2{width, height};
     mTargetIsMax = false;
     mTargetIsMin = false;
     resize();
@@ -185,7 +185,7 @@ void ImageComponent::setResize(float width, float height)
 
 void ImageComponent::setMaxSize(float width, float height)
 {
-    mTargetSize = glm::vec2(width, height);
+    mTargetSize = glm::vec2{width, height};
     mTargetIsMax = true;
     mTargetIsMin = false;
     resize();
@@ -193,7 +193,7 @@ void ImageComponent::setMaxSize(float width, float height)
 
 void ImageComponent::setMinSize(float width, float height)
 {
-    mTargetSize = glm::vec2(width, height);
+    mTargetSize = glm::vec2{width, height};
     mTargetIsMax = false;
     mTargetIsMin = true;
     resize();
@@ -239,7 +239,7 @@ void ImageComponent::uncrop()
 
 void ImageComponent::cropTransparentPadding(float maxSizeX, float maxSizeY)
 {
-    if (mSize == glm::vec2({}))
+    if (mSize == glm::vec2{})
         return;
 
     std::vector<unsigned char> imageRGBA = mTexture.get()->getRawRGBAData();
@@ -247,10 +247,10 @@ void ImageComponent::cropTransparentPadding(float maxSizeX, float maxSizeY)
     if (imageRGBA.size() == 0)
         return;
 
-    Vector2i imageSize = mTexture.get()->getSize();
-    cimg_library::CImg<unsigned char> imageCImg(imageSize.x(), imageSize.y(), 1, 4, 0);
+    glm::ivec2 imageSize{mTexture.get()->getSize()};
+    cimg_library::CImg<unsigned char> imageCImg(imageSize.x, imageSize.y, 1, 4, 0);
 
-    int paddingCoords[4] = {};
+    int paddingCoords[4]{};
 
     // We need to convert our RGBA data to the CImg internal format as CImg does not interleave
     // the pixels (as in RGBARGBARGBA).
@@ -259,12 +259,12 @@ void ImageComponent::cropTransparentPadding(float maxSizeX, float maxSizeY)
     // This will give us the coordinates for the fully transparent areas.
     Utils::CImg::getTransparentPaddingCoords(imageCImg, paddingCoords);
 
-    glm::vec2 originalSize = mSize;
+    glm::vec2 originalSize{mSize};
 
-    float cropLeft = static_cast<float>(paddingCoords[0]) / static_cast<float>(imageSize.x());
-    float cropTop = static_cast<float>(paddingCoords[1]) / static_cast<float>(imageSize.y());
-    float cropRight = static_cast<float>(paddingCoords[2]) / static_cast<float>(imageSize.x());
-    float cropBottom = static_cast<float>(paddingCoords[3]) / static_cast<float>(imageSize.y());
+    float cropLeft{static_cast<float>(paddingCoords[0]) / static_cast<float>(imageSize.x)};
+    float cropTop{static_cast<float>(paddingCoords[1]) / static_cast<float>(imageSize.y)};
+    float cropRight{static_cast<float>(paddingCoords[2]) / static_cast<float>(imageSize.x)};
+    float cropBottom{static_cast<float>(paddingCoords[3]) / static_cast<float>(imageSize.y)};
 
     crop(cropLeft, cropTop, cropRight, cropBottom);
 
@@ -342,16 +342,16 @@ void ImageComponent::updateVertices()
 
     // We go through this mess to make sure everything is properly rounded.
     // If we just round vertices at the end, edge cases occur near sizes of 0.5.
-    const glm::vec2 topLeft = { 0.0f, 0.0f };
-    const glm::vec2 bottomRight = mSize;
-    const float px = mTexture->isTiled() ? mSize.x / getTextureSize().x() : 1.0f;
-    const float py = mTexture->isTiled() ? mSize.y / getTextureSize().y() : 1.0f;
+    const glm::vec2 topLeft{};
+    const glm::vec2 bottomRight{mSize};
+    const float px{mTexture->isTiled() ? mSize.x / getTextureSize().x : 1.0f};
+    const float py{mTexture->isTiled() ? mSize.y / getTextureSize().y : 1.0f};
 
     // clang-format off
-    mVertices[0] = { { topLeft.x,     topLeft.y     }, { mTopLeftCrop.x,          py   - mTopLeftCrop.y     }, 0 };
-    mVertices[1] = { { topLeft.x,     bottomRight.y }, { mTopLeftCrop.x,          1.0f - mBottomRightCrop.y }, 0 };
-    mVertices[2] = { { bottomRight.x, topLeft.y     }, { mBottomRightCrop.x * px, py   - mTopLeftCrop.y     }, 0 };
-    mVertices[3] = { { bottomRight.x, bottomRight.y }, { mBottomRightCrop.x * px, 1.0f - mBottomRightCrop.y }, 0 };
+    mVertices[0] = {{topLeft.x,     topLeft.y    }, {mTopLeftCrop.x,          py   - mTopLeftCrop.y    }, 0};
+    mVertices[1] = {{topLeft.x,     bottomRight.y}, {mTopLeftCrop.x,          1.0f - mBottomRightCrop.y}, 0};
+    mVertices[2] = {{bottomRight.x, topLeft.y    }, {mBottomRightCrop.x * px, py   - mTopLeftCrop.y    }, 0};
+    mVertices[3] = {{bottomRight.x, bottomRight.y}, {mBottomRightCrop.x * px, 1.0f - mBottomRightCrop.y}, 0};
     // clang-format on
 
     updateColors();
@@ -391,18 +391,18 @@ void ImageComponent::render(const glm::mat4& parentTrans)
     if (!isVisible())
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
     Renderer::setMatrix(trans);
 
     if (mTexture && mOpacity > 0) {
         if (Settings::getInstance()->getBool("DebugImage")) {
-            glm::vec2 targetSizePos = (mTargetSize - mSize) * mOrigin * glm::vec2(-1.0f);
+            glm::vec2 targetSizePos{(mTargetSize - mSize) * mOrigin * glm::vec2{-1.0f}};
             Renderer::drawRect(targetSizePos.x, targetSizePos.y, mTargetSize.x, mTargetSize.y,
                                0xFF000033, 0xFF000033);
             Renderer::drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0xFF000033, 0xFF000033);
         }
         // An image with zero size would normally indicate a corrupt image file.
-        if (mTexture->isInitialized() && mTexture->getSize() != 0) {
+        if (mTexture->isInitialized() && mTexture->getSize() != glm::ivec2{}) {
             // Actually draw the image.
             // The bind() function returns false if the texture is not currently loaded. A blank
             // texture is bound in this case but we want to handle a fade so it doesn't just
@@ -482,9 +482,9 @@ void ImageComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
     if (!elem)
         return;
 
-    glm::vec2 scale = getParent() ? getParent()->getSize() :
-                                    glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
-                                              static_cast<float>(Renderer::getScreenHeight()));
+    glm::vec2 scale{getParent() ? getParent()->getSize() :
+                                  glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
+                                            static_cast<float>(Renderer::getScreenHeight()))};
 
     if (properties & ThemeFlags::SIZE) {
         if (elem->has("size"))
diff --git a/es-core/src/components/ImageComponent.h b/es-core/src/components/ImageComponent.h
index 7d70561e8..56f45acf3 100644
--- a/es-core/src/components/ImageComponent.h
+++ b/es-core/src/components/ImageComponent.h
@@ -10,7 +10,6 @@
 #define ES_CORE_COMPONENTS_IMAGE_COMPONENT_H
 
 #include "GuiComponent.h"
-#include "math/Vector2i.h"
 #include "renderers/Renderer.h"
 
 class TextureResource;
@@ -83,7 +82,7 @@ public:
 
     // Returns the size of the current texture, or (0, 0) if none is loaded.
     // May be different than drawn size (use getSize() for that).
-    Vector2i getTextureSize() const;
+    glm::ivec2 getTextureSize() const;
 
     glm::vec2 getSize() const override;
 
diff --git a/es-core/src/components/ImageGridComponent.h b/es-core/src/components/ImageGridComponent.h
index 042f4fa53..77ab6998b 100644
--- a/es-core/src/components/ImageGridComponent.h
+++ b/es-core/src/components/ImageGridComponent.h
@@ -104,7 +104,7 @@ private:
     glm::vec4 mPadding;
     glm::vec2 mMargin;
     glm::vec2 mTileSize;
-    Vector2i mGridDimension;
+    glm::ivec2 mGridDimension;
     std::shared_ptr<ThemeData> mTheme;
     std::vector<std::shared_ptr<GridTileComponent>> mTiles;
 
@@ -126,13 +126,13 @@ template <typename T>
 ImageGridComponent<T>::ImageGridComponent(Window* window)
     : IList<ImageGridData, T>(window)
 {
-    glm::vec2 screen(static_cast<float>(Renderer::getScreenWidth()),
-                     static_cast<float>(Renderer::getScreenHeight()));
+    glm::vec2 screen{static_cast<float>(Renderer::getScreenWidth()),
+                     static_cast<float>(Renderer::getScreenHeight())};
 
     mCamera = 0.0f;
     mCameraDirection = 1.0f;
 
-    mAutoLayout = glm::vec2({});
+    mAutoLayout = glm::vec2{};
     mAutoLayoutZoom = 1.0f;
 
     mStartPosition = 0;
@@ -171,7 +171,7 @@ template <typename T> bool ImageGridComponent<T>::input(InputConfig* config, Inp
     if (input.value != 0) {
         int idx = isVertical() ? 0 : 1;
 
-        Vector2i dir = Vector2i::Zero();
+        glm::ivec2 dir{};
         if (config->isMappedLike("up", input))
             dir[1 ^ idx] = -1;
         else if (config->isMappedLike("down", input))
@@ -181,11 +181,11 @@ template <typename T> bool ImageGridComponent<T>::input(InputConfig* config, Inp
         else if (config->isMappedLike("right", input))
             dir[0 ^ idx] = 1;
 
-        if (dir != Vector2i::Zero()) {
+        if (dir != glm::ivec2{}) {
             if (isVertical())
-                listInput(dir.x() + dir.y() * mGridDimension.x());
+                listInput(dir.x + dir.y * mGridDimension.x);
             else
-                listInput(dir.x() + dir.y() * mGridDimension.y());
+                listInput(dir.x + dir.y * mGridDimension.y);
             return true;
         }
     }
@@ -210,13 +210,13 @@ template <typename T> void ImageGridComponent<T>::update(int deltaTime)
 
 template <typename T> void ImageGridComponent<T>::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = getTransform() * parentTrans;
-    glm::mat4 tileTrans = trans;
+    glm::mat4 trans{getTransform() * parentTrans};
+    glm::mat4 tileTrans{trans};
 
-    float offsetX = isVertical() ? 0.0f : mCamera * mCameraDirection * (mTileSize.x + mMargin.x);
-    float offsetY = isVertical() ? mCamera * mCameraDirection * (mTileSize.y + mMargin.y) : 0.0f;
+    float offsetX{isVertical() ? 0.0f : mCamera * mCameraDirection * (mTileSize.x + mMargin.x)};
+    float offsetY{isVertical() ? mCamera * mCameraDirection * (mTileSize.y + mMargin.y) : 0.0f};
 
-    tileTrans = glm::translate(tileTrans, glm::vec3(offsetX, offsetY, 0.0f));
+    tileTrans = glm::translate(tileTrans, glm::vec3{offsetX, offsetY, 0.0f});
 
     if (mEntriesDirty) {
         updateTiles();
@@ -227,10 +227,10 @@ template <typename T> void ImageGridComponent<T>::render(const glm::mat4& parent
     float scaleX = trans[0].x;
     float scaleY = trans[1].y;
 
-    Vector2i pos(static_cast<int>(std::round(trans[3].x)),
-                 static_cast<int>(std::round(trans[3].y)));
-    Vector2i size(static_cast<int>(std::round(mSize.x * scaleX)),
-                  static_cast<int>(std::round(mSize.y * scaleY)));
+    glm::ivec2 pos{static_cast<int>(std::round(trans[3].x)),
+                   static_cast<int>(std::round(trans[3].y))};
+    glm::ivec2 size{static_cast<int>(std::round(mSize.x * scaleX)),
+                    static_cast<int>(std::round(mSize.y * scaleY))};
 
     Renderer::pushClipRect(pos, size);
 
@@ -269,8 +269,8 @@ void ImageGridComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
     // Keep the theme pointer to apply it on the tiles later on.
     mTheme = theme;
 
-    glm::vec2 screen(static_cast<float>(Renderer::getScreenWidth()),
-                     static_cast<float>(Renderer::getScreenHeight()));
+    glm::vec2 screen{static_cast<float>(Renderer::getScreenWidth()),
+                     static_cast<float>(Renderer::getScreenHeight())};
 
     const ThemeData::ThemeElement* elem = theme->getElement(view, element, "imagegrid");
     if (elem) {
@@ -279,7 +279,7 @@ void ImageGridComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
 
         if (elem->has("padding"))
             mPadding =
-                elem->get<glm::vec4>("padding") * glm::vec4(screen.x, screen.y, screen.x, screen.y);
+                elem->get<glm::vec4>("padding") * glm::vec4{screen.x, screen.y, screen.x, screen.y};
 
         if (elem->has("autoLayout"))
             mAutoLayout = elem->get<glm::vec2>("autoLayout");
@@ -399,8 +399,8 @@ template <typename T> void ImageGridComponent<T>::onCursorChanged(const CursorSt
 
     int oldStart = mStartPosition;
 
-    int dimScrollable = (isVertical() ? mGridDimension.y() : mGridDimension.x()) - 2 * EXTRAITEMS;
-    int dimOpposite = isVertical() ? mGridDimension.x() : mGridDimension.y();
+    int dimScrollable = (isVertical() ? mGridDimension.y : mGridDimension.x) - 2 * EXTRAITEMS;
+    int dimOpposite = isVertical() ? mGridDimension.x : mGridDimension.y;
 
     int centralCol = static_cast<int>((static_cast<float>(dimScrollable) - 0.5f) / 2.0f);
     int maxCentralCol = dimScrollable / 2;
@@ -447,7 +447,7 @@ template <typename T> void ImageGridComponent<T>::onCursorChanged(const CursorSt
             }
         }
 
-        glm::vec3 oldPos {};
+        glm::vec3 oldPos{};
 
         if (oldTile != nullptr && oldTile != newTile) {
             oldPos = oldTile->getBackgroundPosition();
@@ -455,7 +455,7 @@ template <typename T> void ImageGridComponent<T>::onCursorChanged(const CursorSt
         }
 
         if (newTile != nullptr)
-            newTile->setSelected(true, true, oldPos == glm::vec3({}) ? nullptr : &oldPos, true);
+            newTile->setSelected(true, true, oldPos == glm::vec3{} ? nullptr : &oldPos, true);
     }
 
     int firstVisibleCol = mStartPosition / dimOpposite;
@@ -528,12 +528,11 @@ template <typename T> void ImageGridComponent<T>::buildTiles()
     calcGridDimension();
 
     if (mCenterSelection) {
-        int dimScrollable =
-            (isVertical() ? mGridDimension.y() : mGridDimension.x()) - 2 * EXTRAITEMS;
+        int dimScrollable = (isVertical() ? mGridDimension.y : mGridDimension.x) - 2 * EXTRAITEMS;
         mStartPosition -= static_cast<int>(floorf(dimScrollable / 2.0f));
     }
 
-    glm::vec2 tileDistance = mTileSize + mMargin;
+    glm::vec2 tileDistance{mTileSize + mMargin};
 
     if (mAutoLayout.x != 0.0f && mAutoLayout.y != 0.0f) {
         auto x = (mSize.x - (mMargin.x * (mAutoLayout.x - 1.0f)) - mPadding.x - mPadding.z) /
@@ -541,12 +540,12 @@ template <typename T> void ImageGridComponent<T>::buildTiles()
         auto y = (mSize.y - (mMargin.y * (mAutoLayout.y - 1.0f)) - mPadding.y - mPadding.w) /
                  static_cast<int>(mAutoLayout.y);
 
-        mTileSize = glm::vec2(x, y);
+        mTileSize = glm::vec2{x, y};
         tileDistance = mTileSize + mMargin;
     }
 
     bool vert = isVertical();
-    glm::vec2 startPosition = mTileSize / 2.0f;
+    glm::vec2 startPosition{mTileSize / 2.0f};
     startPosition.x += mPadding.x;
     startPosition.y += mPadding.y;
 
@@ -554,8 +553,8 @@ template <typename T> void ImageGridComponent<T>::buildTiles()
     int Y;
 
     // Layout tile size and position.
-    for (int y = 0; y < (vert ? mGridDimension.y() : mGridDimension.x()); y++) {
-        for (int x = 0; x < (vert ? mGridDimension.x() : mGridDimension.y()); x++) {
+    for (int y = 0; y < (vert ? mGridDimension.y : mGridDimension.x); y++) {
+        for (int x = 0; x < (vert ? mGridDimension.x : mGridDimension.y); x++) {
             // Create tiles.
             auto tile = std::make_shared<GridTileComponent>(mWindow);
 
@@ -614,7 +613,7 @@ void ImageGridComponent<T>::updateTiles(bool ascending,
     int end = ascending ? static_cast<int>(mTiles.size()) : -1;
     int img = mStartPosition + ti;
 
-    img -= EXTRAITEMS * (isVertical() ? mGridDimension.x() : mGridDimension.y());
+    img -= EXTRAITEMS * (isVertical() ? mGridDimension.x : mGridDimension.y);
 
     // Update the tiles.
     while (ti != end) {
@@ -674,7 +673,7 @@ void ImageGridComponent<T>::updateTileAtPos(int tilePos,
                 if (idx < 0 || idx >= mTiles.size())
                     idx = 0;
 
-                glm::vec3 pos = mTiles.at(idx)->getBackgroundPosition();
+                glm::vec3 pos{mTiles.at(idx)->getBackgroundPosition()};
                 tile->setSelected(true, allowAnimation, &pos);
             }
             else {
@@ -690,7 +689,7 @@ template <typename T> void ImageGridComponent<T>::calcGridDimension()
 {
     // grid_size = columns * tile_size + (columns - 1) * margin
     // <=> columns = (grid_size + margin) / (tile_size + margin)
-    glm::vec2 gridDimension = (mSize + mMargin) / (mTileSize + mMargin);
+    glm::vec2 gridDimension{(mSize + mMargin) / (mTileSize + mMargin)};
 
     if (mAutoLayout.x != 0.0f && mAutoLayout.y != 0.0f)
         gridDimension = mAutoLayout;
@@ -698,22 +697,22 @@ template <typename T> void ImageGridComponent<T>::calcGridDimension()
     mLastRowPartial = floorf(gridDimension.y) != gridDimension.y;
 
     // Ceil y dim so we can display partial last row.
-    mGridDimension = Vector2i(static_cast<const int>(gridDimension.x),
-                              static_cast<const int>(ceilf(gridDimension.y)));
+    mGridDimension = glm::ivec2{static_cast<const int>(gridDimension.x),
+                                static_cast<const int>(ceilf(gridDimension.y))};
 
     // Grid dimension validation.
-    if (mGridDimension.x() < 1) {
+    if (mGridDimension.x < 1) {
         LOG(LogError) << "Theme defined grid X dimension below 1";
     }
-    if (mGridDimension.y() < 1) {
+    if (mGridDimension.y < 1) {
         LOG(LogError) << "Theme defined grid Y dimension below 1";
     }
 
     // Add extra tiles to both sides.
     if (isVertical())
-        mGridDimension.y() += 2 * EXTRAITEMS;
+        mGridDimension.y += 2 * EXTRAITEMS;
     else
-        mGridDimension.x() += 2 * EXTRAITEMS;
+        mGridDimension.x += 2 * EXTRAITEMS;
 }
 
 template <typename T> bool ImageGridComponent<T>::isScrollLoop()
@@ -721,8 +720,8 @@ template <typename T> bool ImageGridComponent<T>::isScrollLoop()
     if (!mScrollLoop)
         return false;
     if (isVertical())
-        return (mGridDimension.x() * (mGridDimension.y() - 2 * EXTRAITEMS)) <= mEntries.size();
-    return (mGridDimension.y() * (mGridDimension.x() - 2 * EXTRAITEMS)) <= mEntries.size();
+        return (mGridDimension.x * (mGridDimension.y - 2 * EXTRAITEMS)) <= mEntries.size();
+    return (mGridDimension.y * (mGridDimension.x - 2 * EXTRAITEMS)) <= mEntries.size();
 }
 
 #endif // ES_CORE_COMPONENTS_IMAGE_GRID_COMPONENT_H
diff --git a/es-core/src/components/MenuComponent.cpp b/es-core/src/components/MenuComponent.cpp
index 83d2f3b8a..3d5b49e9d 100644
--- a/es-core/src/components/MenuComponent.cpp
+++ b/es-core/src/components/MenuComponent.cpp
@@ -21,7 +21,7 @@ MenuComponent::MenuComponent(Window* window,
                              const std::shared_ptr<Font>& titleFont)
     : GuiComponent(window)
     , mBackground(window)
-    , mGrid(window, Vector2i(1, 3))
+    , mGrid(window, glm::ivec2{1, 3})
     , mNeedsSaving(false)
 {
     addChild(&mBackground);
@@ -34,11 +34,11 @@ MenuComponent::MenuComponent(Window* window,
     mTitle->setHorizontalAlignment(ALIGN_CENTER);
     mTitle->setColor(0x555555FF);
     setTitle(title, titleFont);
-    mGrid.setEntry(mTitle, Vector2i(0, 0), false);
+    mGrid.setEntry(mTitle, glm::ivec2{}, false);
 
     // Set up list which will never change (externally, anyway).
     mList = std::make_shared<ComponentList>(mWindow);
-    mGrid.setEntry(mList, Vector2i(0, 1), true);
+    mGrid.setEntry(mList, glm::ivec2{0, 1}, true);
 
     updateGrid();
     updateSize();
@@ -106,7 +106,7 @@ void MenuComponent::updateSize()
 
 void MenuComponent::onSizeChanged()
 {
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     // Update grid row/column sizes.
     mGrid.setRowHeightPerc(0, TITLE_HEIGHT / mSize.y);
@@ -134,7 +134,7 @@ void MenuComponent::updateGrid()
 
     if (mButtons.size()) {
         mButtonGrid = makeButtonGrid(mWindow, mButtons);
-        mGrid.setEntry(mButtonGrid, Vector2i(0, 2), true, false);
+        mGrid.setEntry(mButtonGrid, glm::ivec2{0, 2}, true, false);
     }
 }
 
@@ -142,13 +142,13 @@ std::shared_ptr<ComponentGrid> makeButtonGrid(
     Window* window, const std::vector<std::shared_ptr<ButtonComponent>>& buttons)
 {
     std::shared_ptr<ComponentGrid> buttonGrid =
-        std::make_shared<ComponentGrid>(window, Vector2i(static_cast<int>(buttons.size()), 2));
+        std::make_shared<ComponentGrid>(window, glm::ivec2{static_cast<int>(buttons.size()), 2});
 
     // Initialize to padding.
     float buttonGridWidth =
         BUTTON_GRID_HORIZ_PADDING * Renderer::getScreenWidthModifier() * buttons.size();
     for (int i = 0; i < static_cast<int>(buttons.size()); i++) {
-        buttonGrid->setEntry(buttons.at(i), Vector2i(i, 0), true, false);
+        buttonGrid->setEntry(buttons.at(i), glm::ivec2{i, 0}, true, false);
         buttonGridWidth += buttons.at(i)->getSize().x;
     }
     for (unsigned int i = 0; i < buttons.size(); i++)
diff --git a/es-core/src/components/NinePatchComponent.cpp b/es-core/src/components/NinePatchComponent.cpp
index a5a396a17..9d4abbde4 100644
--- a/es-core/src/components/NinePatchComponent.cpp
+++ b/es-core/src/components/NinePatchComponent.cpp
@@ -61,47 +61,46 @@ void NinePatchComponent::buildVertices()
 
     mTexture = TextureResource::get(mPath, false, false, true, scaleFactor);
 
-    if (mTexture->getSize() == Vector2i::Zero()) {
+    if (mTexture->getSize() == glm::ivec2{}) {
         mVertices = nullptr;
         LOG(LogWarning) << "NinePatchComponent has no texture";
         return;
     }
 
-    glm::vec2 texSize;
     mVertices = new Renderer::Vertex[6 * 9];
 
-    texSize = glm::vec2(static_cast<float>(mTexture->getSize().x()),
-                        static_cast<float>(mTexture->getSize().y()));
+    glm::vec2 texSize{static_cast<float>(mTexture->getSize().x),
+                      static_cast<float>(mTexture->getSize().y)};
 
-    // clang-format off
-    const float imgSizeX[3] = { mCornerSize.x, mSize.x - mCornerSize.x * 2.0f, mCornerSize.x };
-    const float imgSizeY[3] = { mCornerSize.y, mSize.y - mCornerSize.y * 2.0f, mCornerSize.y };
-    const float imgPosX[3] = { 0, imgSizeX[0], imgSizeX[0] + imgSizeX[1] };
-    const float imgPosY[3] = { 0, imgSizeY[0], imgSizeY[0] + imgSizeY[1] };
+    const float imgSizeX[3]{mCornerSize.x, mSize.x - mCornerSize.x * 2.0f, mCornerSize.x};
+    const float imgSizeY[3]{mCornerSize.y, mSize.y - mCornerSize.y * 2.0f, mCornerSize.y};
+    const float imgPosX[3]{0, imgSizeX[0], imgSizeX[0] + imgSizeX[1]};
+    const float imgPosY[3]{0, imgSizeY[0], imgSizeY[0] + imgSizeY[1]};
 
     // The "1 +" in posY and "-" in sizeY is to deal with texture coordinates having a bottom
     // left corner origin vs. verticies having a top left origin.
-    const float texSizeX[3] = {  mCornerSize.x / texSize.x,  (texSize.x - mCornerSize.x * 2.0f) / texSize.x,  mCornerSize.x / texSize.x };
-    const float texSizeY[3] = { -mCornerSize.y / texSize.y, -(texSize.y - mCornerSize.y * 2.0f) / texSize.y, -mCornerSize.y / texSize.y };
-    const float texPosX[3]  = {  0.0f,        texSizeX[0],        texSizeX[0] + texSizeX[1] };
-    const float texPosY[3]  = {  1.0f, 1.0f + texSizeY[0], 1.0f + texSizeY[0] + texSizeY[1] };
+    const float texSizeX[3]{mCornerSize.x / texSize.x,  (texSize.x - mCornerSize.x * 2.0f) / texSize.x,  mCornerSize.x / texSize.x};
+    const float texSizeY[3]{-mCornerSize.y / texSize.y, -(texSize.y - mCornerSize.y * 2.0f) / texSize.y, -mCornerSize.y / texSize.y};
+
+    const float texPosX[3]{0.0f,        texSizeX[0],        texSizeX[0] + texSizeX[1]};
+    const float texPosY[3]{1.0f, 1.0f + texSizeY[0], 1.0f + texSizeY[0] + texSizeY[1]};
     // clang-format on
 
     int v = 0;
 
     for (int slice = 0; slice < 9; slice++) {
-        const int sliceX = slice % 3;
-        const int sliceY = slice / 3;
-        const glm::vec2 imgPos = glm::vec2(imgPosX[sliceX], imgPosY[sliceY]);
-        const glm::vec2 imgSize = glm::vec2(imgSizeX[sliceX], imgSizeY[sliceY]);
-        const glm::vec2 texPos = glm::vec2(texPosX[sliceX], texPosY[sliceY]);
-        const glm::vec2 texSize = glm::vec2(texSizeX[sliceX], texSizeY[sliceY]);
+        const int sliceX{slice % 3};
+        const int sliceY{slice / 3};
+        const glm::vec2 imgPos{imgPosX[sliceX], imgPosY[sliceY]};
+        const glm::vec2 imgSize{imgSizeX[sliceX], imgSizeY[sliceY]};
+        const glm::vec2 texPos{texPosX[sliceX], texPosY[sliceY]};
+        const glm::vec2 texSize{texSizeX[sliceX], texSizeY[sliceY]};
 
         // clang-format off
-        mVertices[v + 1] = { { imgPos.x            , imgPos.y             }, { texPos.x,             texPos.y             }, 0 };
-        mVertices[v + 2] = { { imgPos.x            , imgPos.y + imgSize.y }, { texPos.x,             texPos.y + texSize.y }, 0 };
-        mVertices[v + 3] = { { imgPos.x + imgSize.x, imgPos.y             }, { texPos.x + texSize.x, texPos.y             }, 0 };
-        mVertices[v + 4] = { { imgPos.x + imgSize.x, imgPos.y + imgSize.y }, { texPos.x + texSize.x, texPos.y + texSize.y }, 0 };
+        mVertices[v + 1] = {{imgPos.x            , imgPos.y            }, {texPos.x,             texPos.y            }, 0};
+        mVertices[v + 2] = {{imgPos.x            , imgPos.y + imgSize.y}, {texPos.x,             texPos.y + texSize.y}, 0};
+        mVertices[v + 3] = {{imgPos.x + imgSize.x, imgPos.y            }, {texPos.x + texSize.x, texPos.y            }, 0};
+        mVertices[v + 4] = {{imgPos.x + imgSize.x, imgPos.y + imgSize.y}, {texPos.x + texSize.x, texPos.y + texSize.y}, 0};
         // clang-format on
 
         // Round vertices.
@@ -123,7 +122,7 @@ void NinePatchComponent::render(const glm::mat4& parentTrans)
     if (!isVisible())
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     if (mTexture && mVertices != nullptr) {
         Renderer::setMatrix(trans);
@@ -144,8 +143,6 @@ void NinePatchComponent::render(const glm::mat4& parentTrans)
     renderChildren(trans);
 }
 
-void NinePatchComponent::onSizeChanged() { buildVertices(); }
-
 void NinePatchComponent::fitTo(glm::vec2 size, glm::vec3 position, glm::vec2 padding)
 {
     size += padding;
diff --git a/es-core/src/components/NinePatchComponent.h b/es-core/src/components/NinePatchComponent.h
index b600f4be4..a02009eb2 100644
--- a/es-core/src/components/NinePatchComponent.h
+++ b/es-core/src/components/NinePatchComponent.h
@@ -37,8 +37,7 @@ public:
 
     void render(const glm::mat4& parentTrans) override;
 
-    void onSizeChanged() override;
-
+    void onSizeChanged() override { buildVertices(); }
     void fitTo(glm::vec2 size, glm::vec3 position = {}, glm::vec2 padding = {});
 
     void setImagePath(const std::string& path);
diff --git a/es-core/src/components/RatingComponent.cpp b/es-core/src/components/RatingComponent.cpp
index f5e8ad349..1751d0f46 100644
--- a/es-core/src/components/RatingComponent.cpp
+++ b/es-core/src/components/RatingComponent.cpp
@@ -25,7 +25,7 @@ RatingComponent::RatingComponent(Window* window, bool colorizeChanges)
     mFilledTexture = TextureResource::get(":/graphics/star_filled.svg", true);
     mUnfilledTexture = TextureResource::get(":/graphics/star_unfilled.svg", true);
     mValue = 0.5f;
-    mSize = glm::vec2(64.0f * NUM_RATING_STARS, 64.0f);
+    mSize = glm::vec2{64.0f * NUM_RATING_STARS, 64.0f};
     updateVertices();
     updateColors();
 }
@@ -121,15 +121,15 @@ void RatingComponent::updateVertices()
     const unsigned int color = Renderer::convertRGBAToABGR(mColorShift);
 
     // clang-format off
-    mVertices[0] = { { 0.0f, 0.0f }, { 0.0f,              1.0f }, color };
-    mVertices[1] = { { 0.0f, h    }, { 0.0f,              0.0f }, color };
-    mVertices[2] = { { w,    0.0f }, { mValue * numStars, 1.0f }, color };
-    mVertices[3] = { { w,    h    }, { mValue * numStars, 0.0f }, color };
+    mVertices[0] = {{0.0f, 0.0f}, {0.0f,              1.0f}, color};
+    mVertices[1] = {{0.0f, h   }, {0.0f,              0.0f}, color};
+    mVertices[2] = {{w,    0.0f}, {mValue * numStars, 1.0f}, color};
+    mVertices[3] = {{w,    h   }, {mValue * numStars, 0.0f}, color};
 
-    mVertices[4] = { { 0.0f, 0.0f }, { 0.0f,              1.0f }, color };
-    mVertices[5] = { { 0.0f, h    }, { 0.0f,              0.0f }, color };
-    mVertices[6] = { { fw,   0.0f }, { numStars,          1.0f }, color };
-    mVertices[7] = { { fw,   h    }, { numStars,          0.0f }, color };
+    mVertices[4] = {{0.0f, 0.0f}, {0.0f,              1.0f}, color};
+    mVertices[5] = {{0.0f, h   }, {0.0f,              0.0f}, color};
+    mVertices[6] = {{fw,   0.0f}, {numStars,          1.0f}, color};
+    mVertices[7] = {{fw,   h   }, {numStars,          0.0f}, color};
     // clang-format on
 }
 
@@ -146,7 +146,7 @@ void RatingComponent::render(const glm::mat4& parentTrans)
     if (!isVisible() || mFilledTexture == nullptr || mUnfilledTexture == nullptr)
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     Renderer::setMatrix(trans);
 
diff --git a/es-core/src/components/ScrollableContainer.cpp b/es-core/src/components/ScrollableContainer.cpp
index b0ff1a85a..53c5e436d 100644
--- a/es-core/src/components/ScrollableContainer.cpp
+++ b/es-core/src/components/ScrollableContainer.cpp
@@ -11,7 +11,6 @@
 
 #include "Window.h"
 #include "animations/LambdaAnimation.h"
-#include "math/Vector2i.h"
 #include "renderers/Renderer.h"
 #include "resources/Font.h"
 
@@ -45,7 +44,7 @@ ScrollableContainer::ScrollableContainer(Window* window)
 void ScrollableContainer::setAutoScroll(bool autoScroll)
 {
     if (autoScroll) {
-        mScrollDir = glm::vec2(0.0f, 1.0f);
+        mScrollDir = glm::vec2{0.0f, 1.0f};
         mAutoScrollDelay = static_cast<int>(mAutoScrollDelayConstant);
         mAutoScrollSpeed = mAutoScrollSpeedConstant;
         mAutoScrollSpeed =
@@ -53,7 +52,7 @@ void ScrollableContainer::setAutoScroll(bool autoScroll)
         reset();
     }
     else {
-        mScrollDir = glm::vec2(0.0f, 0.0f);
+        mScrollDir = glm::vec2{};
         mAutoScrollDelay = 0;
         mAutoScrollSpeed = 0;
         mAutoScrollAccumulator = 0;
@@ -71,7 +70,7 @@ void ScrollableContainer::setScrollParameters(float autoScrollDelayConstant,
 
 void ScrollableContainer::reset()
 {
-    mScrollPos = glm::vec2(0.0f, 0.0f);
+    mScrollPos = glm::vec2{};
     mAutoScrollResetAccumulator = 0;
     mAutoScrollAccumulator = -mAutoScrollDelay + mAutoScrollSpeed;
     mAtEnd = false;
@@ -82,12 +81,12 @@ void ScrollableContainer::update(int deltaTime)
     // Don't scroll if the media viewer or screensaver is active or if text scrolling is disabled;
     if (mWindow->isMediaViewerActive() || mWindow->isScreensaverActive() ||
         !mWindow->getAllowTextScrolling()) {
-        if (mScrollPos != glm::vec2({}) && !mWindow->isLaunchScreenDisplayed())
+        if (mScrollPos != glm::vec2{} && !mWindow->isLaunchScreenDisplayed())
             reset();
         return;
     }
 
-    const glm::vec2 contentSize = getContentSize();
+    const glm::vec2 contentSize{getContentSize()};
     int adjustedAutoScrollSpeed = mAutoScrollSpeed;
 
     // Adjust the scrolling speed based on the width of the container.
@@ -136,7 +135,7 @@ void ScrollableContainer::update(int deltaTime)
             // Fade in the text as it resets to the start position.
             auto func = [this](float t) {
                 this->setOpacity(static_cast<unsigned char>(Math::lerp(0.0f, 1.0f, t) * 255));
-                mScrollPos = glm::vec2(0.0f, 0.0f);
+                mScrollPos = glm::vec2{};
                 mAutoScrollResetAccumulator = 0;
                 mAutoScrollAccumulator = -mAutoScrollDelay + mAutoScrollSpeed;
                 mAtEnd = false;
@@ -153,21 +152,20 @@ void ScrollableContainer::render(const glm::mat4& parentTrans)
     if (!isVisible())
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
-    Vector2i clipPos(static_cast<int>(trans[3].x), static_cast<int>(trans[3].y));
-
-    glm::vec3 dimScaled {};
+    glm::ivec2 clipPos{static_cast<int>(trans[3].x), static_cast<int>(trans[3].y)};
 
+    glm::vec3 dimScaled{};
     dimScaled.x = std::fabs(trans[3].x + mSize.x);
     dimScaled.y = std::fabs(trans[3].y + mSize.y);
 
-    Vector2i clipDim(static_cast<int>(dimScaled.x - trans[3].x),
-                     static_cast<int>(dimScaled.y - trans[3].y));
+    glm::ivec2 clipDim{static_cast<int>(dimScaled.x - trans[3].x),
+                       static_cast<int>(dimScaled.y - trans[3].y)};
 
     Renderer::pushClipRect(clipPos, clipDim);
 
-    trans = glm::translate(trans, -glm::vec3(mScrollPos.x, mScrollPos.y, 0.0f));
+    trans = glm::translate(trans, -glm::vec3{mScrollPos.x, mScrollPos.y, 0.0f});
     Renderer::setMatrix(trans);
 
     GuiComponent::renderChildren(trans);
@@ -176,10 +174,10 @@ void ScrollableContainer::render(const glm::mat4& parentTrans)
 
 glm::vec2 ScrollableContainer::getContentSize()
 {
-    glm::vec2 max(0.0f, 0.0f);
+    glm::vec2 max{};
     for (unsigned int i = 0; i < mChildren.size(); i++) {
-        glm::vec2 pos(mChildren.at(i)->getPosition().x, mChildren.at(i)->getPosition().y);
-        glm::vec2 bottomRight = mChildren.at(i)->getSize() + pos;
+        glm::vec2 pos{mChildren.at(i)->getPosition().x, mChildren.at(i)->getPosition().y};
+        glm::vec2 bottomRight{mChildren.at(i)->getSize() + pos};
         if (bottomRight.x > max.x)
             max.x = bottomRight.x;
         if (bottomRight.y > max.y)
diff --git a/es-core/src/components/SliderComponent.cpp b/es-core/src/components/SliderComponent.cpp
index 71dbe6fb8..35c84a26a 100644
--- a/es-core/src/components/SliderComponent.cpp
+++ b/es-core/src/components/SliderComponent.cpp
@@ -76,20 +76,20 @@ void SliderComponent::update(int deltaTime)
 
 void SliderComponent::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
     Renderer::setMatrix(trans);
 
     // Render suffix.
     if (mValueCache)
         mFont->renderTextCache(mValueCache.get());
 
-    float width =
-        mSize.x - mKnob.getSize().x -
-        (mValueCache ? mValueCache->metrics.size.x + (4.0f * Renderer::getScreenWidthModifier()) :
-                       0.0f);
+    float width{mSize.x - mKnob.getSize().x -
+                (mValueCache ?
+                     mValueCache->metrics.size.x + (4.0f * Renderer::getScreenWidthModifier()) :
+                     0.0f)};
 
     // Render line.
-    const float lineWidth = 2.0f * Renderer::getScreenHeightModifier();
+    const float lineWidth{2.0f * Renderer::getScreenHeightModifier()};
     Renderer::drawRect(mKnob.getSize().x / 2.0f, mSize.y / 2.0f - lineWidth / 2.0f, width,
                        lineWidth, 0x777777FF, 0x777777FF);
 
diff --git a/es-core/src/components/SwitchComponent.cpp b/es-core/src/components/SwitchComponent.cpp
index 975496a27..23f64dd24 100644
--- a/es-core/src/components/SwitchComponent.cpp
+++ b/es-core/src/components/SwitchComponent.cpp
@@ -44,7 +44,7 @@ bool SwitchComponent::input(InputConfig* config, Input input)
 
 void SwitchComponent::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
     mImage.render(trans);
     renderChildren(trans);
 }
diff --git a/es-core/src/components/TextComponent.cpp b/es-core/src/components/TextComponent.cpp
index 6e8191dda..3b268955e 100644
--- a/es-core/src/components/TextComponent.cpp
+++ b/es-core/src/components/TextComponent.cpp
@@ -60,7 +60,7 @@ TextComponent::TextComponent(Window* window,
 
 void TextComponent::onSizeChanged()
 {
-    mAutoCalcExtent = Vector2i((getSize().x == 0), (getSize().y == 0));
+    mAutoCalcExtent = glm::ivec2{(getSize().x == 0), (getSize().y == 0)};
     onTextChanged();
 }
 
@@ -120,7 +120,7 @@ void TextComponent::render(const glm::mat4& parentTrans)
     if (!isVisible())
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
 
     if (mRenderBackground) {
         Renderer::setMatrix(trans);
@@ -128,7 +128,7 @@ void TextComponent::render(const glm::mat4& parentTrans)
     }
 
     if (mTextCache) {
-        const glm::vec2& textSize = mTextCache->metrics.size;
+        const glm::vec2& textSize{mTextCache->metrics.size};
         float yOff = 0.0f;
         switch (mVerticalAlignment) {
             case ALIGN_TOP: {
@@ -147,7 +147,7 @@ void TextComponent::render(const glm::mat4& parentTrans)
                 break;
             }
         }
-        glm::vec3 off(0.0f, yOff, 0.0f);
+        glm::vec3 off{0.0f, yOff, 0.0f};
 
         if (Settings::getInstance()->getBool("DebugText")) {
             // Draw the "textbox" area, what we are aligned within.
@@ -189,11 +189,11 @@ void TextComponent::render(const glm::mat4& parentTrans)
 
 void TextComponent::calculateExtent()
 {
-    if (mAutoCalcExtent.x()) {
+    if (mAutoCalcExtent.x) {
         mSize = mFont->sizeText(mUppercase ? Utils::String::toUpper(mText) : mText, mLineSpacing);
     }
     else {
-        if (mAutoCalcExtent.y())
+        if (mAutoCalcExtent.y)
             mSize.y = mFont
                           ->sizeWrappedText(mUppercase ? Utils::String::toUpper(mText) : mText,
                                             getSize().x, mLineSpacing)
@@ -223,11 +223,11 @@ void TextComponent::onTextChanged()
         addAbbrev = newline != std::string::npos;
     }
 
-    glm::vec2 size = f->sizeText(text);
+    glm::vec2 size{f->sizeText(text)};
     if (!isMultiline && mSize.x > 0.0f && text.size() && (size.x > mSize.x || addAbbrev)) {
         // Abbreviate text.
         const std::string abbrev = "...";
-        glm::vec2 abbrevSize = f->sizeText(abbrev);
+        glm::vec2 abbrevSize{f->sizeText(abbrev)};
         // mMargin adds a margin around the text if it's abbreviated.
         float marginAdjustedSize = mSize.x - (mSize.x * mMargin);
 
@@ -240,12 +240,12 @@ void TextComponent::onTextChanged()
         text.append(abbrev);
 
         mTextCache = std::shared_ptr<TextCache>(
-            f->buildTextCache(text, glm::vec2({}), (mColor >> 8 << 8) | mOpacity, mSize.x,
+            f->buildTextCache(text, glm::vec2{}, (mColor >> 8 << 8) | mOpacity, mSize.x,
                               mHorizontalAlignment, mLineSpacing, mNoTopMargin));
     }
     else {
         mTextCache = std::shared_ptr<TextCache>(f->buildTextCache(
-            f->wrapText(text, mSize.x), glm::vec2({}), (mColor >> 8 << 8) | mOpacity, mSize.x,
+            f->wrapText(text, mSize.x), glm::vec2{}, (mColor >> 8 << 8) | mOpacity, mSize.x,
             mHorizontalAlignment, mLineSpacing, mNoTopMargin));
     }
 }
diff --git a/es-core/src/components/TextComponent.h b/es-core/src/components/TextComponent.h
index 8bf4cd0ed..58ac31f69 100644
--- a/es-core/src/components/TextComponent.h
+++ b/es-core/src/components/TextComponent.h
@@ -88,7 +88,7 @@ private:
     bool mRenderBackground;
 
     bool mUppercase;
-    Vector2i mAutoCalcExtent;
+    glm::ivec2 mAutoCalcExtent;
     std::shared_ptr<TextCache> mTextCache;
     Alignment mHorizontalAlignment;
     Alignment mVerticalAlignment;
diff --git a/es-core/src/components/TextEditComponent.cpp b/es-core/src/components/TextEditComponent.cpp
index 8d0c2f0e4..7ed097944 100644
--- a/es-core/src/components/TextEditComponent.cpp
+++ b/es-core/src/components/TextEditComponent.cpp
@@ -46,9 +46,9 @@ void TextEditComponent::onFocusLost()
 
 void TextEditComponent::onSizeChanged()
 {
-    mBox.fitTo(mSize, glm::vec3({}),
-               glm::vec2(-34.0f + mResolutionAdjustment,
-                         -32.0f - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier())));
+    mBox.fitTo(mSize, glm::vec3{},
+               glm::vec2{-34.0f + mResolutionAdjustment,
+                         -32.0f - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier())});
     onTextChanged(); // Wrap point probably changed.
 }
 
@@ -250,7 +250,7 @@ void TextEditComponent::onTextChanged()
 void TextEditComponent::onCursorChanged()
 {
     if (isMultiline()) {
-        glm::vec2 textSize = mFont->getWrappedTextCursorOffset(mText, getTextAreaSize().x, mCursor);
+        glm::vec2 textSize{mFont->getWrappedTextCursorOffset(mText, getTextAreaSize().x, mCursor)};
 
         // Need to scroll down?
         if (mScrollOffset.y + getTextAreaSize().y < textSize.y + mFont->getHeight())
@@ -260,7 +260,7 @@ void TextEditComponent::onCursorChanged()
             mScrollOffset.y = textSize.y;
     }
     else {
-        glm::vec2 cursorPos = mFont->sizeText(mText.substr(0, mCursor));
+        glm::vec2 cursorPos{mFont->sizeText(mText.substr(0, mCursor))};
 
         if (mScrollOffset.x + getTextAreaSize().x < cursorPos.x)
             mScrollOffset.x = cursorPos.x - getTextAreaSize().x;
@@ -271,24 +271,24 @@ void TextEditComponent::onCursorChanged()
 
 void TextEditComponent::render(const glm::mat4& parentTrans)
 {
-    glm::mat4 trans = getTransform() * parentTrans;
+    glm::mat4 trans{getTransform() * parentTrans};
     renderChildren(trans);
 
     // Text + cursor rendering.
     // Offset into our "text area" (padding).
-    trans = glm::translate(trans, glm::vec3(getTextAreaPos().x, getTextAreaPos().y, 0.0f));
+    trans = glm::translate(trans, glm::vec3{getTextAreaPos().x, getTextAreaPos().y, 0.0f});
 
-    Vector2i clipPos(static_cast<int>(trans[3].x), static_cast<int>(trans[3].y));
+    glm::ivec2 clipPos{static_cast<int>(trans[3].x), static_cast<int>(trans[3].y)};
     // Use "text area" size for clipping.
-    glm::vec3 dimScaled {};
+    glm::vec3 dimScaled{};
     dimScaled.x = std::fabs(trans[3].x + getTextAreaSize().x);
     dimScaled.y = std::fabs(trans[3].y + getTextAreaSize().y);
 
-    Vector2i clipDim(static_cast<int>(dimScaled.x - trans[3].x),
-                     static_cast<int>(dimScaled.y - trans[3].y));
+    glm::ivec2 clipDim{static_cast<int>(dimScaled.x - trans[3].x),
+                       static_cast<int>(dimScaled.y - trans[3].y)};
     Renderer::pushClipRect(clipPos, clipDim);
 
-    trans = glm::translate(trans, glm::vec3(-mScrollOffset.x, -mScrollOffset.y, 0.0f));
+    trans = glm::translate(trans, glm::vec3{-mScrollOffset.x, -mScrollOffset.y, 0.0f});
     Renderer::setMatrix(trans);
 
     if (mTextCache)
@@ -317,16 +317,16 @@ void TextEditComponent::render(const glm::mat4& parentTrans)
 
 glm::vec2 TextEditComponent::getTextAreaPos() const
 {
-    return glm::vec2(
+    return glm::vec2{
         (-mResolutionAdjustment + (TEXT_PADDING_HORIZ * Renderer::getScreenWidthModifier())) / 2.0f,
-        (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier()) / 2.0f);
+        (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier()) / 2.0f};
 }
 
 glm::vec2 TextEditComponent::getTextAreaSize() const
 {
-    return glm::vec2(mSize.x + mResolutionAdjustment -
+    return glm::vec2{mSize.x + mResolutionAdjustment -
                          (TEXT_PADDING_HORIZ * Renderer::getScreenWidthModifier()),
-                     mSize.y - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier()));
+                     mSize.y - (TEXT_PADDING_VERT * Renderer::getScreenHeightModifier())};
 }
 
 std::vector<HelpPrompt> TextEditComponent::getHelpPrompts()
diff --git a/es-core/src/components/TextListComponent.h b/es-core/src/components/TextListComponent.h
index 4b30a07ae..670c7b4ae 100644
--- a/es-core/src/components/TextListComponent.h
+++ b/es-core/src/components/TextListComponent.h
@@ -160,14 +160,14 @@ template <typename T> void TextListComponent<T>::render(const glm::mat4& parentT
     if (size() == 0)
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
-    std::shared_ptr<Font>& font = mFont;
+    glm::mat4 trans{parentTrans * getTransform()};
+    std::shared_ptr<Font>& font{mFont};
 
-    int startEntry = 0;
-    float y = 0;
+    int startEntry{0};
+    float y{0.0f};
 
-    const float entrySize =
-        std::max(font->getHeight(1.0), static_cast<float>(font->getSize())) * mLineSpacing;
+    const float entrySize{std::max(font->getHeight(1.0), static_cast<float>(font->getSize())) *
+                          mLineSpacing};
 
     // Number of entries that can fit on the screen simultaneously.
     int screenCount = static_cast<int>(mSize.y / entrySize + 0.5f);
@@ -206,13 +206,13 @@ template <typename T> void TextListComponent<T>::render(const glm::mat4& parentT
     }
 
     // Clip to inside margins.
-    glm::vec3 dim(mSize.x, mSize.y, 0.0f);
+    glm::vec3 dim{mSize.x, mSize.y, 0.0f};
     dim.x = (trans[0].x * dim.x + trans[3].x) - trans[3].x;
     dim.y = (trans[1].y * dim.y + trans[3].y) - trans[3].y;
 
     Renderer::pushClipRect(
-        Vector2i(static_cast<int>(trans[3].x + mHorizontalMargin), static_cast<int>(trans[3].y)),
-        Vector2i(static_cast<int>(dim.x - mHorizontalMargin * 2.0f), static_cast<int>(dim.y)));
+        glm::ivec2{static_cast<int>(trans[3].x + mHorizontalMargin), static_cast<int>(trans[3].y)},
+        glm::ivec2{static_cast<int>(dim.x - mHorizontalMargin * 2.0f), static_cast<int>(dim.y)});
 
     for (int i = startEntry; i < listCutoff; i++) {
         typename IList<TextListData, T>::Entry& entry = mEntries.at(static_cast<unsigned int>(i));
@@ -236,7 +236,7 @@ template <typename T> void TextListComponent<T>::render(const glm::mat4& parentT
         else
             entry.data.textCache->setColor(color);
 
-        glm::vec3 offset(0.0f, y, 0.0f);
+        glm::vec3 offset{0.0f, y, 0.0f};
 
         switch (mAlignment) {
             case ALIGN_LEFT:
@@ -257,12 +257,12 @@ template <typename T> void TextListComponent<T>::render(const glm::mat4& parentT
         }
 
         // Render text.
-        glm::mat4 drawTrans = trans;
+        glm::mat4 drawTrans{trans};
 
         // Currently selected item text might be scrolling.
         if (mCursor == i && mMarqueeOffset > 0)
             drawTrans = glm::translate(
-                drawTrans, offset - glm::vec3(static_cast<float>(mMarqueeOffset), 0.0f, 0.0f));
+                drawTrans, offset - glm::vec3{static_cast<float>(mMarqueeOffset), 0.0f, 0.0f});
         else
             drawTrans = glm::translate(drawTrans, offset);
 
@@ -278,7 +278,7 @@ template <typename T> void TextListComponent<T>::render(const glm::mat4& parentT
             mMarqueeScroll = true;
             drawTrans = trans;
             drawTrans = glm::translate(
-                drawTrans, offset - glm::vec3(static_cast<float>(mMarqueeOffset2), 0.0f, 0.0f));
+                drawTrans, offset - glm::vec3{static_cast<float>(mMarqueeOffset2), 0.0f, 0.0f});
             Renderer::setMatrix(drawTrans);
             font->renderTextCache(entry.data.textCache.get());
         }
diff --git a/es-core/src/components/VideoComponent.cpp b/es-core/src/components/VideoComponent.cpp
index 0395add15..3e4cb1700 100644
--- a/es-core/src/components/VideoComponent.cpp
+++ b/es-core/src/components/VideoComponent.cpp
@@ -176,7 +176,7 @@ void VideoComponent::render(const glm::mat4& parentTrans)
     if (!isVisible())
         return;
 
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
     GuiComponent::renderChildren(trans);
 
     Renderer::setMatrix(trans);
@@ -223,9 +223,9 @@ void VideoComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
     if (!elem)
         return;
 
-    glm::vec2 scale = getParent() ? getParent()->getSize() :
-                                    glm::vec2(static_cast<float>(Renderer::getScreenWidth()),
-                                              static_cast<float>(Renderer::getScreenHeight()));
+    glm::vec2 scale{getParent() ? getParent()->getSize() :
+                                  glm::vec2{static_cast<float>(Renderer::getScreenWidth()),
+                                            static_cast<float>(Renderer::getScreenHeight())}};
 
     if (properties & ThemeFlags::SIZE) {
         if (elem->has("size")) {
diff --git a/es-core/src/components/VideoFFmpegComponent.cpp b/es-core/src/components/VideoFFmpegComponent.cpp
index 3f679b38d..4209ff996 100644
--- a/es-core/src/components/VideoFFmpegComponent.cpp
+++ b/es-core/src/components/VideoFFmpegComponent.cpp
@@ -57,7 +57,7 @@ VideoFFmpegComponent::~VideoFFmpegComponent() { stopVideo(); }
 void VideoFFmpegComponent::setResize(float width, float height)
 {
     // This resize function is used when stretching videos to full screen in the video screensaver.
-    mTargetSize = glm::vec2(width, height);
+    mTargetSize = glm::vec2{width, height};
     mTargetIsMax = false;
     mStaticImage.setResize(width, height);
     resize();
@@ -67,7 +67,7 @@ void VideoFFmpegComponent::setMaxSize(float width, float height)
 {
     // This resize function is used in most instances, such as non-stretched video screensaver
     // and the gamelist videos.
-    mTargetSize = glm::vec2(width, height);
+    mTargetSize = glm::vec2{width, height};
     mTargetIsMax = true;
     mStaticImage.setMaxSize(width, height);
     resize();
@@ -78,15 +78,15 @@ void VideoFFmpegComponent::resize()
     if (!mTexture)
         return;
 
-    const glm::vec2 textureSize(static_cast<float>(mVideoWidth), static_cast<float>(mVideoHeight));
+    const glm::vec2 textureSize{static_cast<float>(mVideoWidth), static_cast<float>(mVideoHeight)};
 
-    if (textureSize == glm::vec2({}))
+    if (textureSize == glm::vec2{})
         return;
 
     if (mTargetIsMax) {
         mSize = textureSize;
 
-        glm::vec2 resizeScale((mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y));
+        glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
 
         if (resizeScale.x < resizeScale.y) {
             mSize.x *= resizeScale.x;
@@ -97,13 +97,13 @@ void VideoFFmpegComponent::resize()
             mSize.y *= resizeScale.y;
         }
 
-        mSize.y = std::round(mSize[1.0f]);
+        mSize.y = std::round(mSize.y);
         mSize.x = (mSize.y / textureSize.y) * textureSize.x;
     }
     else {
         // If both components are set, we just stretch.
         // If no components are set, we don't resize at all.
-        mSize = mTargetSize == glm::vec2({}) ? textureSize : mTargetSize;
+        mSize = mTargetSize == glm::vec2{} ? textureSize : mTargetSize;
 
         // If only one component is set, we resize in a way that maintains aspect ratio.
         if (!mTargetSize.x && mTargetSize.y) {
@@ -122,7 +122,7 @@ void VideoFFmpegComponent::resize()
 void VideoFFmpegComponent::render(const glm::mat4& parentTrans)
 {
     VideoComponent::render(parentTrans);
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
     GuiComponent::renderChildren(trans);
 
     if (mIsPlaying && mFormatContext) {
@@ -146,10 +146,10 @@ void VideoFFmpegComponent::render(const glm::mat4& parentTrans)
         }
 
         // clang-format off
-        vertices[0] = { { 0.0f     , 0.0f      }, { 0.0f, 0.0f }, color };
-        vertices[1] = { { 0.0f     , mSize.y   }, { 0.0f, 1.0f }, color };
-        vertices[2] = { { mSize.x  , 0.0f      }, { 1.0f, 0.0f }, color };
-        vertices[3] = { { mSize.x  , mSize.y   }, { 1.0f, 1.0f }, color };
+        vertices[0] = {{0.0f     , 0.0f   }, {0.0f, 0.0f}, color};
+        vertices[1] = {{0.0f     , mSize.y}, {0.0f, 1.0f}, color};
+        vertices[2] = {{mSize.x  , 0.0f   }, {1.0f, 0.0f}, color};
+        vertices[3] = {{mSize.x  , mSize.y}, {1.0f, 1.0f}, color};
         // clang-format on
 
         // Round vertices.
@@ -290,7 +290,7 @@ bool VideoFFmpegComponent::setupVideoFilters()
 {
     int returnValue = 0;
     char errorMessage[512];
-    const enum AVPixelFormat outPixFormats[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE };
+    const enum AVPixelFormat outPixFormats[] = {AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE};
 
     mVFilterInputs = avfilter_inout_alloc();
     mVFilterOutputs = avfilter_inout_alloc();
@@ -416,8 +416,8 @@ bool VideoFFmpegComponent::setupAudioFilters()
 {
     int returnValue = 0;
     char errorMessage[512];
-    const int outSampleRates[] = { AudioManager::getInstance()->sAudioFormat.freq, -1 };
-    const enum AVSampleFormat outSampleFormats[] = { AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE };
+    const int outSampleRates[] = {AudioManager::getInstance()->sAudioFormat.freq, -1};
+    const enum AVSampleFormat outSampleFormats[] = {AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE};
 
     mAFilterInputs = avfilter_inout_alloc();
     mAFilterOutputs = avfilter_inout_alloc();
@@ -798,7 +798,7 @@ void VideoFFmpegComponent::calculateBlackRectangle()
     // otherwise it will exactly match the video size. The reason to add a black rectangle
     // behind videos in this second instance is that the scanline rendering will make the
     // video partially transparent so this may avoid some unforseen issues with some themes.
-    if (mVideoAreaPos != glm::vec2({}) && mVideoAreaSize != glm::vec2({})) {
+    if (mVideoAreaPos != glm::vec2{} && mVideoAreaSize != glm::vec2{}) {
         mVideoRectangleCoords.clear();
 
         if (Settings::getInstance()->getBool("GamelistVideoPillarbox")) {
diff --git a/es-core/src/components/VideoVlcComponent.cpp b/es-core/src/components/VideoVlcComponent.cpp
index 0dfecda1c..9c3fc3084 100644
--- a/es-core/src/components/VideoVlcComponent.cpp
+++ b/es-core/src/components/VideoVlcComponent.cpp
@@ -63,7 +63,7 @@ void VideoVlcComponent::deinit()
 void VideoVlcComponent::setResize(float width, float height)
 {
     // This resize function is used when stretching videos to full screen in the video screensaver.
-    mTargetSize = glm::vec2(width, height);
+    mTargetSize = glm::vec2{width, height};
     mTargetIsMax = false;
     mStaticImage.setResize(width, height);
     resize();
@@ -73,7 +73,7 @@ void VideoVlcComponent::setMaxSize(float width, float height)
 {
     // This resize function is used in most instances, such as non-stretched video screensaver
     // and the gamelist videos.
-    mTargetSize = glm::vec2(width, height);
+    mTargetSize = glm::vec2{width, height};
     mTargetIsMax = true;
     mStaticImage.setMaxSize(width, height);
     resize();
@@ -83,7 +83,7 @@ void VideoVlcComponent::setupVLC()
 {
     // If VLC hasn't been initialised yet then do it now.
     if (!mVLC) {
-        const char* args[] = { "--quiet" };
+        const char* args[] = {"--quiet"};
 
 #if defined(__APPLE__)
         // It's required to set the VLC_PLUGIN_PATH variable on macOS, or the libVLC
@@ -129,13 +129,13 @@ void VideoVlcComponent::resize()
 
     const glm::vec2 textureSize(static_cast<float>(mVideoWidth), static_cast<float>(mVideoHeight));
 
-    if (textureSize == glm::vec2({}))
+    if (textureSize == glm::vec2{})
         return;
 
     if (mTargetIsMax) {
         mSize = textureSize;
 
-        glm::vec2 resizeScale((mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y));
+        glm::vec2 resizeScale{(mTargetSize.x / mSize.x), (mTargetSize.y / mSize.y)};
 
         if (resizeScale.x < resizeScale.y) {
             mSize.x *= resizeScale.x;
@@ -152,7 +152,7 @@ void VideoVlcComponent::resize()
     else {
         // If both components are set, we just stretch.
         // If no components are set, we don't resize at all.
-        mSize = mTargetSize == glm::vec2({}) ? textureSize : mTargetSize;
+        mSize = mTargetSize == glm::vec2{} ? textureSize : mTargetSize;
 
         // If only one component is set, we resize in a way that maintains aspect ratio.
         if (!mTargetSize.x && mTargetSize.y) {
@@ -179,7 +179,7 @@ void VideoVlcComponent::render(const glm::mat4& parentTrans)
         setAudioVolume();
 
     VideoComponent::render(parentTrans);
-    glm::mat4 trans = parentTrans * getTransform();
+    glm::mat4 trans{parentTrans * getTransform()};
     GuiComponent::renderChildren(trans);
 
     // Check the actual VLC state, i.e. if the video is really playing rather than
@@ -213,10 +213,10 @@ void VideoVlcComponent::render(const glm::mat4& parentTrans)
         }
 
         // clang-format off
-        vertices[0] = { { 0.0f   , 0.0f    }, { 0.0f, 0.0f }, color };
-        vertices[1] = { { 0.0f   , mSize.y }, { 0.0f, 1.0f }, color };
-        vertices[2] = { { mSize.x, 0.0f    }, { 1.0f, 0.0f }, color };
-        vertices[3] = { { mSize.x, mSize.y }, { 1.0f, 1.0f }, color };
+        vertices[0] = {{0.0f   , 0.0f   }, {0.0f, 0.0f}, color};
+        vertices[1] = {{0.0f   , mSize.y}, {0.0f, 1.0f}, color};
+        vertices[2] = {{mSize.x, 0.0f   }, {1.0f, 0.0f}, color};
+        vertices[3] = {{mSize.x, mSize.y}, {1.0f, 1.0f}, color};
         // clang-format on
 
         // Round vertices.
@@ -255,7 +255,7 @@ void VideoVlcComponent::calculateBlackRectangle()
     // otherwise it will exactly match the video size. The reason to add a black rectangle
     // behind videos in this second instance is that the scanline rendering will make the
     // video partially transparent so this may avoid some unforseen issues with some themes.
-    if (mVideoAreaPos != glm::vec2({}) && mVideoAreaSize != glm::vec2({})) {
+    if (mVideoAreaPos != glm::vec2{} && mVideoAreaSize != glm::vec2{}) {
         mVideoRectangleCoords.clear();
 
         if (Settings::getInstance()->getBool("GamelistVideoPillarbox")) {
diff --git a/es-core/src/guis/GuiComplexTextEditPopup.cpp b/es-core/src/guis/GuiComplexTextEditPopup.cpp
index 848ee62da..15f16b781 100644
--- a/es-core/src/guis/GuiComplexTextEditPopup.cpp
+++ b/es-core/src/guis/GuiComplexTextEditPopup.cpp
@@ -35,7 +35,7 @@ GuiComplexTextEditPopup::GuiComplexTextEditPopup(
     : GuiComponent(window)
     , mHelpStyle(helpstyle)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(1, 5))
+    , mGrid(window, glm::ivec2{1, 5})
     , mMultiLine(multiLine)
     , mInitValue(initValue)
     , mOkCallback(okCallback)
@@ -75,12 +75,12 @@ GuiComplexTextEditPopup::GuiComplexTextEditPopup(
 
     mButtonGrid = makeButtonGrid(mWindow, buttons);
 
-    mGrid.setEntry(mTitle, Vector2i(0, 0), false, true);
-    mGrid.setEntry(mInfoString1, Vector2i(0, 1), false, true);
-    mGrid.setEntry(mInfoString2, Vector2i(0, 2), false, false);
-    mGrid.setEntry(mText, Vector2i(0, 3), true, false, Vector2i(1, 1),
+    mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true);
+    mGrid.setEntry(mInfoString1, glm::ivec2{0, 1}, false, true);
+    mGrid.setEntry(mInfoString2, glm::ivec2{0, 2}, false, false);
+    mGrid.setEntry(mText, glm::ivec2{0, 3}, true, false, glm::ivec2{1, 1},
                    GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
-    mGrid.setEntry(mButtonGrid, Vector2i(0, 4), true, false);
+    mGrid.setEntry(mButtonGrid, glm::ivec2{0, 4}, true, false);
     mGrid.setRowHeightPerc(1, 0.15f, true);
 
     float textHeight = mText->getFont()->getHeight();
@@ -106,7 +106,7 @@ GuiComplexTextEditPopup::GuiComplexTextEditPopup(
 
 void GuiComplexTextEditPopup::onSizeChanged()
 {
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
     mText->setSize(mSize.x - 40.0f, mText->getSize().y);
 
     // Update grid.
diff --git a/es-core/src/guis/GuiDetectDevice.cpp b/es-core/src/guis/GuiDetectDevice.cpp
index 7062f97b4..8159f9bb2 100644
--- a/es-core/src/guis/GuiDetectDevice.cpp
+++ b/es-core/src/guis/GuiDetectDevice.cpp
@@ -25,7 +25,7 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
     , mFirstRun(firstRun)
     , mForcedConfig(forcedConfig)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(1, 5))
+    , mGrid(window, glm::ivec2{1, 5})
 {
     mHoldingConfig = nullptr;
     mHoldTime = 0;
@@ -38,7 +38,8 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
     mTitle =
         std::make_shared<TextComponent>(mWindow, firstRun ? "WELCOME" : "CONFIGURE INPUT DEVICE",
                                         Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
-    mGrid.setEntry(mTitle, Vector2i(0, 0), false, true, Vector2i(1, 1), GridFlags::BORDER_BOTTOM);
+    mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true, glm::ivec2{1, 1},
+                   GridFlags::BORDER_BOTTOM);
 
     // Device info.
     std::stringstream deviceInfo;
@@ -54,7 +55,7 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
 
     mDeviceInfo = std::make_shared<TextComponent>(
         mWindow, deviceInfo.str(), Font::get(FONT_SIZE_SMALL), 0x999999FF, ALIGN_CENTER);
-    mGrid.setEntry(mDeviceInfo, Vector2i(0, 1), false, true);
+    mGrid.setEntry(mDeviceInfo, glm::ivec2{0, 1}, false, true);
 
     // Message.
     if (numDevices > 0) {
@@ -68,18 +69,18 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
             0x777777FF, ALIGN_CENTER);
     }
 
-    mGrid.setEntry(mMsg1, Vector2i(0, 2), false, true);
+    mGrid.setEntry(mMsg1, glm::ivec2{0, 2}, false, true);
 
     const std::string msg2str =
         firstRun ? "PRESS ESC TO SKIP (OR F4 TO QUIT AT ANY TIME)" : "PRESS ESC TO CANCEL";
     mMsg2 = std::make_shared<TextComponent>(mWindow, msg2str, Font::get(FONT_SIZE_SMALL),
                                             0x777777FF, ALIGN_CENTER);
-    mGrid.setEntry(mMsg2, Vector2i(0, 3), false, true);
+    mGrid.setEntry(mMsg2, glm::ivec2{0, 3}, false, true);
 
     // Currently held device.
     mDeviceHeld = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_MEDIUM),
                                                   0xFFFFFFFF, ALIGN_CENTER);
-    mGrid.setEntry(mDeviceHeld, Vector2i(0, 4), false, true);
+    mGrid.setEntry(mDeviceHeld, glm::ivec2{0, 4}, false, true);
 
     // Adjust the width relative to the aspect ratio of the screen to make the GUI look coherent
     // regardless of screen type. The 1.778 aspect ratio value is the 16:9 reference.
@@ -93,7 +94,7 @@ GuiDetectDevice::GuiDetectDevice(Window* window,
 
 void GuiDetectDevice::onSizeChanged()
 {
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     // Grid.
     mGrid.setSize(mSize);
diff --git a/es-core/src/guis/GuiInputConfig.cpp b/es-core/src/guis/GuiInputConfig.cpp
index 997d570e2..cac72bc45 100644
--- a/es-core/src/guis/GuiInputConfig.cpp
+++ b/es-core/src/guis/GuiInputConfig.cpp
@@ -33,7 +33,7 @@ GuiInputConfig::GuiInputConfig(Window* window,
                                const std::function<void()>& okCallback)
     : GuiComponent(window)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(1, 7))
+    , mGrid(window, glm::ivec2{1, 7})
     , mTargetConfig(target)
     , mHoldingInput(false)
 {
@@ -54,11 +54,11 @@ GuiInputConfig::GuiInputConfig(Window* window,
     addChild(&mGrid);
 
     // 0 is a spacer row.
-    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false);
+    mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), glm::ivec2{0, 0}, false);
 
     mTitle = std::make_shared<TextComponent>(mWindow, "CONFIGURING", Font::get(FONT_SIZE_LARGE),
                                              0x555555FF, ALIGN_CENTER);
-    mGrid.setEntry(mTitle, Vector2i(0, 1), false, true);
+    mGrid.setEntry(mTitle, glm::ivec2{0, 1}, false, true);
 
     std::stringstream ss;
     if (target->getDeviceId() == DEVICE_KEYBOARD)
@@ -70,7 +70,7 @@ GuiInputConfig::GuiInputConfig(Window* window,
     mSubtitle1 =
         std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(ss.str()),
                                         Font::get(FONT_SIZE_MEDIUM), 0x555555FF, ALIGN_CENTER);
-    mGrid.setEntry(mSubtitle1, Vector2i(0, 2), false, true);
+    mGrid.setEntry(mSubtitle1, glm::ivec2{0, 2}, false, true);
 
     mSubtitle2 =
         std::make_shared<TextComponent>(mWindow, "HOLD ANY BUTTON 1 SECOND TO SKIP",
@@ -78,11 +78,11 @@ GuiInputConfig::GuiInputConfig(Window* window,
     // The opacity will be set to visible for any row that is skippable.
     mSubtitle2->setOpacity(0);
 
-    mGrid.setEntry(mSubtitle2, Vector2i(0, 3), false, true);
+    mGrid.setEntry(mSubtitle2, glm::ivec2{0, 3}, false, true);
 
     // 4 is a spacer row.
     mList = std::make_shared<ComponentList>(mWindow);
-    mGrid.setEntry(mList, Vector2i(0, 5), true, true);
+    mGrid.setEntry(mList, glm::ivec2{0, 5}, true, true);
 
     for (int i = 0; i < inputCount; i++) {
         ComponentListRow row;
@@ -184,7 +184,7 @@ GuiInputConfig::GuiInputConfig(Window* window,
                                                         [this, okFunction] { okFunction(); }));
 
     mButtonGrid = makeButtonGrid(mWindow, buttons);
-    mGrid.setEntry(mButtonGrid, Vector2i(0, 6), true, false);
+    mGrid.setEntry(mButtonGrid, glm::ivec2{0, 6}, true, false);
 
     // Adjust the width relative to the aspect ratio of the screen to make the GUI look coherent
     // regardless of screen type. The 1.778 aspect ratio value is the 16:9 reference.
@@ -201,67 +201,67 @@ void GuiInputConfig::populateConfigList()
     std::string controllerType = Settings::getInstance()->getString("InputControllerType");
 
     // clang-format off
-    sGuiInputConfigList[0] = { "Up",    false, "D-PAD UP",    ":/help/dpad_up.svg" };
-    sGuiInputConfigList[1] = { "Down",  false, "D-PAD DOWN",  ":/help/dpad_down.svg" };
-    sGuiInputConfigList[2] = { "Left",  false, "D-PAD LEFT",  ":/help/dpad_left.svg" };
-    sGuiInputConfigList[3] = { "Right", false, "D-PAD RIGHT", ":/help/dpad_right.svg" };
+    sGuiInputConfigList[0] = {"Up",    false, "D-PAD UP",    ":/help/dpad_up.svg"};
+    sGuiInputConfigList[1] = {"Down",  false, "D-PAD DOWN",  ":/help/dpad_down.svg"};
+    sGuiInputConfigList[2] = {"Left",  false, "D-PAD LEFT",  ":/help/dpad_left.svg"};
+    sGuiInputConfigList[3] = {"Right", false, "D-PAD RIGHT", ":/help/dpad_right.svg"};
 
     if (controllerType == "snes") {
-        sGuiInputConfigList[4] = { "Back",  false, "SELECT",    ":/help/button_back_SNES.svg" };
-        sGuiInputConfigList[5] = { "Start", false, "START",     ":/help/button_start_SNES.svg" };
-        sGuiInputConfigList[6] = { "A",     false, "B",         ":/help/mbuttons_a_SNES.svg" };
-        sGuiInputConfigList[7] = { "B",     false, "A",         ":/help/mbuttons_b_SNES.svg" };
-        sGuiInputConfigList[8] = { "X",     true,  "Y",         ":/help/mbuttons_x_SNES.svg" };
-        sGuiInputConfigList[9] = { "Y",     true,  "X",         ":/help/mbuttons_y_SNES.svg" };
+        sGuiInputConfigList[4] = {"Back",  false, "SELECT",    ":/help/button_back_SNES.svg"};
+        sGuiInputConfigList[5] = {"Start", false, "START",     ":/help/button_start_SNES.svg"};
+        sGuiInputConfigList[6] = {"A",     false, "B",         ":/help/mbuttons_a_SNES.svg"};
+        sGuiInputConfigList[7] = {"B",     false, "A",         ":/help/mbuttons_b_SNES.svg"};
+        sGuiInputConfigList[8] = {"X",     true,  "Y",         ":/help/mbuttons_x_SNES.svg"};
+        sGuiInputConfigList[9] = {"Y",     true,  "X",         ":/help/mbuttons_y_SNES.svg"};
     }
     else if (controllerType == "ps4") {
-        sGuiInputConfigList[4] = { "Back",  false, "SHARE",     ":/help/button_back_PS4.svg" };
-        sGuiInputConfigList[5] = { "Start", false, "OPTIONS",   ":/help/button_start_PS4.svg" };
-        sGuiInputConfigList[6] = { "A",     false, "CROSS",     ":/help/mbuttons_a_PS.svg" };
-        sGuiInputConfigList[7] = { "B",     false, "CIRCLE",    ":/help/mbuttons_b_PS.svg" };
-        sGuiInputConfigList[8] = { "X",     true,  "SQUARE",    ":/help/mbuttons_x_PS.svg" };
-        sGuiInputConfigList[9] = { "Y",     true,  "TRIANGLE",  ":/help/mbuttons_y_PS.svg" };
+        sGuiInputConfigList[4] = {"Back",  false, "SHARE",     ":/help/button_back_PS4.svg"};
+        sGuiInputConfigList[5] = {"Start", false, "OPTIONS",   ":/help/button_start_PS4.svg"};
+        sGuiInputConfigList[6] = {"A",     false, "CROSS",     ":/help/mbuttons_a_PS.svg"};
+        sGuiInputConfigList[7] = {"B",     false, "CIRCLE",    ":/help/mbuttons_b_PS.svg"};
+        sGuiInputConfigList[8] = {"X",     true,  "SQUARE",    ":/help/mbuttons_x_PS.svg"};
+        sGuiInputConfigList[9] = {"Y",     true,  "TRIANGLE",  ":/help/mbuttons_y_PS.svg"};
     }
     else if (controllerType == "ps5") {
-        sGuiInputConfigList[4] = { "Back",  false, "CREATE",    ":/help/button_back_PS5.svg" };
-        sGuiInputConfigList[5] = { "Start", false, "OPTIONS",   ":/help/button_start_PS5.svg" };
-        sGuiInputConfigList[6] = { "A",     false, "CROSS",     ":/help/mbuttons_a_PS.svg" };
-        sGuiInputConfigList[7] = { "B",     false, "CIRCLE",    ":/help/mbuttons_b_PS.svg" };
-        sGuiInputConfigList[8] = { "X",     true,  "SQUARE",    ":/help/mbuttons_x_PS.svg" };
-        sGuiInputConfigList[9] = { "Y",     true,  "TRIANGLE",  ":/help/mbuttons_y_PS.svg" };
+        sGuiInputConfigList[4] = {"Back",  false, "CREATE",    ":/help/button_back_PS5.svg"};
+        sGuiInputConfigList[5] = {"Start", false, "OPTIONS",   ":/help/button_start_PS5.svg"};
+        sGuiInputConfigList[6] = {"A",     false, "CROSS",     ":/help/mbuttons_a_PS.svg"};
+        sGuiInputConfigList[7] = {"B",     false, "CIRCLE",    ":/help/mbuttons_b_PS.svg"};
+        sGuiInputConfigList[8] = {"X",     true,  "SQUARE",    ":/help/mbuttons_x_PS.svg"};
+        sGuiInputConfigList[9] = {"Y",     true,  "TRIANGLE",  ":/help/mbuttons_y_PS.svg"};
     }
     else if (controllerType == "xbox360") {
-        sGuiInputConfigList[4] = { "Back",  false, "BACK",      ":/help/button_back_XBOX360.svg" };
-        sGuiInputConfigList[5] = { "Start", false, "START",     ":/help/button_start_XBOX360.svg" };
-        sGuiInputConfigList[6] = { "A",     false, "A",         ":/help/mbuttons_a_XBOX.svg" };
-        sGuiInputConfigList[7] = { "B",     false, "B",         ":/help/mbuttons_b_XBOX.svg" };
-        sGuiInputConfigList[8] = { "X",     true,  "X",         ":/help/mbuttons_x_XBOX.svg" };
-        sGuiInputConfigList[9] = { "Y",     true,  "Y",         ":/help/mbuttons_y_XBOX.svg" };
+        sGuiInputConfigList[4] = {"Back",  false, "BACK",      ":/help/button_back_XBOX360.svg"};
+        sGuiInputConfigList[5] = {"Start", false, "START",     ":/help/button_start_XBOX360.svg"};
+        sGuiInputConfigList[6] = {"A",     false, "A",         ":/help/mbuttons_a_XBOX.svg"};
+        sGuiInputConfigList[7] = {"B",     false, "B",         ":/help/mbuttons_b_XBOX.svg"};
+        sGuiInputConfigList[8] = {"X",     true,  "X",         ":/help/mbuttons_x_XBOX.svg"};
+        sGuiInputConfigList[9] = {"Y",     true,  "Y",         ":/help/mbuttons_y_XBOX.svg"};
     }
     else {
         // Xbox One and later.
-        sGuiInputConfigList[4] = { "Back",  false, "VIEW", ":/help/button_back_XBOX.svg" };
-        sGuiInputConfigList[5] = { "Start", false, "MENU", ":/help/button_start_XBOX.svg" };
-        sGuiInputConfigList[6] = { "A",     false, "A",    ":/help/mbuttons_a_XBOX.svg" };
-        sGuiInputConfigList[7] = { "B",     false, "B",    ":/help/mbuttons_b_XBOX.svg" };
-        sGuiInputConfigList[8] = { "X",     true,  "X",    ":/help/mbuttons_x_XBOX.svg" };
-        sGuiInputConfigList[9] = { "Y",     true,  "Y",    ":/help/mbuttons_y_XBOX.svg" };
+        sGuiInputConfigList[4] = {"Back",  false, "VIEW", ":/help/button_back_XBOX.svg"};
+        sGuiInputConfigList[5] = {"Start", false, "MENU", ":/help/button_start_XBOX.svg"};
+        sGuiInputConfigList[6] = {"A",     false, "A",    ":/help/mbuttons_a_XBOX.svg"};
+        sGuiInputConfigList[7] = {"B",     false, "B",    ":/help/mbuttons_b_XBOX.svg"};
+        sGuiInputConfigList[8] = {"X",     true,  "X",    ":/help/mbuttons_x_XBOX.svg"};
+        sGuiInputConfigList[9] = {"Y",     true,  "Y",    ":/help/mbuttons_y_XBOX.svg"};
     }
 
-    sGuiInputConfigList[10] = { "LeftShoulder",         true, "LEFT SHOULDER",          ":/help/button_l.svg" };
-    sGuiInputConfigList[11] = { "RightShoulder",        true, "RIGHT SHOULDER",         ":/help/button_r.svg" };
-    sGuiInputConfigList[12] = { "LeftTrigger",          true, "LEFT TRIGGER",           ":/help/button_lt.svg" };
-    sGuiInputConfigList[13] = { "RightTrigger",         true, "RIGHT TRIGGER",          ":/help/button_rt.svg" };
-    sGuiInputConfigList[14] = { "LeftThumbstickUp",     true, "LEFT THUMBSTICK UP",     ":/help/thumbstick_up.svg" };
-    sGuiInputConfigList[15] = { "LeftThumbstickDown",   true, "LEFT THUMBSTICK DOWN",   ":/help/thumbstick_down.svg" };
-    sGuiInputConfigList[16] = { "LeftThumbstickLeft",   true, "LEFT THUMBSTICK LEFT",   ":/help/thumbstick_left.svg" };
-    sGuiInputConfigList[17] = { "LeftThumbstickRight",  true, "LEFT THUMBSTICK RIGHT",  ":/help/thumbstick_right.svg" };
-    sGuiInputConfigList[18] = { "LeftThumbstickClick",  true, "LEFT THUMBSTICK CLICK",  ":/help/thumbstick_click.svg" };
-    sGuiInputConfigList[19] = { "RightThumbstickUp",    true, "RIGHT THUMBSTICK UP",    ":/help/thumbstick_up.svg" };
-    sGuiInputConfigList[20] = { "RightThumbstickDown",  true, "RIGHT THUMBSTICK DOWN",  ":/help/thumbstick_down.svg" };
-    sGuiInputConfigList[21] = { "RightThumbstickLeft",  true, "RIGHT THUMBSTICK LEFT",  ":/help/thumbstick_left.svg" };
-    sGuiInputConfigList[22] = { "RightThumbstickRight", true, "RIGHT THUMBSTICK RIGHT", ":/help/thumbstick_right.svg" };
-    sGuiInputConfigList[23] = { "RightThumbstickClick", true, "RIGHT THUMBSTICK CLICK", ":/help/thumbstick_click.svg" };
+    sGuiInputConfigList[10] = {"LeftShoulder",         true, "LEFT SHOULDER",          ":/help/button_l.svg"};
+    sGuiInputConfigList[11] = {"RightShoulder",        true, "RIGHT SHOULDER",         ":/help/button_r.svg"};
+    sGuiInputConfigList[12] = {"LeftTrigger",          true, "LEFT TRIGGER",           ":/help/button_lt.svg"};
+    sGuiInputConfigList[13] = {"RightTrigger",         true, "RIGHT TRIGGER",          ":/help/button_rt.svg"};
+    sGuiInputConfigList[14] = {"LeftThumbstickUp",     true, "LEFT THUMBSTICK UP",     ":/help/thumbstick_up.svg"};
+    sGuiInputConfigList[15] = {"LeftThumbstickDown",   true, "LEFT THUMBSTICK DOWN",   ":/help/thumbstick_down.svg"};
+    sGuiInputConfigList[16] = {"LeftThumbstickLeft",   true, "LEFT THUMBSTICK LEFT",   ":/help/thumbstick_left.svg"};
+    sGuiInputConfigList[17] = {"LeftThumbstickRight",  true, "LEFT THUMBSTICK RIGHT",  ":/help/thumbstick_right.svg"};
+    sGuiInputConfigList[18] = {"LeftThumbstickClick",  true, "LEFT THUMBSTICK CLICK",  ":/help/thumbstick_click.svg"};
+    sGuiInputConfigList[19] = {"RightThumbstickUp",    true, "RIGHT THUMBSTICK UP",    ":/help/thumbstick_up.svg"};
+    sGuiInputConfigList[20] = {"RightThumbstickDown",  true, "RIGHT THUMBSTICK DOWN",  ":/help/thumbstick_down.svg"};
+    sGuiInputConfigList[21] = {"RightThumbstickLeft",  true, "RIGHT THUMBSTICK LEFT",  ":/help/thumbstick_left.svg"};
+    sGuiInputConfigList[22] = {"RightThumbstickRight", true, "RIGHT THUMBSTICK RIGHT", ":/help/thumbstick_right.svg"};
+    sGuiInputConfigList[23] = {"RightThumbstickClick", true, "RIGHT THUMBSTICK CLICK", ":/help/thumbstick_click.svg"};
     // clang-format on
 }
 
@@ -293,7 +293,7 @@ void GuiInputConfig::update(int deltaTime)
 
 void GuiInputConfig::onSizeChanged()
 {
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     // Update grid.
     mGrid.setSize(mSize);
@@ -313,7 +313,7 @@ void GuiInputConfig::rowDone()
             // At bottom of list, we're done.
             mConfiguringAll = false;
             mConfiguringRow = false;
-            mGrid.moveCursor(Vector2i(0, 1));
+            mGrid.moveCursor(glm::ivec2{0, 1});
         }
         else {
             // On another row.
diff --git a/es-core/src/guis/GuiMsgBox.cpp b/es-core/src/guis/GuiMsgBox.cpp
index a96e41c42..fa7dc2823 100644
--- a/es-core/src/guis/GuiMsgBox.cpp
+++ b/es-core/src/guis/GuiMsgBox.cpp
@@ -28,7 +28,7 @@ GuiMsgBox::GuiMsgBox(Window* window,
     : GuiComponent(window)
     , mHelpStyle(helpstyle)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(1, 2))
+    , mGrid(window, glm::ivec2{1, 2})
     , mDisableBackButton(disableBackButton)
     , mDeleteOnButtonPress(deleteOnButtonPress)
 {
@@ -43,7 +43,7 @@ GuiMsgBox::GuiMsgBox(Window* window,
 
     mMsg = std::make_shared<TextComponent>(mWindow, text, Font::get(FONT_SIZE_MEDIUM), 0x777777FF,
                                            ALIGN_CENTER);
-    mGrid.setEntry(mMsg, Vector2i(0, 0), false, false);
+    mGrid.setEntry(mMsg, glm::ivec2{0, 0}, false, false);
 
     // Create the buttons.
     mButtons.push_back(std::make_shared<ButtonComponent>(
@@ -71,7 +71,8 @@ GuiMsgBox::GuiMsgBox(Window* window,
 
     // Put the buttons into a ComponentGrid.
     mButtonGrid = makeButtonGrid(mWindow, mButtons);
-    mGrid.setEntry(mButtonGrid, Vector2i(0, 1), true, false, Vector2i(1, 1), GridFlags::BORDER_TOP);
+    mGrid.setEntry(mButtonGrid, glm::ivec2{0, 1}, true, false, glm::ivec2{1, 1},
+                   GridFlags::BORDER_TOP);
 
     // Decide final width.
     if (mMsg->getSize().x < width && mButtonGrid->getSize().x < width) {
@@ -160,7 +161,7 @@ void GuiMsgBox::onSizeChanged()
                   mGrid.getRowHeight(0));
     mGrid.onSizeChanged();
 
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 }
 
 void GuiMsgBox::deleteMeAndCall(const std::function<void()>& func)
diff --git a/es-core/src/guis/GuiTextEditPopup.cpp b/es-core/src/guis/GuiTextEditPopup.cpp
index 0917845bb..ffadf4ed7 100644
--- a/es-core/src/guis/GuiTextEditPopup.cpp
+++ b/es-core/src/guis/GuiTextEditPopup.cpp
@@ -25,7 +25,7 @@ GuiTextEditPopup::GuiTextEditPopup(Window* window,
     : GuiComponent(window)
     , mHelpStyle(helpstyle)
     , mBackground(window, ":/graphics/frame.svg")
-    , mGrid(window, Vector2i(1, 3))
+    , mGrid(window, glm::ivec2{1, 3})
     , mMultiLine(multiLine)
     , mInitValue(initValue)
     , mOkCallback(okCallback)
@@ -53,10 +53,10 @@ GuiTextEditPopup::GuiTextEditPopup(Window* window,
 
     mButtonGrid = makeButtonGrid(mWindow, buttons);
 
-    mGrid.setEntry(mTitle, Vector2i(0, 0), false, true);
-    mGrid.setEntry(mText, Vector2i(0, 1), true, false, Vector2i(1, 1),
+    mGrid.setEntry(mTitle, glm::ivec2{0, 0}, false, true);
+    mGrid.setEntry(mText, glm::ivec2{0, 1}, true, false, glm::ivec2{1, 1},
                    GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
-    mGrid.setEntry(mButtonGrid, Vector2i(0, 2), true, false);
+    mGrid.setEntry(mButtonGrid, glm::ivec2{0, 2}, true, false);
 
     float textHeight = mText->getFont()->getHeight();
 
@@ -78,7 +78,7 @@ GuiTextEditPopup::GuiTextEditPopup(Window* window,
 
 void GuiTextEditPopup::onSizeChanged()
 {
-    mBackground.fitTo(mSize, glm::vec3({}), glm::vec2(-32.0f, -32.0f));
+    mBackground.fitTo(mSize, glm::vec3{}, glm::vec2{-32.0f, -32.0f});
 
     mText->setSize(mSize.x - 40.0f, mText->getSize().y);
 
diff --git a/es-core/src/math/Transform4x4f.h b/es-core/src/math/Transform4x4f.h
index c9f07da13..b0e1b7089 100644
--- a/es-core/src/math/Transform4x4f.h
+++ b/es-core/src/math/Transform4x4f.h
@@ -60,7 +60,7 @@ public:
 
     static const Transform4x4f Identity()
     {
-        return { { 1, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 1 } };
+        return {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}};
     }
 
 protected:
diff --git a/es-core/src/math/Vector2f.h b/es-core/src/math/Vector2f.h
index 193776e68..6d697c7c6 100644
--- a/es-core/src/math/Vector2f.h
+++ b/es-core/src/math/Vector2f.h
@@ -87,9 +87,9 @@ public:
     Vector2f& round();
     Vector2f& lerp(const Vector2f& _start, const Vector2f& _end, const float _fraction);
 
-    static const Vector2f Zero() { return { 0.0f, 0.0f }; }
-    static const Vector2f UnitX() { return { 1.0f, 0.0f }; }
-    static const Vector2f UnitY() { return { 0.0f, 1.0f }; }
+    static const Vector2f Zero() { return {0.0f, 0.0f}; }
+    static const Vector2f UnitX() { return {1.0f, 0.0f}; }
+    static const Vector2f UnitY() { return {0.0f, 1.0f}; }
 
 private:
     float mX;
diff --git a/es-core/src/math/Vector2i.h b/es-core/src/math/Vector2i.h
index 1924852d6..802af6ced 100644
--- a/es-core/src/math/Vector2i.h
+++ b/es-core/src/math/Vector2i.h
@@ -69,9 +69,9 @@ public:
     const int& x() const { return mX; }
     const int& y() const { return mY; }
 
-    static const Vector2i Zero() { return { 0, 0 }; }
-    static const Vector2i UnitX() { return { 1, 0 }; }
-    static const Vector2i UnitY() { return { 0, 1 }; }
+    static const Vector2i Zero() { return {0, 0}; }
+    static const Vector2i UnitX() { return {1, 0}; }
+    static const Vector2i UnitY() { return {0, 1}; }
 
 private:
     int mX;
diff --git a/es-core/src/math/Vector3f.h b/es-core/src/math/Vector3f.h
index 73a05f71d..9d98899f5 100644
--- a/es-core/src/math/Vector3f.h
+++ b/es-core/src/math/Vector3f.h
@@ -106,10 +106,10 @@ public:
     Vector3f& round();
     Vector3f& lerp(const Vector3f& _start, const Vector3f& _end, const float _fraction);
 
-    static const Vector3f Zero() { return { 0.0f, 0.0f, 0.0f }; }
-    static const Vector3f UnitX() { return { 1.0f, 0.0f, 0.0f }; }
-    static const Vector3f UnitY() { return { 0.0f, 1.0f, 0.0f }; }
-    static const Vector3f UnitZ() { return { 0.0f, 0.0f, 1.0f }; }
+    static const Vector3f Zero() { return {0.0f, 0.0f, 0.0f}; }
+    static const Vector3f UnitX() { return {1.0f, 0.0f, 0.0f}; }
+    static const Vector3f UnitY() { return {0.0f, 1.0f, 0.0f}; }
+    static const Vector3f UnitZ() { return {0.0f, 0.0f, 1.0f}; }
 
 private:
     float mX;
diff --git a/es-core/src/math/Vector4f.h b/es-core/src/math/Vector4f.h
index 000684ada..9db7541ed 100644
--- a/es-core/src/math/Vector4f.h
+++ b/es-core/src/math/Vector4f.h
@@ -132,11 +132,11 @@ public:
     Vector4f& round();
     Vector4f& lerp(const Vector4f& _start, const Vector4f& _end, const float _fraction);
 
-    static const Vector4f Zero() { return { 0.0f, 0.0f, 0.0f, 0.0f }; }
-    static const Vector4f UnitX() { return { 1.0f, 0.0f, 0.0f, 0.0f }; }
-    static const Vector4f UnitY() { return { 0.0f, 1.0f, 0.0f, 0.0f }; }
-    static const Vector4f UnitZ() { return { 0.0f, 0.0f, 1.0f, 0.0f }; }
-    static const Vector4f UnitW() { return { 0.0f, 0.0f, 0.0f, 1.0f }; }
+    static const Vector4f Zero() { return {0.0f, 0.0f, 0.0f, 0.0f}; }
+    static const Vector4f UnitX() { return {1.0f, 0.0f, 0.0f, 0.0f}; }
+    static const Vector4f UnitY() { return {0.0f, 1.0f, 0.0f, 0.0f}; }
+    static const Vector4f UnitZ() { return {0.0f, 0.0f, 1.0f, 0.0f}; }
+    static const Vector4f UnitW() { return {0.0f, 0.0f, 0.0f, 1.0f}; }
 
 private:
     float mX;
diff --git a/es-core/src/renderers/Renderer.cpp b/es-core/src/renderers/Renderer.cpp
index 893212ce6..b5230a610 100644
--- a/es-core/src/renderers/Renderer.cpp
+++ b/es-core/src/renderers/Renderer.cpp
@@ -12,7 +12,6 @@
 #include "Log.h"
 #include "Settings.h"
 #include "Shader_GL21.h"
-#include "math/Vector2i.h"
 #include "resources/ResourceManager.h"
 
 #include <SDL2/SDL.h>
@@ -325,8 +324,8 @@ namespace Renderer
         if (!createWindow())
             return false;
 
-        glm::mat4 projection = getIdentity();
-        Rect viewport = Rect(0, 0, 0, 0);
+        glm::mat4 projection{getIdentity()};
+        Rect viewport{0, 0, 0, 0};
 
         switch (screenRotate) {
             case 1: {
@@ -336,8 +335,8 @@ namespace Renderer
                 viewport.h = screenWidth;
                 projection = glm::ortho(0.0f, static_cast<float>(screenHeight),
                                         static_cast<float>(screenWidth), 0.0f, -1.0f, 1.0f);
-                projection = glm::rotate(projection, glm::radians(90.0f), { 0.0f, 0.0f, 1.0f });
-                projection = glm::translate(projection, { 0.0f, screenHeight * -1.0f, 0.0f });
+                projection = glm::rotate(projection, glm::radians(90.0f), {0.0f, 0.0f, 1.0f});
+                projection = glm::translate(projection, {0.0f, screenHeight * -1.0f, 0.0f});
                 break;
             }
             case 2: {
@@ -347,9 +346,9 @@ namespace Renderer
                 viewport.h = screenHeight;
                 projection = glm::ortho(0.0f, static_cast<float>(screenWidth),
                                         static_cast<float>(screenHeight), 0.0f, -1.0f, 1.0f);
-                projection = glm::rotate(projection, glm::radians(180.0f), { 0.0f, 0.0f, 1.0f });
+                projection = glm::rotate(projection, glm::radians(180.0f), {0.0f, 0.0f, 1.0f});
                 projection =
-                    glm::translate(projection, { screenWidth * -1.0f, screenHeight * -1.0f, 0.0f });
+                    glm::translate(projection, {screenWidth * -1.0f, screenHeight * -1.0f, 0.0f});
                 break;
             }
             case 3: {
@@ -359,8 +358,8 @@ namespace Renderer
                 viewport.h = screenWidth;
                 projection = glm::ortho(0.0f, static_cast<float>(screenHeight),
                                         static_cast<float>(screenWidth), 0.0f, -1.0f, 1.0f);
-                projection = glm::rotate(projection, glm::radians(270.0f), { 0.0f, 0.0f, 1.0f });
-                projection = glm::translate(projection, { screenWidth * -1.0f, 0.0f, 0.0f });
+                projection = glm::rotate(projection, glm::radians(270.0f), {0.0f, 0.0f, 1.0f});
+                projection = glm::translate(projection, {screenWidth * -1.0f, 0.0f, 0.0f});
                 break;
             }
             default: {
@@ -393,9 +392,9 @@ namespace Renderer
         destroyWindow();
     }
 
-    void pushClipRect(const Vector2i& _pos, const Vector2i& _size)
+    void pushClipRect(const glm::ivec2& _pos, const glm::ivec2& _size)
     {
-        Rect box(_pos.x(), _pos.y(), _size.x(), _size.y());
+        Rect box(_pos.x, _pos.y, _size.x, _size.y);
 
         if (box.w == 0)
             box.w = screenWidth - box.x;
@@ -485,10 +484,10 @@ namespace Renderer
             _hL = 1.0f;
 
         // clang-format off
-        vertices[0] = { { _x      , _y       }, { 0.0f, 0.0f }, color };
-        vertices[1] = { { _x      , _y + _hL }, { 0.0f, 0.0f }, horizontalGradient ? colorEnd : color };
-        vertices[2] = { { _x + _wL, _y       }, { 0.0f, 0.0f }, horizontalGradient ? color : colorEnd };
-        vertices[3] = { { _x + _wL, _y + _hL }, { 0.0f, 0.0f }, colorEnd };
+        vertices[0] = {{_x      , _y      }, {0.0f, 0.0f}, color};
+        vertices[1] = {{_x      , _y + _hL}, {0.0f, 0.0f}, horizontalGradient ? colorEnd : color};
+        vertices[2] = {{_x + _wL, _y      }, {0.0f, 0.0f}, horizontalGradient ? color : colorEnd};
+        vertices[3] = {{_x + _wL, _y + _hL}, {0.0f, 0.0f}, colorEnd};
         // clang-format on
 
         // Round vertices.
diff --git a/es-core/src/renderers/Renderer.h b/es-core/src/renderers/Renderer.h
index b9b4c3ac4..ec6aac4b4 100644
--- a/es-core/src/renderers/Renderer.h
+++ b/es-core/src/renderers/Renderer.h
@@ -18,8 +18,6 @@
 
 struct SDL_Window;
 
-class Vector2i;
-
 namespace Renderer
 {
     const unsigned int SHADER_DESATURATE = 1;
@@ -38,8 +36,8 @@ namespace Renderer
         unsigned int blurPasses;
 
         shaderParameters()
-            : textureSize({ 0.0f, 0.0f })
-            , textureCoordinates({ 0.0f, 0.0f, 0.0f, 0.0f })
+            : textureSize({0.0f, 0.0f})
+            , textureCoordinates({0.0f, 0.0f, 0.0f, 0.0f})
             , fragmentSaturation(1.0f)
             , fragmentDimValue(0.4f)
             , fragmentOpacity(1.0f)
@@ -51,7 +49,7 @@ namespace Renderer
     static std::vector<Shader*> sShaderProgramVector;
     static GLuint shaderFBO;
     static glm::mat4 mProjectionMatrix;
-    static constexpr glm::mat4 getIdentity() { return glm::mat4(1.0f); }
+    static constexpr glm::mat4 getIdentity() { return glm::mat4{1.0f}; }
 
 #if !defined(NDEBUG)
 #define GL_CHECK_ERROR(Function) (Function, _GLCheckError(#Function))
@@ -130,7 +128,7 @@ namespace Renderer
 
     bool init();
     void deinit();
-    void pushClipRect(const Vector2i& _pos, const Vector2i& _size);
+    void pushClipRect(const glm::ivec2& _pos, const glm::ivec2& _size);
     void popClipRect();
     void drawRect(const float _x,
                   const float _y,
diff --git a/es-core/src/renderers/Renderer_GL21.cpp b/es-core/src/renderers/Renderer_GL21.cpp
index f40d65bce..130393e46 100644
--- a/es-core/src/renderers/Renderer_GL21.cpp
+++ b/es-core/src/renderers/Renderer_GL21.cpp
@@ -137,7 +137,7 @@ namespace Renderer
             return false;
         }
 
-        uint8_t data[4] = { 255, 255, 255, 255 };
+        uint8_t data[4] = {255, 255, 255, 255};
         whiteTexture = createTexture(Texture::RGBA, false, true, 1, 1, data);
 
         GL_CHECK_ERROR(glClearColor(0.0f, 0.0f, 0.0f, 1.0f));
@@ -301,7 +301,7 @@ namespace Renderer
                 if (runShader) {
                     runShader->activateShaders();
                     runShader->setModelViewProjectionMatrix(getProjectionMatrix() * _trans);
-                    runShader->setTextureSize({ width, height });
+                    runShader->setTextureSize({width, height});
                     GL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, _numVertices));
                     runShader->deactivateShaders();
                 }
@@ -312,7 +312,7 @@ namespace Renderer
                 if (runShader) {
                     runShader->activateShaders();
                     runShader->setModelViewProjectionMatrix(getProjectionMatrix() * _trans);
-                    runShader->setTextureSize({ width, height });
+                    runShader->setTextureSize({width, height});
                     GL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, _numVertices));
                     runShader->deactivateShaders();
                 }
@@ -343,7 +343,7 @@ namespace Renderer
                 if (runShader) {
                     runShader->activateShaders();
                     runShader->setModelViewProjectionMatrix(getProjectionMatrix() * _trans);
-                    runShader->setTextureSize({ shaderWidth, shaderHeight });
+                    runShader->setTextureSize({shaderWidth, shaderHeight});
                     GL_CHECK_ERROR(glDrawArrays(GL_TRIANGLE_STRIP, 0, _numVertices));
                     runShader->deactivateShaders();
                 }
@@ -360,7 +360,7 @@ namespace Renderer
 
     void setMatrix(const glm::mat4& _matrix)
     {
-        glm::mat4 matrix = _matrix;
+        glm::mat4 matrix{_matrix};
         matrix[3] = glm::round(matrix[3]);
 
         GL_CHECK_ERROR(glMatrixMode(GL_MODELVIEW));
diff --git a/es-core/src/renderers/Renderer_GLES10.cpp b/es-core/src/renderers/Renderer_GLES10.cpp
index 743c6f82a..7e36ea094 100644
--- a/es-core/src/renderers/Renderer_GLES10.cpp
+++ b/es-core/src/renderers/Renderer_GLES10.cpp
@@ -90,7 +90,7 @@ namespace Renderer
                      << (extensions.find("GL_OES_texture_npot") != std::string::npos ? "OK" :
                                                                                        "MISSING");
 
-        uint8_t data[4] = { 255, 255, 255, 255 };
+        uint8_t data[4] = {255, 255, 255, 255};
         whiteTexture = createTexture(Texture::RGBA, false, true, 1, 1, data);
 
         GL_CHECK_ERROR(glClearColor(0.0f, 0.0f, 0.0f, 1.0f));
@@ -207,7 +207,7 @@ namespace Renderer
 
     void setMatrix(const glm::mat4& _matrix)
     {
-        glm::mat4 matrix = _matrix;
+        glm::mat4 matrix{_matrix};
         matrix[3] = glm::round(matrix[3]);
 
         GL_CHECK_ERROR(glMatrixMode(GL_MODELVIEW));
diff --git a/es-core/src/resources/Font.cpp b/es-core/src/resources/Font.cpp
index e24216d4e..e92b4d651 100644
--- a/es-core/src/resources/Font.cpp
+++ b/es-core/src/resources/Font.cpp
@@ -49,7 +49,7 @@ size_t Font::getMemUsage() const
 {
     size_t memUsage = 0;
     for (auto it = mTextures.cbegin(); it != mTextures.cend(); it++)
-        memUsage += it->textureSize.x() * it->textureSize.y() * 4;
+        memUsage += it->textureSize.x * it->textureSize.y * 4;
 
     for (auto it = mFaceCache.cbegin(); it != mFaceCache.cend(); it++)
         memUsage += it->second->data.length;
@@ -137,8 +137,8 @@ Font::FontTexture::FontTexture(const int mSize)
     // I'm not entirely sure if the 16 and 6 constants are correct, but they seem to provide
     // a texture buffer large enough to hold the fonts (otherwise the application would crash).
     // This logic is obviously a hack though and needs to be properly reviewed and improved.
-    textureSize = Vector2i(mSize * 16, mSize * 6);
-    writePos = Vector2i::Zero();
+    textureSize = glm::ivec2{mSize * 16, mSize * 6};
+    writePos = glm::ivec2{};
     rowHeight = 0;
 }
 
@@ -148,28 +148,30 @@ Font::FontTexture::~FontTexture()
     deinitTexture();
 }
 
-bool Font::FontTexture::findEmpty(const Vector2i& size, Vector2i& cursor_out)
+bool Font::FontTexture::findEmpty(const glm::ivec2& size, glm::ivec2& cursor_out)
 {
-    if (size.x() >= textureSize.x() || size.y() >= textureSize.y())
+    if (size.x >= textureSize.x || size.y >= textureSize.y)
         return false;
 
-    if (writePos.x() + size.x() >= textureSize.x() &&
-        writePos.y() + rowHeight + size.y() + 1 < textureSize.y()) {
+    if (writePos.x + size.x >= textureSize.x &&
+        writePos.y + rowHeight + size.y + 1 < textureSize.y) {
         // Row full, but it should fit on the next row so move the cursor there.
-        writePos = Vector2i(0, writePos.y() + rowHeight + 1); // Leave 1px of space between glyphs.
+        // Leave 1px of space between glyphs.
+        writePos = glm::ivec2{0, writePos.y + rowHeight + 1};
         rowHeight = 0;
     }
 
-    if (writePos.x() + size.x() >= textureSize.x() || writePos.y() + size.y() >= textureSize.y()) {
+    if (writePos.x + size.x >= textureSize.x || writePos.y + size.y >= textureSize.y) {
         // Nope, still won't fit.
         return false;
     }
 
     cursor_out = writePos;
-    writePos[0] += size.x() + 1; // Leave 1px of space between glyphs.
+    // Leave 1px of space between glyphs.
+    writePos.x += size.x + 1;
 
-    if (size.y() > rowHeight)
-        rowHeight = size.y();
+    if (size.y > rowHeight)
+        rowHeight = size.y;
 
     return true;
 }
@@ -177,8 +179,8 @@ bool Font::FontTexture::findEmpty(const Vector2i& size, Vector2i& cursor_out)
 void Font::FontTexture::initTexture()
 {
     assert(textureId == 0);
-    textureId = Renderer::createTexture(Renderer::Texture::ALPHA, false, false, textureSize.x(),
-                                        textureSize.y(), nullptr);
+    textureId = Renderer::createTexture(Renderer::Texture::ALPHA, false, false, textureSize.x,
+                                        textureSize.y, nullptr);
 }
 
 void Font::FontTexture::deinitTexture()
@@ -189,9 +191,9 @@ void Font::FontTexture::deinitTexture()
     }
 }
 
-void Font::getTextureForNewGlyph(const Vector2i& glyphSize,
+void Font::getTextureForNewGlyph(const glm::ivec2& glyphSize,
                                  FontTexture*& tex_out,
-                                 Vector2i& cursor_out)
+                                 glm::ivec2& cursor_out)
 {
     if (mTextures.size()) {
         // Check if the most recent texture has space.
@@ -210,7 +212,7 @@ void Font::getTextureForNewGlyph(const Vector2i& glyphSize,
     bool ok = tex_out->findEmpty(glyphSize, cursor_out);
     if (!ok) {
         LOG(LogError) << "Glyph too big to fit on a new texture (glyph size > "
-                      << tex_out->textureSize.x() << ", " << tex_out->textureSize.y() << ")";
+                      << tex_out->textureSize.x << ", " << tex_out->textureSize.y << ")";
         tex_out = nullptr;
     }
 }
@@ -296,10 +298,10 @@ Font::Glyph* Font::getGlyph(unsigned int id)
         return nullptr;
     }
 
-    Vector2i glyphSize(g->bitmap.width, g->bitmap.rows);
+    glm::ivec2 glyphSize{g->bitmap.width, g->bitmap.rows};
 
     FontTexture* tex = nullptr;
-    Vector2i cursor;
+    glm::ivec2 cursor;
     getTextureForNewGlyph(glyphSize, tex, cursor);
 
     // getTextureForNewGlyph can fail if the glyph is bigger than the max texture
@@ -314,23 +316,23 @@ Font::Glyph* Font::getGlyph(unsigned int id)
     Glyph& glyph = mGlyphMap[id];
 
     glyph.texture = tex;
-    glyph.texPos = glm::vec2(cursor.x() / static_cast<float>(tex->textureSize.x()),
-                             cursor.y() / static_cast<float>(tex->textureSize.y()));
-    glyph.texSize = glm::vec2(glyphSize.x() / static_cast<float>(tex->textureSize.x()),
-                              glyphSize.y() / static_cast<float>(tex->textureSize.y()));
+    glyph.texPos = glm::vec2{cursor.x / static_cast<float>(tex->textureSize.x),
+                             cursor.y / static_cast<float>(tex->textureSize.y)};
+    glyph.texSize = glm::vec2{glyphSize.x / static_cast<float>(tex->textureSize.x),
+                              glyphSize.y / static_cast<float>(tex->textureSize.y)};
 
-    glyph.advance = glm::vec2(static_cast<float>(g->metrics.horiAdvance) / 64.0f,
-                              static_cast<float>(g->metrics.vertAdvance) / 64.0f);
-    glyph.bearing = glm::vec2(static_cast<float>(g->metrics.horiBearingX) / 64.0f,
-                              static_cast<float>(g->metrics.horiBearingY) / 64.0f);
+    glyph.advance = glm::vec2{static_cast<float>(g->metrics.horiAdvance) / 64.0f,
+                              static_cast<float>(g->metrics.vertAdvance) / 64.0f};
+    glyph.bearing = glm::vec2{static_cast<float>(g->metrics.horiBearingX) / 64.0f,
+                              static_cast<float>(g->metrics.horiBearingY) / 64.0f};
 
     // Upload glyph bitmap to texture.
-    Renderer::updateTexture(tex->textureId, Renderer::Texture::ALPHA, cursor.x(), cursor.y(),
-                            glyphSize.x(), glyphSize.y(), g->bitmap.buffer);
+    Renderer::updateTexture(tex->textureId, Renderer::Texture::ALPHA, cursor.x, cursor.y,
+                            glyphSize.x, glyphSize.y, g->bitmap.buffer);
 
     // Update max glyph height.
-    if (glyphSize.y() > mMaxGlyphHeight)
-        mMaxGlyphHeight = glyphSize.y();
+    if (glyphSize.y > mMaxGlyphHeight)
+        mMaxGlyphHeight = glyphSize.y;
 
     // Done.
     return &glyph;
@@ -354,14 +356,14 @@ void Font::rebuildTextures()
         FontTexture* tex = it->second.texture;
 
         // Find the position/size.
-        Vector2i cursor(static_cast<int>(it->second.texPos.x * tex->textureSize.x()),
-                        static_cast<int>(it->second.texPos.y * tex->textureSize.y()));
-        Vector2i glyphSize(static_cast<int>(it->second.texSize.x * tex->textureSize.x()),
-                           static_cast<int>(it->second.texSize.y * tex->textureSize.y()));
+        glm::ivec2 cursor{static_cast<int>(it->second.texPos.x * tex->textureSize.x),
+                          static_cast<int>(it->second.texPos.y * tex->textureSize.y)};
+        glm::ivec2 glyphSize{static_cast<int>(it->second.texSize.x * tex->textureSize.x),
+                             static_cast<int>(it->second.texSize.y * tex->textureSize.y)};
 
         // Upload to texture.
-        Renderer::updateTexture(tex->textureId, Renderer::Texture::ALPHA, cursor.x(), cursor.y(),
-                                glyphSize.x(), glyphSize.y(), glyphSlot->bitmap.buffer);
+        Renderer::updateTexture(tex->textureId, Renderer::Texture::ALPHA, cursor.x, cursor.y,
+                                glyphSize.x, glyphSize.y, glyphSlot->bitmap.buffer);
     }
 }
 
@@ -412,7 +414,7 @@ glm::vec2 Font::sizeText(std::string text, float lineSpacing)
     if (lineWidth > highestWidth)
         highestWidth = lineWidth;
 
-    return glm::vec2(highestWidth, y);
+    return glm::vec2{highestWidth, y};
 }
 
 std::string Font::getTextMaxWidth(std::string text, float maxWidth)
@@ -435,7 +437,7 @@ float Font::getLetterHeight()
 {
     Glyph* glyph = getGlyph('S');
     assert(glyph);
-    return glyph->texSize.y * glyph->texture->textureSize.y();
+    return glyph->texSize.y * glyph->texture->textureSize.y;
 }
 
 // Breaks up a normal string with newlines to make it fit xLen.
@@ -538,7 +540,7 @@ glm::vec2 Font::getWrappedTextCursorOffset(std::string text,
             lineWidth += glyph->advance.x;
     }
 
-    return glm::vec2(lineWidth, y);
+    return glm::vec2{lineWidth, y};
 }
 
 //
@@ -631,24 +633,23 @@ TextCache* Font::buildTextCache(const std::string& text,
         verts.resize(oldVertSize + 6);
         Renderer::Vertex* vertices = verts.data() + oldVertSize;
 
-        const float glyphStartX = x + glyph->bearing.x;
-        const Vector2i& textureSize = glyph->texture->textureSize;
+        const float glyphStartX{x + glyph->bearing.x};
+        const glm::ivec2& textureSize{glyph->texture->textureSize};
         const unsigned int convertedColor = Renderer::convertRGBAToABGR(color);
 
-        vertices[1] = { { glyphStartX, y - glyph->bearing.y },
-                        { glyph->texPos.x, glyph->texPos.y },
-                        convertedColor };
-        vertices[2] = { { glyphStartX,
-                          y - glyph->bearing.y + (glyph->texSize.y * textureSize.y()) },
-                        { glyph->texPos.x, glyph->texPos.y + glyph->texSize.y },
-                        convertedColor };
-        vertices[3] = { { glyphStartX + glyph->texSize.x * textureSize.x(), y - glyph->bearing.y },
-                        { glyph->texPos.x + glyph->texSize.x, glyph->texPos.y },
-                        convertedColor };
-        vertices[4] = { { glyphStartX + glyph->texSize.x * textureSize.x(),
-                          y - glyph->bearing.y + (glyph->texSize.y * textureSize.y()) },
-                        { glyph->texPos.x + glyph->texSize.x, glyph->texPos.y + glyph->texSize.y },
-                        convertedColor };
+        vertices[1] = {{glyphStartX, y - glyph->bearing.y},
+                       {glyph->texPos.x, glyph->texPos.y},
+                       convertedColor};
+        vertices[2] = {{glyphStartX, y - glyph->bearing.y + (glyph->texSize.y * textureSize.y)},
+                       {glyph->texPos.x, glyph->texPos.y + glyph->texSize.y},
+                       convertedColor};
+        vertices[3] = {{glyphStartX + glyph->texSize.x * textureSize.x, y - glyph->bearing.y},
+                       {glyph->texPos.x + glyph->texSize.x, glyph->texPos.y},
+                       convertedColor};
+        vertices[4] = {{glyphStartX + glyph->texSize.x * textureSize.x,
+                        y - glyph->bearing.y + (glyph->texSize.y * textureSize.y)},
+                       {glyph->texPos.x + glyph->texSize.x, glyph->texPos.y + glyph->texSize.y},
+                       convertedColor};
 
         // Round vertices.
         for (int i = 1; i < 5; i++)
@@ -666,7 +667,7 @@ TextCache* Font::buildTextCache(const std::string& text,
 
     TextCache* cache = new TextCache();
     cache->vertexLists.resize(vertMap.size());
-    cache->metrics = { sizeText(text, lineSpacing) };
+    cache->metrics = {sizeText(text, lineSpacing)};
 
     unsigned int i = 0;
     for (auto it = vertMap.cbegin(); it != vertMap.cend(); it++) {
@@ -687,7 +688,7 @@ TextCache* Font::buildTextCache(const std::string& text,
                                 float lineSpacing,
                                 bool noTopMargin)
 {
-    return buildTextCache(text, glm::vec2(offsetX, offsetY), color, 0.0f, ALIGN_LEFT, lineSpacing,
+    return buildTextCache(text, glm::vec2{offsetX, offsetY}, color, 0.0f, ALIGN_LEFT, lineSpacing,
                           noTopMargin);
 }
 
diff --git a/es-core/src/resources/Font.h b/es-core/src/resources/Font.h
index e7b99718f..745285d14 100644
--- a/es-core/src/resources/Font.h
+++ b/es-core/src/resources/Font.h
@@ -11,7 +11,6 @@
 #define ES_CORE_RESOURCES_FONT_H
 
 #include "ThemeData.h"
-#include "math/Vector2i.h"
 #include "renderers/Renderer.h"
 #include "resources/ResourceManager.h"
 
@@ -114,14 +113,14 @@ private:
 
     struct FontTexture {
         unsigned int textureId;
-        Vector2i textureSize;
+        glm::ivec2 textureSize;
 
-        Vector2i writePos;
+        glm::ivec2 writePos;
         int rowHeight;
 
         FontTexture(const int mSize);
         ~FontTexture();
-        bool findEmpty(const Vector2i& size, Vector2i& cursor_out);
+        bool findEmpty(const glm::ivec2& size, glm::ivec2& cursor_out);
 
         // You must call initTexture() after creating a FontTexture to get a textureId.
         // Initializes the OpenGL texture according to this FontTexture's settings,
@@ -146,9 +145,9 @@ private:
 
     std::vector<FontTexture> mTextures;
 
-    void getTextureForNewGlyph(const Vector2i& glyphSize,
+    void getTextureForNewGlyph(const glm::ivec2& glyphSize,
                                FontTexture*& tex_out,
-                               Vector2i& cursor_out);
+                               glm::ivec2& cursor_out);
 
     std::map<unsigned int, std::unique_ptr<FontFace>> mFaceCache;
     FT_Face getFaceForChar(unsigned int id);
diff --git a/es-core/src/resources/ResourceManager.cpp b/es-core/src/resources/ResourceManager.cpp
index e61d69ea9..0f4072b09 100644
--- a/es-core/src/resources/ResourceManager.cpp
+++ b/es-core/src/resources/ResourceManager.cpp
@@ -107,7 +107,7 @@ const ResourceData ResourceManager::getFileData(const std::string& path) const
     }
 
     // If the file doesn't exist, return an "empty" ResourceData.
-    ResourceData data = { nullptr, 0 };
+    ResourceData data = {nullptr, 0};
     return data;
 }
 
@@ -128,7 +128,7 @@ ResourceData ResourceManager::loadFile(const std::string& path) const
     stream.read(reinterpret_cast<char*>(data.get()), size);
     stream.close();
 
-    ResourceData ret = { data, size };
+    ResourceData ret = {data, size};
     return ret;
 }
 
diff --git a/es-core/src/resources/TextureResource.cpp b/es-core/src/resources/TextureResource.cpp
index cd18010fb..ff2281044 100644
--- a/es-core/src/resources/TextureResource.cpp
+++ b/es-core/src/resources/TextureResource.cpp
@@ -46,15 +46,15 @@ TextureResource::TextureResource(const std::string& path,
             data->load();
         }
 
-        mSize = Vector2i(static_cast<int>(data->width()), static_cast<int>(data->height()));
-        mSourceSize = glm::vec2(data->sourceWidth(), data->sourceHeight());
+        mSize = glm::ivec2{static_cast<int>(data->width()), static_cast<int>(data->height())};
+        mSourceSize = glm::vec2{data->sourceWidth(), data->sourceHeight()};
     }
     else {
         // Create a texture managed by this class because it cannot be dynamically
         // loaded and unloaded. This would normally be a video texture, where the player
         // reserves a texture to later be used for the video rendering.
         mTextureData = std::shared_ptr<TextureData>(new TextureData(tile));
-        mSize = Vector2i(0, 0);
+        mSize = glm::ivec2{};
     }
     sAllTextures.insert(this);
 }
@@ -75,8 +75,8 @@ void TextureResource::initFromPixels(const unsigned char* dataRGBA, size_t width
     mTextureData->releaseRAM();
     mTextureData->initFromRGBA(dataRGBA, width, height);
     // Cache the image dimensions.
-    mSize = Vector2i(static_cast<int>(width), static_cast<int>(height));
-    mSourceSize = glm::vec2(mTextureData->sourceWidth(), mTextureData->sourceHeight());
+    mSize = glm::ivec2{static_cast<int>(width), static_cast<int>(height)};
+    mSourceSize = glm::vec2{mTextureData->sourceWidth(), mTextureData->sourceHeight()};
 }
 
 void TextureResource::initFromMemory(const char* data, size_t length)
@@ -87,9 +87,9 @@ void TextureResource::initFromMemory(const char* data, size_t length)
     mTextureData->releaseRAM();
     mTextureData->initImageFromMemory(reinterpret_cast<const unsigned char*>(data), length);
     // Get the size from the texture data.
-    mSize =
-        Vector2i(static_cast<int>(mTextureData->width()), static_cast<int>(mTextureData->height()));
-    mSourceSize = glm::vec2(mTextureData->sourceWidth(), mTextureData->sourceHeight());
+    mSize = glm::ivec2{static_cast<int>(mTextureData->width()),
+                       static_cast<int>(mTextureData->height())};
+    mSourceSize = glm::vec2{mTextureData->sourceWidth(), mTextureData->sourceHeight()};
 }
 
 void TextureResource::manualUnload(std::string path, bool tile)
@@ -197,7 +197,7 @@ void TextureResource::rasterizeAt(size_t width, size_t height)
         data = mTextureData;
     else
         data = sTextureDataManager.get(this);
-    mSourceSize = glm::vec2(static_cast<float>(width), static_cast<float>(height));
+    mSourceSize = glm::vec2{static_cast<float>(width), static_cast<float>(height)};
     data->setSourceSize(static_cast<float>(width), static_cast<float>(height));
     if (mForceLoad || (mTextureData != nullptr))
         data->load();
@@ -220,11 +220,11 @@ size_t TextureResource::getTotalMemUsage()
 
 size_t TextureResource::getTotalTextureSize()
 {
-    size_t total = 0;
+    size_t total{0};
     // Count up all textures that manage their own texture data.
     for (auto tex : sAllTextures) {
         if (tex->mTextureData != nullptr)
-            total += tex->getSize().x() * tex->getSize().y() * 4;
+            total += tex->getSize().x * tex->getSize().y * 4;
     }
     // Now get the total memory from the manager.
     total += sTextureDataManager.getTotalSize();
diff --git a/es-core/src/resources/TextureResource.h b/es-core/src/resources/TextureResource.h
index 6aee633a9..12319d81d 100644
--- a/es-core/src/resources/TextureResource.h
+++ b/es-core/src/resources/TextureResource.h
@@ -10,7 +10,6 @@
 #define ES_CORE_RESOURCES_TEXTURE_RESOURCE_H
 
 #include "math/Misc.h"
-#include "math/Vector2i.h"
 #include "resources/ResourceManager.h"
 #include "resources/TextureDataManager.h"
 
@@ -52,7 +51,7 @@ public:
     bool isInitialized() const { return true; }
     bool isTiled() const;
 
-    const Vector2i getSize() const { return mSize; }
+    const glm::ivec2 getSize() const { return mSize; }
     bool bind();
 
     // Returns an approximation of total VRAM used by textures (in bytes).
@@ -73,7 +72,7 @@ private:
     // The texture data manager manages loading and unloading of filesystem based textures.
     static TextureDataManager sTextureDataManager;
 
-    Vector2i mSize;
+    glm::ivec2 mSize;
     glm::vec2 mSourceSize;
     bool mForceLoad;
 
diff --git a/es-core/src/utils/StringUtil.cpp b/es-core/src/utils/StringUtil.cpp
index 552b23d7b..556622138 100644
--- a/es-core/src/utils/StringUtil.cpp
+++ b/es-core/src/utils/StringUtil.cpp
@@ -153,8 +153,7 @@ namespace Utils
             (wchar_t)0xFF4B, (wchar_t)0xFF4C, (wchar_t)0xFF4D, (wchar_t)0xFF4E, (wchar_t)0xFF4F,
             (wchar_t)0xFF50, (wchar_t)0xFF51, (wchar_t)0xFF52, (wchar_t)0xFF53, (wchar_t)0xFF54,
             (wchar_t)0xFF55, (wchar_t)0xFF56, (wchar_t)0xFF57, (wchar_t)0xFF58, (wchar_t)0xFF59,
-            (wchar_t)0xFF5A
-        };
+            (wchar_t)0xFF5A};
 
         static wchar_t unicodeUppercase[] = {
             (wchar_t)0x0041, (wchar_t)0x0042, (wchar_t)0x0043, (wchar_t)0x0044, (wchar_t)0x0045,
@@ -290,8 +289,7 @@ namespace Utils
             (wchar_t)0xFF2B, (wchar_t)0xFF2C, (wchar_t)0xFF2D, (wchar_t)0xFF2E, (wchar_t)0xFF2F,
             (wchar_t)0xFF30, (wchar_t)0xFF31, (wchar_t)0xFF32, (wchar_t)0xFF33, (wchar_t)0xFF34,
             (wchar_t)0xFF35, (wchar_t)0xFF36, (wchar_t)0xFF37, (wchar_t)0xFF38, (wchar_t)0xFF39,
-            (wchar_t)0xFF3A
-        };
+            (wchar_t)0xFF3A};
 
         unsigned int chars2Unicode(const std::string& stringArg, size_t& cursor)
         {
@@ -592,7 +590,7 @@ namespace Utils
 
         std::string removeParenthesis(const std::string& stringArg)
         {
-            static std::vector<char> remove = { '(', ')', '[', ']' };
+            static std::vector<char> remove = {'(', ')', '[', ']'};
             std::string stringRemove = stringArg;
             size_t start;
             size_t end;
diff --git a/es-core/src/utils/TimeUtil.cpp b/es-core/src/utils/TimeUtil.cpp
index 6d4a46cb1..ef829d351 100644
--- a/es-core/src/utils/TimeUtil.cpp
+++ b/es-core/src/utils/TimeUtil.cpp
@@ -18,7 +18,7 @@ namespace Utils
         DateTime::DateTime()
         {
             mTime = 0;
-            mTimeStruct = { 0, 0, 0, 1, 0, 0, 0, 0, -1 };
+            mTimeStruct = {0, 0, 0, 1, 0, 0, 0, 0, -1};
             mIsoString = "00000000T000000";
         }
 
@@ -83,7 +83,7 @@ namespace Utils
         {
             const char* s = string.c_str();
             const char* f = format.c_str();
-            tm timeStruct = { 0, 0, 0, 1, 0, 0, 0, 0, -1 };
+            tm timeStruct = {0, 0, 0, 1, 0, 0, 0, 0, -1};
             size_t parsedChars = 0;
 
             if (string == "19700101T010000")
@@ -172,7 +172,7 @@ namespace Utils
 #else
             localtime_r(&time, &timeStruct);
 #endif
-            char buf[256] = { '\0' };
+            char buf[256] = {'\0'};
             char* s = buf;
 
             while (*f) {
@@ -231,7 +231,7 @@ namespace Utils
 
         int daysInMonth(const int year, const int month)
         {
-            tm timeStruct = { 0, 0, 0, 0, month, year - 1900, 0, 0, -1 };
+            tm timeStruct = {0, 0, 0, 0, month, year - 1900, 0, 0, -1};
             mktime(&timeStruct);
 
             return timeStruct.tm_mday;
@@ -239,7 +239,7 @@ namespace Utils
 
         int daysInYear(const int year)
         {
-            tm timeStruct = { 0, 0, 0, 0, 0, year - 1900 + 1, 0, 0, -1 };
+            tm timeStruct = {0, 0, 0, 0, 0, year - 1900 + 1, 0, 0, -1};
             mktime(&timeStruct);
 
             return timeStruct.tm_yday + 1;