fix: typo in font_loader.windows

bump version
fix(nixos): write to config.temp.toml if config.toml is unwriteable
2026-04-09 12:37:41 +03:00 · 2025-12-19 08:21:37 +03:00 · 2025-12-19 00:23:02 +03:00 · 2025-12-19 00:19:26 +03:00 · 2025-12-18 23:53:06 +03:00 · 2025-12-18 23:33:04 +03:00
97 changed files with 5417 additions and 2278 deletions
--- a/.github/workflows/Test
+++ b/.github/workflows/Test
@@ -2,7 +2,7 @@ name: Test PKGBUILD-git

 on:
  push:
-    branch: master
+    branches: master
  pull_request:
    branches: master

--- a/.github/workflows/Test
+++ b/.github/workflows/Test
@@ -2,8 +2,9 @@ name: Test flake.nix

 on:
  push:
-    branches: [master]
+    branches: master
  pull_request:
+    branches: master

 jobs:
  build:
--- a/.github/workflows/publish-release.yml
+++ b/.github/workflows/publish-release.yml
@@ -49,7 +49,8 @@ jobs:
          sudo apt-get update
          sudo apt-get install -y cmake build-essential git \
            libglfw3-dev libfreetype6-dev libfontconfig1-dev \
-            libx11-dev libxrandr-dev libxi-dev \
+            zlib1g-dev libharfbuzz-dev \
+            libx11-dev libxrandr-dev libxi-dev libgtk-3-dev \
            mesa-common-dev libgl1-mesa-dev libglu1-mesa-dev \
            libxinerama-dev libxcursor-dev libxkbcommon-dev

@@ -83,10 +84,11 @@ jobs:
        run: |
          dnf install -y cmake gcc gcc-c++ make rpm-build git \
            glfw-devel freetype-devel fontconfig-devel \
+            zlib-devel harfbuzz-devel \
            libX11-devel libXrandr-devel libXi-devel \
            mesa-libGL-devel mesa-libGLU-devel \
            libXinerama-devel libXcursor-devel \
-            wayland-devel wayland-protocols-devel
+            wayland-devel wayland-protocols-devel gtk3-devel

      - name: Configure CMake
        run: cmake -B build -DCMAKE_BUILD_TYPE=Release -DUSE_SYSTEM_GLFW=ON
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@
 out

 build/
+build-msvc/
 CMakeCache.txt
 CMakeFiles/
 cmake_install.cmake
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -5,7 +5,7 @@
    "version": "0.2.0",
    "configurations": [
        {
-            "name": "Debug current target",
+            "name": "Debug current target (GDB)",
            "type": "cppdbg",
            "request": "launch",
            "program": "${command:cmake.launchTargetPath}",
@@ -31,6 +31,22 @@
                    "ignoreFailures": true
                }
            ]
+        },
+                {
+            "name": "Debug current target (LLDB)",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${command:cmake.launchTargetPath}",
+            "args": [
+                "--apply",
+                "--theme",
+                "dark"
+            ],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "lldb",
        },
    ]
 }
--- a/AUR/PKGBUILD
+++ b/AUR/PKGBUILD
@@ -1,6 +1,6 @@
 # Maintainer: Daniel Dada <dan@binarygoose.dev>
 pkgname=clrsync
-pkgver=0.1.4
+pkgver=0.1.7
 pkgrel=1
 pkgdesc="Color scheme manager"
 arch=('x86_64')
@@ -14,6 +14,7 @@ depends=(
    mesa
    libglvnd
    libxcursor
+    gtk3
 )

 makedepends=(
@@ -26,6 +27,7 @@ makedepends=(
  libxcursor
  wayland
  wayland-protocols
+  gtk3
 )

 source=("$pkgname-$pkgver.tar.gz::https://github.com/obsqrbtz/clrsync/archive/refs/tags/v$pkgver.tar.gz")
--- a/AUR/PKGBUILD-git
+++ b/AUR/PKGBUILD-git
@@ -10,9 +10,12 @@ depends=(
    glfw
    freetype2
    fontconfig
+    zlib
+    harfbuzz
    mesa
    libglvnd
    libxcursor
+    gtk3
 )

 makedepends=(
@@ -26,6 +29,7 @@ makedepends=(
  libxcursor
  wayland
  wayland-protocols
+  gtk3
 )
 provides=('clrsync')
 conflicts=('clrsync')
--- a/AUR/PKGBUILD.in
+++ b/AUR/PKGBUILD.in
@@ -14,6 +14,7 @@ depends=(
    mesa
    libglvnd
    libxcursor
+    gtk3
 )

 makedepends=(
@@ -26,6 +27,7 @@ makedepends=(
  libxcursor
  wayland
  wayland-protocols
+  gtk3
 )

 source=("$pkgname-$pkgver.tar.gz::https://github.com/obsqrbtz/clrsync/archive/refs/tags/v$pkgver.tar.gz")
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.25)
-project(clrsync VERSION 0.1.4 LANGUAGES CXX)
+project(clrsync VERSION 0.1.7 LANGUAGES CXX)

 include(GNUInstallDirs)

@@ -26,9 +26,45 @@ set(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
 set(CMAKE_INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")

+if(DEFINED CLRSYNC_SEMVER)
+  set(SEMVER "${CLRSYNC_SEMVER}")
+else()
+  find_package(Git QUIET)
+
+    if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    execute_process(
+        COMMAND git describe --tags --long --always
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_DESCRIBE
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    endif()
+
+    if(GIT_DESCRIBE MATCHES "^[vV]?[0-9]+\\.[0-9]+\\.[0-9]+-[0-9]+-g[0-9a-f]+")
+    string(REGEX REPLACE
+        "^[vV]?([0-9]+\\.[0-9]+\\.[0-9]+)-([0-9]+)-g([0-9a-f]+)"
+        "\\1+git.g\\3"
+        SEMVER "${GIT_DESCRIBE}"
+    )
+    elseif(GIT_DESCRIBE)
+    set(SEMVER "${PROJECT_VERSION}.git.${GIT_DESCRIBE}")
+    else()
+    set(SEMVER "${PROJECT_VERSION}")
+    endif()
+endif()
+
+message(STATUS "clrsync version: ${SEMVER}")
+
 configure_file(
-    ${CMAKE_SOURCE_DIR}/src/core/version.hpp.in
-    ${CMAKE_SOURCE_DIR}/src/core/version.hpp
+    ${CMAKE_SOURCE_DIR}/src/core/common/version.hpp.in
+    ${CMAKE_SOURCE_DIR}/src/core/common/version.hpp
+    @ONLY
+)
+
+configure_file(
+    ${CMAKE_SOURCE_DIR}/VERSION.in
+    ${CMAKE_SOURCE_DIR}/VERSION
    @ONLY
 )

--- a/README.md
+++ b/README.md
@@ -4,7 +4,6 @@
 # clrsync

 **Notice:** This application is not yet released and is subject to change.  
-Deb, RPM, and AUR packages, as well as a Windows installer, will be available soon.

 A theme management tool for synchronizing color schemes across multiple applications. clrsync allows to define color palettes once and apply them consistently to all configurable applications.

@@ -12,13 +11,18 @@ A theme management tool for synchronizing color schemes across multiple applicat

 ## Table of Contents

+
 - [Features](#features)
 - [Installation](#installation)
+  - [Linux](#linux)
+    - [Ubuntu](#ubuntu)
+    - [Fedora](#fedora)
    - [NixOS](#nixos)
      - [Home Manager Module](#home-manager-module)
      - [Package](#package)
      - [Install to profile](#install-to-profile)
      - [Run without installing](#run-without-installing)
+  - [Windows](#windows)
  - [Other systems](#other-systems)
 - [Building](#building)
  - [Prerequisites](#prerequisites)
@@ -41,7 +45,32 @@ A theme management tool for synchronizing color schemes across multiple applicat

 ## Installation

-### NixOS
+### Linux
+
+#### Ubuntu
+
+1. Download the latest .deb from the [releases page](https://github.com/obsqrbtz/clrsync/releases)
+2. Install the package
+
+```shell
+sudo dpkg -i clrsync-<version>.deb
+```
+
+#### Fedora
+
+1. Download the latest .rpm from the [releases page](https://github.com/obsqrbtz/clrsync/releases)
+
+2. Install the package
+
+```shell
+sudo rpm -i clrsync-<version>.rpm
+
+# or
+
+sudo dnf install clrsync-<version>.rpm
+```
+
+#### NixOS

 <details>
 <summary>Home Manager Module</summary>
@@ -198,6 +227,12 @@ nix run github:obsqrbtz/clrsync#clrsync-cli

 </details>

+### Windows
+
+1. Download the latest installer from the [releases page](https://github.com/obsqrbtz/clrsync/releases)
+2. Run the installer and follow the wizard
+3. Optionally, add the installation dir to your PATH for easier CLI access
+
 ### Other systems

 Follow the steps from Building section then install with cmake:
--- a/1
+++ b/1
@@ -0,0 +1 @@
+0.1.7
--- a/VERSION.in
+++ b/VERSION.in
@@ -0,0 +1 @@
+@PROJECT_VERSION@
--- a/assets/screenshot.png
+++ b/assets/screenshot.png
--- a/cmake/Dependencies.cmake
+++ b/cmake/Dependencies.cmake
@@ -7,7 +7,25 @@ if(WIN32)
        freetype
        URL https://download.savannah.gnu.org/releases/freetype/freetype-2.14.1.tar.gz
    )
+    
+    set(FT_DISABLE_ZLIB FALSE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_BZIP2 TRUE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_PNG TRUE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_HARFBUZZ FALSE CACHE BOOL "" FORCE)
+    set(FT_DISABLE_BROTLI TRUE CACHE BOOL "" FORCE)
+    
    FetchContent_MakeAvailable(freetype)
+elseif(APPLE)
+    option(USE_SYSTEM_GLFW ON)
+    find_package(Freetype REQUIRED)
+    find_package(ZLIB REQUIRED)
+    find_package(BZip2 REQUIRED)
+    find_package(PNG REQUIRED)
+    
+    find_package(PkgConfig QUIET)
+    if(PkgConfig_FOUND)
+        pkg_check_modules(HARFBUZZ harfbuzz)
+    endif()
 else()
    find_package(Freetype REQUIRED)
    find_package(PkgConfig REQUIRED)
@@ -15,17 +33,29 @@ else()
    find_package(ZLIB REQUIRED)
    find_package(BZip2 REQUIRED)
    find_package(PNG REQUIRED)
-
-    find_library(BROTLIDEC_LIBRARY NAMES brotlidec)
-    find_library(BROTLICOMMON_LIBRARY NAMES brotlicommon)
-
    pkg_check_modules(HARFBUZZ harfbuzz)
    pkg_check_modules(WAYLAND_CLIENT wayland-client)
    pkg_check_modules(WAYLAND_EGL wayland-egl)
 endif()

+if(LINUX)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
+endif()
+
 if(USE_SYSTEM_GLFW)
+    if(APPLE)
+        find_package(glfw3 QUIET)
+        if(glfw3_FOUND)
+            set(GLFW_FOUND TRUE)
+            set(GLFW_LIBRARIES glfw)
+        else()
+            find_package(PkgConfig REQUIRED)
            pkg_check_modules(GLFW REQUIRED glfw3)
+        endif()
+    else()
+        pkg_check_modules(GLFW REQUIRED glfw3)
+    endif()
 else()
    include(FetchContent)
    FetchContent_Declare(
@@ -46,22 +76,19 @@ else()
 endif()

 set(FREETYPE_EXTRA_LIBS "")
-if(BROTLIDEC_LIBRARY AND BROTLICOMMON_LIBRARY)
-    list(APPEND FREETYPE_EXTRA_LIBS ${BROTLIDEC_LIBRARY} ${BROTLICOMMON_LIBRARY})
-    message(STATUS "Found Brotli libraries")
-endif()
-
 if(HARFBUZZ_FOUND)
    list(APPEND FREETYPE_EXTRA_LIBS ${HARFBUZZ_LIBRARIES})
    message(STATUS "Found HarfBuzz")
 endif()

 set(WAYLAND_LIBS "")
-if(WAYLAND_CLIENT_FOUND)
+if(NOT APPLE)
+    if(WAYLAND_CLIENT_FOUND)
        list(APPEND WAYLAND_LIBS ${WAYLAND_CLIENT_LIBRARIES})
        message(STATUS "Found Wayland client")
-endif()
-if(WAYLAND_EGL_FOUND)
+    endif()
+    if(WAYLAND_EGL_FOUND)
        list(APPEND WAYLAND_LIBS ${WAYLAND_EGL_LIBRARIES})
        message(STATUS "Found Wayland EGL")
+    endif()
 endif()
--- a/cmake/Packaging.cmake
+++ b/cmake/Packaging.cmake
@@ -27,7 +27,7 @@ set(CPACK_NSIS_CREATE_DESKTOP_LINKS "bin/clrsync_gui.exe;clrsync")

 # Debian
 set(CPACK_DEBIAN_PACKAGE_MAINTAINER "Daniel Dada <dan@binarygoose.dev>")
-set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.31), libglfw3, libfreetype6")
+set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.31), libglfw3, libfreetype6, zlib1g, libharfbuzz0b")
 set(CPACK_DEBIAN_PACKAGE_SECTION "utils")
 set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
 set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
@@ -36,6 +36,6 @@ set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
 set(CPACK_RPM_PACKAGE_LICENSE "MIT")
 set(CPACK_RPM_PACKAGE_GROUP "Applications/System")
 set(CPACK_RPM_PACKAGE_URL "https://github.com/obsqrbtz/clrsync")
-set(CPACK_RPM_PACKAGE_REQUIRES "freetype, glfw, fontconfig")
+set(CPACK_RPM_PACKAGE_REQUIRES "freetype, glfw, fontconfig, zlib, harfbuzz")

 include(CPack)
--- a/example_config/config.toml
+++ b/example_config/config.toml
@@ -1,5 +1,5 @@
 [general]
-default_theme = 'cursed'
+default_theme = 'dark'
 palettes_path = '~/.config/clrsync/palettes'
 font = 'JetBrainsMono Nerd Font Mono'
 font_size = 14
--- a/example_config/palettes/cursed-light.toml
+++ b/example_config/palettes/cursed-light.toml
@@ -1,67 +0,0 @@
-[colors]
-# General
-background = "#f5f5f5FF"
-on_background = "#3d3d2fFF"
-
-surface = "#e8e8e8FF"
-on_surface = "#3d3d2fFF"
-
-surface_variant = "#d0d0c8FF"
-on_surface_variant = "#3d3d2fFF"
-
-border_focused = "#c9a305FF"
-border = "#d0d0c8FF"
-
-foreground = "#3d3d2fFF"
-
-cursor = "#c9a305FF"
-accent = "#b44242FF"
-
-# Terminal
-base00 = "#f5f5f5FF"
-base01 = "#b44242FF"
-base02 = "#95a328FF"
-base03 = "#c9a305FF"
-base04 = "#60928fFF"
-base05 = "#7c435aFF"
-base06 = "#a48b4aFF"
-base07 = "#3d3d2fFF"
-base08 = "#c0c0b8FF"
-base09 = "#dc7671FF"
-base0A = "#d4d430FF"
-base0B = "#9e9052FF"
-base0C = "#76c39bFF"
-base0D = "#86596cFF"
-base0E = "#b89a1fFF"
-base0F = "#4f4f48FF"
-
-# Semantic
-success = "#95a328FF"
-info = "#60928fFF"
-warning = "#c9a305FF"
-error = "#b44242FF"
-
-on_success = "#f5f5f5FF"
-on_info = "#f5f5f5FF"
-on_warning = "#f5f5f5FF"
-on_error = "#f5f5f5FF"
-
-# Code editor
-editor_background = "#f5f5f5FF"
-editor_command = "#b89a1fFF"
-editor_comment = "#a0a098FF"
-editor_disabled = "#c0c0b8FF"
-editor_emphasis = "#dc7671FF"
-editor_error = "#b44242FF"
-editor_inactive = "#a0a098FF"
-editor_line_number = "#86596cFF"
-editor_link = "#60928fFF"
-editor_main = "#3d3d2fFF"
-editor_selected = "#d0d0c8FF"
-editor_selection_inactive = "#e0e0d8FF"
-editor_string = "#5fa37bFF"
-editor_success = "#95a328FF"
-editor_warning = "#c9a305FF"
-
-[general]
-name = 'cursed-light'
--- a/example_config/palettes/dark.toml
+++ b/example_config/palettes/dark.toml
@@ -0,0 +1,54 @@
+[colors]
+accent = '#9A8652FF'
+background = '#111111FF'
+base00 = '#111111FF'
+base01 = '#668A51FF'
+base02 = '#9A8652FF'
+base03 = '#B47837FF'
+base04 = '#9A5552FF'
+base05 = '#AA477BFF'
+base06 = '#3A898CFF'
+base07 = '#B5B5B5FF'
+base08 = '#AA4E4AFF'
+base09 = '#A9DC86FF'
+base0A = '#B6AB82FF'
+base0B = '#C5916BFF'
+base0C = '#AC7676FF'
+base0D = '#B0779EFF'
+base0E = '#849899FF'
+base0F = '#D2D2D2FF'
+border = '#242424FF'
+border_focused = '#2E2E2EFF'
+cursor = '#D2D2D2FF'
+editor_background = '#111111FF'
+editor_command = '#3A898CFF'
+editor_comment = '#849899FF'
+editor_disabled = '#849899FF'
+editor_emphasis = '#A9DC86FF'
+editor_error = '#AA4E4AFF'
+editor_inactive = '#849899FF'
+editor_line_number = '#849899FF'
+editor_link = '#B0779EFF'
+editor_main = '#D2D2D2FF'
+editor_selected = '#242424FF'
+editor_selection_inactive = '#1D1C1CFF'
+editor_string = '#9A8652FF'
+editor_success = '#668A51FF'
+editor_warning = '#B47837FF'
+error = '#AA4E4AFF'
+foreground = '#D2D2D2FF'
+info = '#3A898CFF'
+on_background = '#D4D4D4FF'
+on_error = '#D2D2D2FF'
+on_info = '#D2D2D2FF'
+on_success = '#D2D2D2FF'
+on_surface = '#D4D4D4FF'
+on_surface_variant = '#D4D4D4FF'
+on_warning = '#D2D2D2FF'
+success = '#668A51FF'
+surface = '#111111FF'
+surface_variant = '#191919FF'
+warning = '#B47837FF'
+
+[general]
+name = 'dark'
--- a/example_config/palettes/light.toml
+++ b/example_config/palettes/light.toml
@@ -0,0 +1,54 @@
+[colors]
+accent = '#9A8652FF'
+background = '#E0E0E0FF'
+base00 = '#E0E0E0FF'
+base01 = '#668A51FF'
+base02 = '#9A8652FF'
+base03 = '#B47837FF'
+base04 = '#9A5552FF'
+base05 = '#AA477BFF'
+base06 = '#3A898CFF'
+base07 = '#5A5A5AFF'
+base08 = '#AA4E4AFF'
+base09 = '#4A7A2EFF'
+base0A = '#7A6A42FF'
+base0B = '#A5714BFF'
+base0C = '#8C5656FF'
+base0D = '#90577EFF'
+base0E = '#2A6A6DFF'
+base0F = '#2A2A2AFF'
+border = '#C5C5C5FF'
+border_focused = '#B9B9B9FF'
+cursor = '#2A2A2AFF'
+editor_background = '#E0E0E0FF'
+editor_command = '#3A898CFF'
+editor_comment = '#849899FF'
+editor_disabled = '#A0A0A0FF'
+editor_emphasis = '#4A7A2EFF'
+editor_error = '#AA4E4AFF'
+editor_inactive = '#A0A0A0FF'
+editor_line_number = '#9A9A95FF'
+editor_link = '#90577EFF'
+editor_main = '#2A2A2AFF'
+editor_selected = '#C9C9C9FF'
+editor_selection_inactive = '#D2D2D2FF'
+editor_string = '#9A8652FF'
+editor_success = '#668A51FF'
+editor_warning = '#B47837FF'
+error = '#AA4E4AFF'
+foreground = '#2A2A2AFF'
+info = '#3A898CFF'
+on_background = '#2A2A2AFF'
+on_error = '#FAFAF8FF'
+on_info = '#FAFAF8FF'
+on_success = '#FAFAF8FF'
+on_surface = '#2A2A2AFF'
+on_surface_variant = '#3A3A3AFF'
+on_warning = '#FAFAF8FF'
+success = '#668A51FF'
+surface = '#E0E0E0FF'
+surface_variant = '#CECECEFF'
+warning = '#B47837FF'
+
+[general]
+name = 'light'
--- a/extra/palettes/cursed-light.toml
+++ b/extra/palettes/cursed-light.toml
@@ -0,0 +1,54 @@
+[colors]
+accent = '#95A328FF'
+background = '#F5F5F5FF'
+base00 = '#F5F5F5FF'
+base01 = '#B44242FF'
+base02 = '#95A328FF'
+base03 = '#C9A305FF'
+base04 = '#60928FFF'
+base05 = '#7C435AFF'
+base06 = '#A48B4AFF'
+base07 = '#3D3D2FFF'
+base08 = '#C0C0B8FF'
+base09 = '#DC7671FF'
+base0A = '#D4D430FF'
+base0B = '#9E9052FF'
+base0C = '#76C39BFF'
+base0D = '#86596CFF'
+base0E = '#B89A1FFF'
+base0F = '#4F4F48FF'
+border = '#D0D0C8FF'
+border_focused = '#C9A305FF'
+cursor = '#C9A305FF'
+editor_background = '#F5F5F5FF'
+editor_command = '#B89A1FFF'
+editor_comment = '#A0A098FF'
+editor_disabled = '#C0C0B8FF'
+editor_emphasis = '#DC7671FF'
+editor_error = '#B44242FF'
+editor_inactive = '#A0A098FF'
+editor_line_number = '#86596CFF'
+editor_link = '#60928FFF'
+editor_main = '#3D3D2FFF'
+editor_selected = '#D0D0C8FF'
+editor_selection_inactive = '#E0E0D8FF'
+editor_string = '#5FA37BFF'
+editor_success = '#95A328FF'
+editor_warning = '#C9A305FF'
+error = '#B44242FF'
+foreground = '#3D3D2FFF'
+info = '#60928FFF'
+on_background = '#3D3D2FFF'
+on_error = '#F5F5F5FF'
+on_info = '#F5F5F5FF'
+on_success = '#F5F5F5FF'
+on_surface = '#3D3D2FFF'
+on_surface_variant = '#CCCCCCFF'
+on_warning = '#F5F5F5FF'
+success = '#95A328FF'
+surface = '#E8E8E8FF'
+surface_variant = '#D0D0C8FF'
+warning = '#C9A305FF'
+
+[general]
+name = 'cursed-light'
--- a/example_config/palettes/cursed.toml
+++ b/example_config/palettes/cursed.toml
@@ -1,5 +1,5 @@
 [colors]
-accent = '#B44242FF'
+accent = '#95A328FF'
 background = '#151515FF'
 base00 = '#151515FF'
 base01 = '#B44242FF'
@@ -22,7 +22,7 @@ border_focused = '#E1C135FF'
 cursor = '#E1C135FF'
 editor_background = '#151515FF'
 editor_command = '#CEB34FFF'
-editor_comment = '#3F3639FF'
+editor_comment = '#7A7A7AFF'
 editor_disabled = '#3F3639FF'
 editor_emphasis = '#DC7671FF'
 editor_error = '#B44242FF'
@@ -43,7 +43,7 @@ on_error = '#151515FF'
 on_info = '#151515FF'
 on_success = '#151515FF'
 on_surface = '#C2C2B0FF'
-on_surface_variant = '#C2C2B0FF'
+on_surface_variant = '#CCCCCCFF'
 on_warning = '#151515FF'
 success = '#95A328FF'
 surface = '#1C1C1CFF'
--- a/extra/palettes/nord.toml
+++ b/extra/palettes/nord.toml
@@ -0,0 +1,54 @@
+[colors]
+accent = '#5E81ACFF'
+background = '#2E3440FF'
+base00 = '#2E3440FF'
+base01 = '#BF616AFF'
+base02 = '#A3BE8CFF'
+base03 = '#EBCB8BFF'
+base04 = '#81A1C1FF'
+base05 = '#B48EADFF'
+base06 = '#88C0D0FF'
+base07 = '#E5E9F0FF'
+base08 = '#4C566AFF'
+base09 = '#D08770FF'
+base0A = '#EBCB8BFF'
+base0B = '#A3BE8CFF'
+base0C = '#8FBCBBFF'
+base0D = '#5E81ACFF'
+base0E = '#B48EADFF'
+base0F = '#ECEFF4FF'
+border = '#4C566AFF'
+border_focused = '#88C0D0FF'
+cursor = '#D8DEE9FF'
+editor_background = '#2E3440FF'
+editor_command = '#81A1C1FF'
+editor_comment = '#616E88FF'
+editor_disabled = '#4C566AFF'
+editor_emphasis = '#B48EADFF'
+editor_error = '#BF616AFF'
+editor_inactive = '#616E88FF'
+editor_line_number = '#4C566AFF'
+editor_link = '#88C0D0FF'
+editor_main = '#D8DEE9FF'
+editor_selected = '#434C5EFF'
+editor_selection_inactive = '#3B4252FF'
+editor_string = '#A3BE8CFF'
+editor_success = '#A3BE8CFF'
+editor_warning = '#EBCB8BFF'
+error = '#BF616AFF'
+foreground = '#D8DEE9FF'
+info = '#5E81ACFF'
+on_background = '#D8DEE9FF'
+on_error = '#2E3440FF'
+on_info = '#2E3440FF'
+on_success = '#2E3440FF'
+on_surface = '#ECEFF4FF'
+on_surface_variant = '#ECEFF4FF'
+on_warning = '#2E3440FF'
+success = '#A3BE8CFF'
+surface = '#3B4252FF'
+surface_variant = '#434C5EFF'
+warning = '#EBCB8BFF'
+
+[general]
+name = 'nord'
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1764950072,
-        "narHash": "sha256-BmPWzogsG2GsXZtlT+MTcAWeDK5hkbGRZTeZNW42fwA=",
+        "lastModified": 1765779637,
+        "narHash": "sha256-KJ2wa/BLSrTqDjbfyNx70ov/HdgNBCBBSQP3BIzKnv4=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "f61125a668a320878494449750330ca58b78c557",
+        "rev": "1306659b587dc277866c7b69eb97e5f07864d8c4",
        "type": "github"
      },
      "original": {
--- a/flake.nix
+++ b/flake.nix
@@ -13,6 +13,14 @@
      ];
      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
      nixpkgsFor = forAllSystems (system: import nixpkgs { inherit system; });
+
+      baseVersion = nixpkgs.lib.removeSuffix "\n" (builtins.readFile ./VERSION);
+
+      semver =
+        if self ? rev then
+          "${baseVersion}+git.${builtins.substring 0 7 self.rev}"
+        else
+          "${baseVersion}+dev";
    in
    {
      packages = forAllSystems (
@@ -21,7 +29,7 @@
          pkgs = nixpkgsFor.${system};
        in
        rec {
-          clrsync = pkgs.callPackage ./package.nix { };
+          clrsync = pkgs.callPackage ./package.nix { inherit semver; };
          default = clrsync;
        }
      );
@@ -59,12 +67,12 @@
        system:
        let
          pkgs = nixpkgsFor.${system};
+          clrsync = self.packages.${system}.clrsync;
        in
        {
          default = pkgs.mkShell {
-            inputsFrom = [ self.packages.${system}.clrsync ];
-
-            buildInputs = with pkgs; [
+            inputsFrom = [ clrsync ];
+            packages = with pkgs; [
              cmake
              ninja
              clang-tools
--- a/package.nix
+++ b/package.nix
@@ -5,6 +5,7 @@
  git,
  pkg-config,
  makeWrapper,
+  wrapGAppsHook3,
  wayland-protocols,
  glfw,
  freetype,
@@ -16,11 +17,16 @@
  zlib,
  bzip2,
  wayland-scanner,
+  gtk3,
+  glib,
+  gsettings-desktop-schemas,
+  semver,
 }:

 stdenv.mkDerivation rec {
  pname = "clrsync";
-  version = "unstable-2024-12-15";
+
+  version = semver;

  src = lib.cleanSourceWith {
    src = ./.;
@@ -46,6 +52,7 @@ stdenv.mkDerivation rec {
    git
    pkg-config
    makeWrapper
+    wrapGAppsHook3
    wayland-protocols
  ];

@@ -65,11 +72,15 @@ stdenv.mkDerivation rec {
    libxkbcommon
    zlib
    bzip2
+    gtk3
+    gsettings-desktop-schemas
+    glib
  ];

  cmakeFlags = [
    "-DCMAKE_BUILD_TYPE=Release"
    "-DUSE_SYSTEM_GLFW=ON"
+    "-DCLRSYNC_SEMVER=${version}"
  ];

  installPhase = ''
@@ -77,21 +88,17 @@ stdenv.mkDerivation rec {

    cmake --install . --prefix $out

-    wrapProgram $out/bin/clrsync_gui \
-      --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath buildInputs}
-
-    wrapProgram $out/bin/clrsync_cli \
-      --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath buildInputs}
-
    runHook postInstall
  '';

+  dontWrapGApps = false;
+
  meta = with lib; {
    description = "Color scheme manager with GUI and CLI";
    homepage = "https://github.com/obsqrbtz/clrsync";
    license = licenses.mit;
    platforms = platforms.linux;
    mainProgram = "clrsync_gui";
-    maintainers = [ ];
+    maintainers = [ "Daniel Dada" ];
  };
 }
--- a/src/cli/main.cpp
+++ b/src/cli/main.cpp
@@ -4,14 +4,15 @@

 #include <argparse/argparse.hpp>

-#include <core/config/config.hpp>
-#include <core/io/toml_file.hpp>
-#include <core/palette/palette_file.hpp>
-#include <core/palette/palette_manager.hpp>
-#include <core/theme/theme_renderer.hpp>
-#include <core/theme/theme_template.hpp>
-#include <core/utils.hpp>
-#include <core/version.hpp>
+#include "core/common/error.hpp"
+#include "core/common/utils.hpp"
+#include "core/common/version.hpp"
+#include "core/config/config.hpp"
+#include "core/io/toml_file.hpp"
+#include "core/palette/palette_file.hpp"
+#include "core/palette/palette_manager.hpp"
+#include "core/theme/theme_renderer.hpp"
+#include "core/theme/theme_template.hpp"

 void handle_show_vars()
 {
@@ -35,16 +36,17 @@ int handle_apply_theme(const argparse::ArgumentParser &program, const std::strin
 {
    clrsync::core::theme_renderer<clrsync::core::io::toml_file> renderer;
    std::string theme_identifier;
+    clrsync::core::Result<void> result = clrsync::core::Ok();

    if (program.is_used("--theme"))
    {
        theme_identifier = program.get<std::string>("--theme");
-        renderer.apply_theme(theme_identifier);
+        result = renderer.apply_theme(theme_identifier);
    }
    else if (program.is_used("--path"))
    {
        theme_identifier = program.get<std::string>("--path");
-        renderer.apply_theme_from_path(theme_identifier);
+        result = renderer.apply_theme_from_path(theme_identifier);
    }
    else
    {
@@ -54,17 +56,23 @@ int handle_apply_theme(const argparse::ArgumentParser &program, const std::strin
            return 1;
        }
        theme_identifier = default_theme;
-        renderer.apply_theme(theme_identifier);
+        result = renderer.apply_theme(theme_identifier);
+    }
+
+    if (!result)
+    {
+        std::cerr << "Failed to apply theme: " << result.error().description() << std::endl;
+        return 1;
    }

    std::cout << "Applied theme " << theme_identifier << std::endl;
    return 0;
 }

-void initialize_config(const std::string &config_path)
+clrsync::core::Result<void> initialize_config(const std::string &config_path)
 {
    auto conf = std::make_unique<clrsync::core::io::toml_file>(config_path);
-    clrsync::core::config::instance().initialize(std::move(conf));
+    return clrsync::core::config::instance().initialize(std::move(conf));
 }

 void setup_argument_parser(argparse::ArgumentParser &program)
@@ -103,13 +111,10 @@ int main(int argc, char *argv[])

    std::string config_path = program.get<std::string>("--config");

-    try
+    auto config_result = initialize_config(config_path);
+    if (!config_result)
    {
-        initialize_config(config_path);
-    }
-    catch (const std::exception &err)
-    {
-        std::cerr << "Error loading config: " << err.what() << std::endl;
+        std::cerr << "Error loading config: " << config_result.error().description() << std::endl;
        return 1;
    }

--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -2,8 +2,8 @@ set(CORE_SOURCES
    palette/color.cpp
    io/toml_file.cpp
    config/config.cpp
-    utils.cpp
-    version.cpp
+        common/utils.cpp
+        common/version.cpp
    theme/theme_template.cpp
 )

--- a/src/core/common/error.hpp
+++ b/src/core/common/error.hpp
@@ -0,0 +1,266 @@
+#ifndef CLRSYNC_CORE_ERROR_HPP
+#define CLRSYNC_CORE_ERROR_HPP
+
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace clrsync::core
+{
+
+enum class error_code
+{
+    unknown,
+
+    file_not_found,
+    file_open_failed,
+    file_write_failed,
+    file_read_failed,
+    dir_create_failed,
+
+    parse_failed,
+    invalid_format,
+
+    config_missing,
+    config_invalid,
+
+    template_not_found,
+    template_load_failed,
+    template_apply_failed,
+
+    palette_not_found,
+    palette_load_failed,
+
+    init_failed,
+    invalid_arg,
+    resource_missing,
+};
+
+inline const char *error_code_string(error_code code)
+{
+    switch (code)
+    {
+    case error_code::unknown:
+        return "Unknown error";
+    case error_code::file_not_found:
+        return "File not found";
+    case error_code::file_open_failed:
+        return "Failed to open file";
+    case error_code::file_write_failed:
+        return "Failed to write file";
+    case error_code::file_read_failed:
+        return "Failed to read file";
+    case error_code::dir_create_failed:
+        return "Failed to create directory";
+    case error_code::parse_failed:
+        return "Parse failed";
+    case error_code::invalid_format:
+        return "Invalid format";
+    case error_code::config_missing:
+        return "Configuration missing";
+    case error_code::config_invalid:
+        return "Configuration invalid";
+    case error_code::template_not_found:
+        return "Template not found";
+    case error_code::template_load_failed:
+        return "Failed to load template";
+    case error_code::template_apply_failed:
+        return "Failed to apply template";
+    case error_code::palette_not_found:
+        return "Palette not found";
+    case error_code::palette_load_failed:
+        return "Failed to load palette";
+    case error_code::init_failed:
+        return "Initialization failed";
+    case error_code::invalid_arg:
+        return "Invalid argument";
+    case error_code::resource_missing:
+        return "Resource missing";
+    default:
+        return "Unknown error code";
+    }
+}
+
+struct Error
+{
+    error_code code;
+    std::string message;
+    std::string context;
+
+    Error(error_code c) : code(c), message(error_code_string(c))
+    {
+    }
+
+    Error(error_code c, std::string msg) : code(c), message(std::move(msg))
+    {
+    }
+
+    Error(error_code c, std::string msg, std::string ctx)
+        : code(c), message(std::move(msg)), context(std::move(ctx))
+    {
+    }
+
+    std::string description() const
+    {
+        if (context.empty())
+            return message;
+        return message + " [" + context + "]";
+    }
+};
+
+template <typename T> class [[nodiscard]] Result
+{
+  private:
+    std::variant<T, Error> m_data;
+
+  public:
+    Result(T value) : m_data(std::move(value))
+    {
+    }
+
+    Result(Error error) : m_data(std::move(error))
+    {
+    }
+
+    bool is_ok() const
+    {
+        return std::holds_alternative<T>(m_data);
+    }
+
+    bool is_error() const
+    {
+        return std::holds_alternative<Error>(m_data);
+    }
+
+    explicit operator bool() const
+    {
+        return is_ok();
+    }
+
+    T &value() &
+    {
+        return std::get<T>(m_data);
+    }
+    const T &value() const &
+    {
+        return std::get<T>(m_data);
+    }
+    T &&value() &&
+    {
+        return std::get<T>(std::move(m_data));
+    }
+
+    const Error &error() const
+    {
+        return std::get<Error>(m_data);
+    }
+
+    T value_or(T default_value) const
+    {
+        return is_ok() ? std::get<T>(m_data) : std::move(default_value);
+    }
+
+    std::optional<T> ok() const
+    {
+        if (is_ok())
+            return std::get<T>(m_data);
+        return std::nullopt;
+    }
+
+    std::optional<Error> err() const
+    {
+        if (is_error())
+            return std::get<Error>(m_data);
+        return std::nullopt;
+    }
+
+    template <typename F> auto map(F &&func) -> Result<decltype(func(std::declval<T>()))>
+    {
+        using U = decltype(func(std::declval<T>()));
+        if (is_ok())
+            return Result<U>(func(std::get<T>(m_data)));
+        return Result<U>(std::get<Error>(m_data));
+    }
+
+    template <typename F> auto and_then(F &&func) -> decltype(func(std::declval<T>()))
+    {
+        if (is_ok())
+            return func(std::get<T>(m_data));
+        using ResultType = decltype(func(std::declval<T>()));
+        return ResultType(std::get<Error>(m_data));
+    }
+};
+
+template <> class [[nodiscard]] Result<void>
+{
+  private:
+    std::optional<Error> m_error;
+
+  public:
+    Result() : m_error(std::nullopt)
+    {
+    }
+
+    Result(Error error) : m_error(std::move(error))
+    {
+    }
+
+    bool is_ok() const
+    {
+        return !m_error.has_value();
+    }
+
+    bool is_error() const
+    {
+        return m_error.has_value();
+    }
+
+    explicit operator bool() const
+    {
+        return is_ok();
+    }
+
+    const Error &error() const
+    {
+        return *m_error;
+    }
+
+    std::optional<Error> err() const
+    {
+        return m_error;
+    }
+};
+
+template <typename T> Result<T> Ok(T value)
+{
+    return Result<T>(std::move(value));
+}
+
+inline Result<void> Ok()
+{
+    return Result<void>();
+}
+
+template <typename T> Result<T> Err(Error error)
+{
+    return Result<T>(std::move(error));
+}
+
+template <typename T> Result<T> Err(error_code code)
+{
+    return Result<T>(Error(code));
+}
+
+template <typename T> Result<T> Err(error_code code, std::string message)
+{
+    return Result<T>(Error(code, std::move(message)));
+}
+
+template <typename T> Result<T> Err(error_code code, std::string message, std::string context)
+{
+    return Result<T>(Error(code, std::move(message), std::move(context)));
+}
+
+} // namespace clrsync::core
+
+#endif // CLRSYNC_CORE_ERROR_HPP
--- a/src/core/common/utils.cpp
+++ b/src/core/common/utils.cpp
@@ -0,0 +1,56 @@
+#include "utils.hpp"
+#include <filesystem>
+#include <iostream>
+
+namespace clrsync::core
+{
+void print_color_keys()
+{
+    for (const auto &key : clrsync::core::COLOR_KEYS)
+    {
+        std::cout << key << std::endl;
+    }
+}
+
+std::string get_default_config_path()
+{
+    const char *env_path = std::getenv("CLRSYNC_CONFIG_PATH");
+    if (env_path && env_path[0] != '\0')
+        return normalize_path(env_path).string();
+
+    std::filesystem::path home = normalize_path("~");
+    std::filesystem::path config_path = home / ".config" / "clrsync" / "config.toml";
+    return config_path.string();
+}
+
+std::string expand_user(const std::string &path)
+{
+    if (path.empty() || path[0] != '~')
+        return path;
+
+    if (path.length() == 1 || path[1] == '/' || path[1] == '\\')
+    {
+#ifdef _WIN32
+        const char *home = std::getenv("USERPROFILE");
+#else
+        const char *home = std::getenv("HOME");
+#endif
+        if (!home)
+            return path;
+
+        if (path.length() == 1)
+            return std::string(home);
+
+        return std::string(home) + path.substr(1);
+    }
+    return path;
+}
+
+std::filesystem::path normalize_path(const std::string &path)
+{
+    std::string expanded = expand_user(path);
+    std::filesystem::path fs_path(expanded);
+    return fs_path.lexically_normal();
+}
+
+} // namespace clrsync::core
--- a/src/core/common/utils.hpp
+++ b/src/core/common/utils.hpp
@@ -1,14 +1,16 @@
 #ifndef CLRSYNC_CORE_UTILS_HPP
 #define CLRSYNC_CORE_UTILS_HPP

+#include <filesystem>
 #include <string>

-#include <core/palette/color_keys.hpp>
+#include "core/palette/color_keys.hpp"

 namespace clrsync::core
 {
 void print_color_keys();
 std::string get_default_config_path();
 std::string expand_user(const std::string &path);
+std::filesystem::path normalize_path(const std::string &path);
 } // namespace clrsync::core
 #endif // CLRSYNC_CORE_UTILS_HPP
--- a/src/core/common/version.cpp
+++ b/src/core/common/version.cpp
@@ -0,0 +1,9 @@
+#include "core/common/version.hpp"
+
+namespace clrsync::core
+{
+const std::string version_string()
+{
+    return GIT_SEMVER;
+}
+} // namespace clrsync::core
--- a/src/core/common/version.hpp
+++ b/src/core/common/version.hpp
@@ -1,15 +1,12 @@
 #ifndef CLRSYNC_CORE_VERSION_HPP
 #define CLRSYNC_CORE_VERSION_HPP

-#include <cstdint>
 #include <string>

 namespace clrsync::core
 {

-constexpr uint8_t VERSION_MAJOR = 0;
-constexpr uint8_t VERSION_MINOR = 1;
-constexpr uint8_t VERSION_PATCH = 4;
+const std::string GIT_SEMVER = "0.1.6+git.gdff3e91";

 const std::string version_string();
 } // namespace clrsync::core
--- a/src/core/common/version.hpp.in
+++ b/src/core/common/version.hpp.in
@@ -1,15 +1,12 @@
 #ifndef CLRSYNC_CORE_VERSION_HPP
 #define CLRSYNC_CORE_VERSION_HPP

-#include <cstdint>
 #include <string>

 namespace clrsync::core
 {

-constexpr uint8_t VERSION_MAJOR = @PROJECT_VERSION_MAJOR@;
-constexpr uint8_t VERSION_MINOR = @PROJECT_VERSION_MINOR@;
-constexpr uint8_t VERSION_PATCH = @PROJECT_VERSION_PATCH@;
+const std::string GIT_SEMVER = "@SEMVER@";

 const std::string version_string();
 } // namespace clrsync::core
--- a/src/core/config/config.cpp
+++ b/src/core/config/config.cpp
@@ -1,14 +1,16 @@
 #include "config.hpp"
-#include "core/utils.hpp"
+#include "core/common/error.hpp"
+#include "core/common/utils.hpp"
+#include "core/io/toml_file.hpp"

-#include <core/palette/color.hpp>
+#include "core/palette/color.hpp"
 #include <filesystem>
 #include <fstream>
-#include <stdexcept>

 #ifdef _WIN32
 #include "windows.h"
 #endif
+#include <iostream>

 namespace clrsync::core
 {
@@ -18,24 +20,80 @@ config &config::instance()
    return inst;
 }

-void config::initialize(std::unique_ptr<clrsync::core::io::file> file)
+Result<void> config::initialize(std::unique_ptr<clrsync::core::io::file> file)
 {
    copy_default_configs();
    m_file = std::move(file);
-    if (m_file)
-        if (!m_file->parse())
-            throw std::runtime_error{"Could not parse config file"};
+    if (!m_file)
+        return Err<void>(error_code::config_missing, "Config file is missing");
+
+    auto parse_result = m_file->parse();
+    if (!parse_result)
+        return Err<void>(error_code::config_invalid, parse_result.error().message,
+                         parse_result.error().context);
+
+    std::filesystem::path config_path = get_user_config_dir() / "config.toml";
+    std::filesystem::path temp_config_path = get_user_config_dir() / "config-temp.toml";
+    
+    if (std::filesystem::exists(config_path))
+    {
+        std::error_code ec;
+        auto perms = std::filesystem::status(config_path, ec).permissions();
+        
+        if (ec || (perms & std::filesystem::perms::owner_write) == std::filesystem::perms::none)
+        {
+            m_temp_config_path = temp_config_path.string();
+            
+            if (std::filesystem::exists(temp_config_path))
+            {
+                try
+                {
+                    auto temp_conf = std::make_unique<clrsync::core::io::toml_file>(temp_config_path.string());
+                    auto temp_parse = temp_conf->parse();
+                    if (temp_parse)
+                    {
+                        m_temp_file = std::move(temp_conf);
+                    }
+                }
+                catch (const std::exception &e)
+                {
+                    std::cerr << "Warning: Failed to load temp config: " << e.what() << std::endl;
+                }
+            }
+        }
+    }
+
+    return Ok();
 }

 std::filesystem::path config::get_user_config_dir()
 {
-    auto home = expand_user("~");
-#ifdef _WIN32
-    return home + "\\.config\\clrsync";
+    std::filesystem::path home = normalize_path("~");
+    return home / ".config" / "clrsync";
+}

-#else
-    return home + "/.config/clrsync";
-#endif
+std::filesystem::path config::get_user_state_dir()
+{
+    std::filesystem::path home = normalize_path("~");
+    return home / ".local" / "state" / "clrsync";
+}
+
+std::filesystem::path config::get_writable_config_path()
+{
+    std::filesystem::path config_path = get_user_config_dir() / "config.toml";
+    
+    if (std::filesystem::exists(config_path))
+    {
+        std::error_code ec;
+        auto perms = std::filesystem::status(config_path, ec).permissions();
+        
+        if (ec || (perms & std::filesystem::perms::owner_write) == std::filesystem::perms::none)
+        {
+            return get_user_config_dir() / "config-temp.toml";
+        }
+    }
+    
+    return config_path;
 }

 std::filesystem::path config::get_data_dir()
@@ -62,13 +120,23 @@ void config::copy_file(const std::filesystem::path &src, const std::filesystem::
    if (std::filesystem::exists(dst))
        return;

+    if (!std::filesystem::exists(src))
+        return;
+
    std::ifstream in(src, std::ios::binary);
    std::ofstream out(dst, std::ios::binary);
+
+    if (!in || !out)
+        return;
+
    out << in.rdbuf();
 }

 void config::copy_dir(const std::filesystem::path &src, const std::filesystem::path &dst)
 {
+    if (!std::filesystem::exists(src))
+        return;
+
    for (auto const &entry : std::filesystem::recursive_directory_iterator(src))
    {
        auto rel = std::filesystem::relative(entry.path(), src);
@@ -92,6 +160,9 @@ void config::copy_default_configs()

    std::filesystem::create_directories(user_dir);

+    if (system_dir.empty())
+        return;
+
    {
        auto src = system_dir / "config.toml";
        auto dst = user_dir / "config.toml";
@@ -120,15 +191,50 @@ void config::copy_default_configs()
    }
 }

+Result<void> config::save_config_value(const std::string &section, const std::string &key, const value_type &value)
+{
+    if (!m_temp_config_path.empty())
+    {
+        if (!m_temp_file)
+        {
+            m_temp_file = std::make_unique<clrsync::core::io::toml_file>(m_temp_config_path);
+            m_temp_file->parse();
+        }
+        
+        m_temp_file->set_value(section, key, value);
+        return m_temp_file->save_file();
+    }
+    
+    m_file->set_value(section, key, value);
+    return m_file->save_file();
+}
+
 const std::string &config::palettes_path()
 {
    if (m_palettes_dir.empty() && m_file)
+    {
+        if (m_temp_file)
+        {
+            auto temp_value = m_temp_file->get_string_value("general", "palettes_path");
+            if (!temp_value.empty())
+            {
+                m_palettes_dir = temp_value;
+                return m_palettes_dir;
+            }
+        }
        m_palettes_dir = m_file->get_string_value("general", "palettes_path");
+    }
    return m_palettes_dir;
 }

 const std::string config::default_theme() const
 {
+    if (m_temp_file)
+    {
+        auto temp_value = m_temp_file->get_string_value("general", "default_theme");
+        if (!temp_value.empty())
+            return temp_value;
+    }
    if (m_file)
        return m_file->get_string_value("general", "default_theme");
    return {};
@@ -136,6 +242,12 @@ const std::string config::default_theme() const

 const std::string config::font() const
 {
+    if (m_temp_file)
+    {
+        auto temp_value = m_temp_file->get_string_value("general", "font");
+        if (!temp_value.empty())
+            return temp_value;
+    }
    if (m_file)
        return m_file->get_string_value("general", "font");
    return {};
@@ -143,55 +255,106 @@ const std::string config::font() const

 const uint32_t config::font_size() const
 {
+    if (m_temp_file)
+    {
+        auto temp_value = m_temp_file->get_uint_value("general", "font_size");
+        if (temp_value != 0)
+            return temp_value;
+    }
    if (m_file)
        return m_file->get_uint_value("general", "font_size");
    return 14;
 }

-void config::set_default_theme(const std::string &theme)
+Result<void> config::set_default_theme(const std::string &theme)
 {
-    if (m_file)
-    {
-        m_file->set_value("general", "default_theme", theme);
-        m_file->save_file();
-    }
+    if (!m_file)
+        return Err<void>(error_code::config_missing, "Configuration not initialized");
+
+    return save_config_value("general", "default_theme", theme);
 }

-void config::set_palettes_path(const std::string &path)
+Result<void> config::set_palettes_path(const std::string &path)
 {
-    if (m_file)
-    {
-        m_file->set_value("general", "palettes_path", path);
-        m_file->save_file();
-    }
+    if (!m_file)
+        return Err<void>(error_code::config_missing, "Configuration not initialized");
+
+    return save_config_value("general", "palettes_path", path);
 }

-void config::set_font(const std::string &font)
+Result<void> config::set_font(const std::string &font)
 {
-    if (m_file)
-    {
-        m_file->set_value("general", "font", font);
-        m_file->save_file();
-    }
+    if (!m_file)
+        return Err<void>(error_code::config_missing, "Configuration not initialized");
+
+    return save_config_value("general", "font", font);
 }
-void config::set_font_size(int font_size)
+Result<void> config::set_font_size(int font_size)
 {
-    if (m_file)
-    {
-        m_file->set_value("general", "font_size", font_size);
-        m_file->save_file();
-    }
+    if (!m_file)
+        return Err<void>(error_code::config_missing, "Configuration not initialized");
+
+    return save_config_value("general", "font_size", static_cast<uint32_t>(font_size));
 }

-void config::update_template(const std::string &key,
+Result<void> config::update_template(const std::string &key,
                                     const clrsync::core::theme_template &theme_template)
 {
+    if (!m_file)
+        return Err<void>(error_code::config_missing, "Configuration not initialized");
+
    m_themes[key] = theme_template;
-    m_file->set_value("templates." + key, "input_path", theme_template.template_path());
-    m_file->set_value("templates." + key, "output_path", theme_template.output_path());
-    m_file->set_value("templates." + key, "enabled", theme_template.enabled());
-    m_file->set_value("templates." + key, "reload_cmd", theme_template.reload_command());
-    m_file->save_file();
+    
+    auto result1 = save_config_value("templates." + key, "input_path", theme_template.template_path());
+    if (!result1) return result1;
+    
+    auto result2 = save_config_value("templates." + key, "output_path", theme_template.output_path());
+    if (!result2) return result2;
+    
+    auto result3 = save_config_value("templates." + key, "enabled", theme_template.enabled());
+    if (!result3) return result3;
+    
+    return save_config_value("templates." + key, "reload_cmd", theme_template.reload_command());
+}
+
+Result<void> config::remove_template(const std::string &key)
+{
+    if (!m_file)
+        return Err<void>(error_code::config_missing, "Configuration not initialized");
+
+    auto it = m_themes.find(key);
+    if (it == m_themes.end())
+        return Err<void>(error_code::template_not_found, "Template not found", key);
+
+    std::filesystem::path template_file = it->second.template_path();
+    if (std::filesystem::exists(template_file))
+    {
+        try
+        {
+            std::filesystem::remove(template_file);
+        }
+        catch (const std::exception &e)
+        {
+            return Err<void>(error_code::file_write_failed, "Failed to delete template file",
+                             e.what());
+        }
+    }
+
+    m_themes.erase(it);
+
+    if (!m_temp_config_path.empty())
+    {
+        if (!m_temp_file)
+        {
+            m_temp_file = std::make_unique<clrsync::core::io::toml_file>(m_temp_config_path);
+            m_temp_file->parse();
+        }
+        m_temp_file->remove_section("templates." + key);
+        return m_temp_file->save_file();
+    }
+    
+    m_file->remove_section("templates." + key);
+    return m_file->save_file();
 }

 const std::unordered_map<std::string, clrsync::core::theme_template> config::templates()
@@ -214,21 +377,23 @@ const std::unordered_map<std::string, clrsync::core::theme_template> config::tem
                theme.set_enabled(false);
            }
            theme.set_reload_command(std::get<std::string>(current["reload_cmd"]));
-            theme.load_template();
+            (void)theme.load_template();
            m_themes.insert({theme.name(), theme});
        }
    }
    return m_themes;
 }

-const clrsync::core::theme_template &config::template_by_name(const std::string &name) const
+Result<const clrsync::core::theme_template *> config::template_by_name(
+    const std::string &name) const
 {
    auto it = m_themes.find(name);
    if (it != m_themes.end())
    {
-        return it->second;
+        return Ok(&it->second);
    }
-    throw std::runtime_error("Template not found: " + name);
+    return Err<const clrsync::core::theme_template *>(error_code::template_not_found,
+                                                      "Template not found", name);
 }

 } // namespace clrsync::core
--- a/src/core/config/config.hpp
+++ b/src/core/config/config.hpp
@@ -1,8 +1,9 @@
 #ifndef CLRSYNC_CORE_CONFIG_HPP
 #define CLRSYNC_CORE_CONFIG_HPP

-#include <core/io/file.hpp>
-#include <core/theme/theme_template.hpp>
+#include "core/common/error.hpp"
+#include "core/io/file.hpp"
+#include "core/theme/theme_template.hpp"
 #include <filesystem>
 #include <memory>
 #include <string>
@@ -14,24 +15,26 @@ class config
  public:
    static config &instance();

-    void initialize(std::unique_ptr<clrsync::core::io::file> file);
+    Result<void> initialize(std::unique_ptr<clrsync::core::io::file> file);

    const std::string font() const;
    const uint32_t font_size() const;
    const std::string &palettes_path();
    const std::string default_theme() const;
    const std::unordered_map<std::string, clrsync::core::theme_template> templates();
-    const clrsync::core::theme_template &template_by_name(const std::string &name) const;
+    Result<const clrsync::core::theme_template *> template_by_name(const std::string &name) const;
    std::filesystem::path get_user_config_dir();
+    std::filesystem::path get_user_state_dir();
+    std::filesystem::path get_writable_config_path();

+    Result<void> set_default_theme(const std::string &theme);
+    Result<void> set_palettes_path(const std::string &path);
+    Result<void> set_font(const std::string &font);
+    Result<void> set_font_size(int font_size);

-    void set_default_theme(const std::string &theme);
-    void set_palettes_path(const std::string &path);
-    void set_font(const std::string &font);
-    void set_font_size(int font_size);
-
-    void update_template(const std::string &key,
+    Result<void> update_template(const std::string &key,
                                 const clrsync::core::theme_template &theme_template);
+    Result<void> remove_template(const std::string &key);
    static std::filesystem::path get_data_dir();

  private:
@@ -41,9 +44,12 @@ class config

    std::string m_palettes_dir{};
    std::unique_ptr<io::file> m_file;
+    std::unique_ptr<io::file> m_temp_file; 
+    std::string m_temp_config_path;
    std::unordered_map<std::string, theme_template> m_themes{};
-    static void copy_file(const std::filesystem::path& src, const std::filesystem::path& dst);
-    static void copy_dir(const std::filesystem::path& src, const std::filesystem::path& dst);
+    Result<void> save_config_value(const std::string &section, const std::string &key, const value_type &value);
+    static void copy_file(const std::filesystem::path &src, const std::filesystem::path &dst);
+    static void copy_dir(const std::filesystem::path &src, const std::filesystem::path &dst);
    void copy_default_configs();
 };
 } // namespace clrsync::core
--- a/src/core/io/file.hpp
+++ b/src/core/io/file.hpp
@@ -1,5 +1,6 @@
 #ifndef CLRSYNC_CORE_IO_FILE_HPP
 #define CLRSYNC_CORE_IO_FILE_HPP
+#include "core/common/error.hpp"
 #include <cstdint>
 #include <map>
 #include <string>
@@ -14,7 +15,11 @@ class file
  public:
    file() = default;
    file(std::string path) {};
-    virtual bool parse() { return false; };
+    virtual ~file() = default;
+    virtual Result<void> parse()
+    {
+        return Ok();
+    };
    virtual const std::string get_string_value(const std::string &section,
                                               const std::string &key) const
    {
@@ -39,7 +44,11 @@ class file
    }
    virtual void insert_or_update_value(const std::string &section, const std::string &key,
                                        const value_type &value) {};
-    virtual void save_file() {};
+    virtual void remove_section(const std::string &section) {};
+    virtual Result<void> save_file()
+    {
+        return Ok();
+    };
 };
 } // namespace clrsync::core::io
 #endif
--- a/src/core/io/toml_file.cpp
+++ b/src/core/io/toml_file.cpp
@@ -1,5 +1,5 @@
-#include "toml_file.hpp"
-#include "core/utils.hpp"
+#include "core/io/toml_file.hpp"
+#include "core/common/utils.hpp"
 #include <filesystem>
 #include <fstream>
 #include <vector>
@@ -8,15 +8,16 @@ namespace clrsync::core::io
 {
 toml_file::toml_file(std::string path)
 {
-    m_path = expand_user(path);
+    m_path = normalize_path(path).string();
 }

-bool toml_file::parse()
+Result<void> toml_file::parse()
 {
    if (!std::filesystem::exists(m_path))
-        return false;
+        return Err<void>(error_code::file_not_found, "File does not exist", m_path);
+
    m_file = toml::parse_file(m_path);
-    return true;
+    return Ok();
 }

 const std::string toml_file::get_string_value(const std::string &section,
@@ -63,7 +64,7 @@ std::map<std::string, value_type> toml_file::get_table(const std::string &sectio
        else if (auto d = val.value<double>())
            result[std::string(p.first.str())] = static_cast<uint32_t>(*d);
        else
-            result[std::string(p.first.str())] = {}; // fallback for unsupported types
+            result[std::string(p.first.str())] = {};
    }

    return result;
@@ -91,11 +92,45 @@ void toml_file::insert_or_update_value(const std::string &section, const std::st
    std::visit([&](auto &&v) { tbl->insert_or_assign(key, v); }, value);
 }

-void toml_file::save_file()
+void toml_file::remove_section(const std::string &section)
 {
+    toml::table *tbl = m_file.as_table();
+    auto parts = split(section, '.');
+
+    if (parts.empty())
+        return;
+
+    for (size_t i = 0; i < parts.size() - 1; ++i)
+    {
+        auto *sub = (*tbl)[parts[i]].as_table();
+        if (!sub)
+            return;
+        tbl = sub;
+    }
+
+    tbl->erase(parts.back());
+}
+
+Result<void> toml_file::save_file()
+{
+    try
+    {
        std::filesystem::create_directories(std::filesystem::path(m_path).parent_path());
+    }
+    catch (const std::exception &e)
+    {
+        return Err<void>(error_code::dir_create_failed, e.what(), m_path);
+    }
+
    std::ofstream stream(m_path, std::ios::binary);
+    if (!stream)
+        return Err<void>(error_code::file_write_failed, "Failed to open file for writing", m_path);
+
    stream << m_file;
+    if (!stream)
+        return Err<void>(error_code::file_write_failed, "Failed to write to file", m_path);
+
+    return Ok();
 }

 std::vector<std::string> toml_file::split(const std::string &s, char delim) const
--- a/src/core/io/toml_file.hpp
+++ b/src/core/io/toml_file.hpp
@@ -1,6 +1,7 @@
 #ifndef CLRSYNC_CORE_IO_TOML_FILE_HPP
 #define CLRSYNC_CORE_IO_TOML_FILE_HPP
-#include <core/io/file.hpp>
+#include "core/common/error.hpp"
+#include "core/io/file.hpp"
 #include <string>
 #include <toml/toml.hpp>

@@ -10,7 +11,7 @@ class toml_file : public file
 {
  public:
    explicit toml_file(std::string path);
-    bool parse() override;
+    Result<void> parse() override;
    const std::string get_string_value(const std::string &section,
                                       const std::string &key) const override;
    uint32_t get_uint_value(const std::string &section, const std::string &key) const override;
@@ -18,7 +19,8 @@ class toml_file : public file
    std::map<std::string, value_type> get_table(const std::string &section_path) const override;
    void insert_or_update_value(const std::string &section, const std::string &key,
                                const value_type &value) override;
-    void save_file() override;
+    void remove_section(const std::string &section) override;
+    Result<void> save_file() override;

  private:
    toml::parse_result m_file{};
--- a/src/core/palette/color.cpp
+++ b/src/core/palette/color.cpp
@@ -3,7 +3,6 @@
 #include <cstdio>
 #include <format>
 #include <stdexcept>
-#include <unordered_map>

 namespace clrsync::core
 {
@@ -112,14 +111,17 @@ void color::from_hex_string(const std::string &str)
    if (str.empty() || str[0] != '#')
        throw std::invalid_argument("Invalid hex color format");

-    if (str.size() == 7) {
+    if (str.size() == 7)
+    {
        uint32_t rgb = static_cast<uint32_t>(std::stoul(str.substr(1), nullptr, 16));
        m_hex = (rgb << 8) | 0xFF;
    }
-    else if (str.size() == 9) {
+    else if (str.size() == 9)
+    {
        m_hex = static_cast<uint32_t>(std::stoul(str.substr(1), nullptr, 16));
    }
-    else {
+    else
+    {
        throw std::invalid_argument("Invalid hex color format");
    }
 }
@@ -138,30 +140,38 @@ const std::string color::to_hex_string_with_alpha() const
    return std::string(buffer);
 }

-std::string color::format(const std::string& field) const
+std::string color::format(const std::string &field) const
 {
    auto rgb = to_rgb();
    auto rgba = to_rgba();
    auto hslv = to_hsl();
    auto hslav = to_hsla();

-    if (field == "hex") return to_hex_string();
-    if (field == "hex_stripped") {
+    if (field == "hex")
+        return to_hex_string();
+    if (field == "hex_stripped")
+    {
        auto s = to_hex_string();
        return s.substr(1);
    }

-    if (field == "hexa") return to_hex_string_with_alpha();
-    if (field == "hexa_stripped") {
+    if (field == "hexa")
+        return to_hex_string_with_alpha();
+    if (field == "hexa_stripped")
+    {
        auto s = to_hex_string_with_alpha();
        return s.substr(1);
    }

-    if (field == "r") return std::to_string(rgb.r);
-    if (field == "g") return std::to_string(rgb.g);
-    if (field == "b") return std::to_string(rgb.b);
+    if (field == "r")
+        return std::to_string(rgb.r);
+    if (field == "g")
+        return std::to_string(rgb.g);
+    if (field == "b")
+        return std::to_string(rgb.b);

-    if (field == "a") {
+    if (field == "a")
+    {
        float af = rgba.a / 255.0f;
        return std::format("{:.2f}", af);
    }
@@ -170,9 +180,7 @@ std::string color::format(const std::string& field) const
        return std::format("rgb({},{},{})", rgb.r, rgb.g, rgb.b);

    if (field == "rgba")
-        return std::format("rgba({},{},{},{:.2f})",
-                           rgba.r, rgba.g, rgba.b,
-                           rgba.a / 255.0f);
+        return std::format("rgba({},{},{},{:.2f})", rgba.r, rgba.g, rgba.b, rgba.a / 255.0f);

    if (field == "h")
        return std::format("{:.0f}", hslv.h);
@@ -186,12 +194,10 @@ std::string color::format(const std::string& field) const
        return std::format("{:.2f}", hslav.a);

    if (field == "hsl")
-        return std::format("hsl({:.0f},{:.2f},{:.2f})",
-                           hslv.h, hslv.s, hslv.l);
+        return std::format("hsl({:.0f},{:.2f},{:.2f})", hslv.h, hslv.s, hslv.l);

    if (field == "hsla")
-        return std::format("hsla({:.0f},{:.2f},{:.2f},{:.2f})",
-                           hslav.h, hslav.s, hslav.l, hslav.a);
+        return std::format("hsla({:.0f},{:.2f},{:.2f},{:.2f})", hslav.h, hslav.s, hslav.l, hslav.a);

    throw std::runtime_error("Unknown color format: " + field);
 }
--- a/src/core/palette/color.hpp
+++ b/src/core/palette/color.hpp
@@ -60,7 +60,7 @@ class color

    const std::string to_hex_string_with_alpha() const;

-    std::string format(const std::string& field) const;
+    std::string format(const std::string &field) const;

    void set(uint32_t hex);

--- a/src/core/palette/color_keys.hpp
+++ b/src/core/palette/color_keys.hpp
@@ -1,11 +1,14 @@
 #ifndef CLRSYNC_CORE_PALETTE_COLOR_KEYS_HPP
 #define CLRSYNC_CORE_PALETTE_COLOR_KEYS_HPP
 #include <cstddef>
+#include <cstdint>
 #include <iterator>
+#include <string>
+#include <unordered_map>

 namespace clrsync::core
 {
-constexpr const char* COLOR_KEYS[] = {
+constexpr const char *COLOR_KEYS[] = {
    // General UI
    "background",
    "on_background",
@@ -72,5 +75,67 @@ constexpr const char* COLOR_KEYS[] = {
 };

 constexpr size_t NUM_COLOR_KEYS = std::size(COLOR_KEYS);
+
+inline const std::unordered_map<std::string, uint32_t> DEFAULT_COLORS = {
+    {"background", 0x111111ff},
+    {"on_background", 0xd4d4d4ff},
+
+    {"surface", 0x111111ff},
+    {"on_surface", 0xd4d4d4ff},
+
+    {"surface_variant", 0x191919ff},
+    {"on_surface_variant", 0xd4d4d4ff},
+
+    {"border_focused", 0x2e2e2eff},
+    {"border", 0x242424ff},
+
+    {"foreground", 0xd2d2d2ff},
+
+    {"cursor", 0xd2d2d2ff},
+    {"accent", 0x9a8652ff},
+
+    {"success", 0x668a51ff},
+    {"info", 0x3a898cff},
+    {"warning", 0xb47837ff},
+    {"error", 0xaa4e4aff},
+
+    {"on_success", 0xd2d2d2ff},
+    {"on_info", 0xd2d2d2ff},
+    {"on_warning", 0xd2d2d2ff},
+    {"on_error", 0xd2d2d2ff},
+
+    {"editor_background", 0x111111ff},
+    {"editor_command", 0x3a898cff},
+    {"editor_comment", 0x849899ff},
+    {"editor_disabled", 0x849899ff},
+    {"editor_emphasis", 0xa9dc86ff},
+    {"editor_error", 0xaa4e4aff},
+    {"editor_inactive", 0x849899ff},
+    {"editor_line_number", 0x849899ff},
+    {"editor_link", 0xb0779eff},
+    {"editor_main", 0xd2d2d2ff},
+    {"editor_selected", 0x242424ff},
+    {"editor_selection_inactive", 0x1d1c1cff},
+    {"editor_string", 0x9a8652ff},
+    {"editor_success", 0x668a51ff},
+    {"editor_warning", 0xb47837ff},
+
+    {"base00", 0x111111ff},
+    {"base01", 0x668a51ff},
+    {"base02", 0x9a8652ff},
+    {"base03", 0xb47837ff},
+    {"base04", 0x9a5552ff},
+    {"base05", 0xaa477bff},
+    {"base06", 0x3a898cff},
+    {"base07", 0xb5b5b5ff},
+    {"base08", 0xaa4e4aff},
+    {"base09", 0xa9dc86ff},
+    {"base0A", 0xb6ab82ff},
+    {"base0B", 0xc5916bff},
+    {"base0C", 0xac7676ff},
+    {"base0D", 0xb0779eff},
+    {"base0E", 0x849899ff},
+    {"base0F", 0xd2d2d2ff},
+};
 } // namespace clrsync::core
 #endif
--- a/src/core/palette/palette.hpp
+++ b/src/core/palette/palette.hpp
@@ -4,7 +4,8 @@
 #include <string>
 #include <unordered_map>

-#include <core/palette/color.hpp>
+#include "core/palette/color.hpp"
+#include "core/palette/color_keys.hpp"

 namespace clrsync::core
 {
@@ -37,9 +38,16 @@ class palette
        {
            return it->second;
        }
-        static color default_color{};
+        auto default_it = DEFAULT_COLORS.find(key);
+        if (default_it != DEFAULT_COLORS.end())
+        {
+            static color default_color;
+            default_color.set(default_it->second);
            return default_color;
        }
+        static color empty_color{};
+        return empty_color;
+    }

    const std::unordered_map<std::string, color> &colors() const
    {
--- a/src/core/palette/palette_file.hpp
+++ b/src/core/palette/palette_file.hpp
@@ -5,9 +5,9 @@
 #include <cstdint>
 #include <string>

-#include <core/io/file.hpp>
-#include <core/palette/color_keys.hpp>
-#include <core/palette/palette.hpp>
+#include "core/io/file.hpp"
+#include "core/palette/color_keys.hpp"
+#include "core/palette/palette.hpp"

 #include <memory>

@@ -26,14 +26,26 @@ template <typename FileType> class palette_file
        if (!m_file->parse())
            return false;
        m_palette.set_name(m_file->get_string_value("general", "name"));
+
+        for (const auto &color_key : COLOR_KEYS)
+        {
+            auto it = DEFAULT_COLORS.find(color_key);
+            if (it != DEFAULT_COLORS.end())
+            {
+                m_palette.set_color(color_key, core::color(it->second));
+            }
+        }
+
        for (const auto &color_key : COLOR_KEYS)
        {
            auto color_str = m_file->get_string_value("colors", color_key);
-            core::color color{0x000000FF};
            if (!color_str.empty())
+            {
+                core::color color;
                color.from_hex_string(color_str);
                m_palette.set_color(color_key, color);
            }
+        }
        return true;
    }
    core::palette palette() const
@@ -52,7 +64,7 @@ template <typename FileType> class palette_file
    }
    void save()
    {
-        m_file->save_file();
+        (void)m_file->save_file();
    }

  private:
--- a/src/core/palette/palette_manager.hpp
+++ b/src/core/palette/palette_manager.hpp
@@ -1,14 +1,13 @@
 #ifndef CLRSYNC_CORE_PALETTE_PALETTE_MANAGER_HPP
 #define CLRSYNC_CORE_PALETTE_PALETTE_MANAGER_HPP

-#include "core/utils.hpp"
-#include <iostream>
+#include "core/common/utils.hpp"
 #include <string>
 #include <unordered_map>

-#include <core/config/config.hpp>
-#include <core/palette/palette.hpp>
-#include <core/palette/palette_file.hpp>
+#include "core/config/config.hpp"
+#include "core/palette/palette.hpp"
+#include "core/palette/palette_file.hpp"
 #include <filesystem>

 namespace clrsync::core
@@ -19,12 +18,9 @@ template <typename FileType> class palette_manager
    palette_manager() = default;
    void load_palettes_from_directory(const std::string &directory_path)
    {
-        auto directory_path_expanded = expand_user(directory_path);
+        std::filesystem::path directory_path_expanded = normalize_path(directory_path);
        if (!std::filesystem::exists(directory_path_expanded))
-        {
-            std::cerr << "Palettes directory does not exist\n" ;
            return;
-        }
        for (const auto &entry : std::filesystem::directory_iterator(directory_path_expanded))
        {
            if (entry.is_regular_file())
@@ -37,8 +33,9 @@ template <typename FileType> class palette_manager
    }
    void save_palette_to_file(const palette &pal, const std::string &directory_path) const
    {
-        std::string file_path = directory_path + "/" + pal.name() + ".toml";
-        palette_file<FileType> pal_file(file_path);
+        std::filesystem::path dir_path = normalize_path(directory_path);
+        std::filesystem::path file_path = dir_path / (pal.name() + ".toml");
+        palette_file<FileType> pal_file(file_path.string());
        pal_file.save_palette(pal);
    }

--- a/src/core/theme/template_manager.hpp
+++ b/src/core/theme/template_manager.hpp
@@ -1,17 +1,15 @@
 #ifndef CLRSYNC_CORE_THEME_TEMPLATE_MANAGER_HPP
 #define CLRSYNC_CORE_THEME_TEMPLATE_MANAGER_HPP

-#include <core/config/config.hpp>
-#include <core/theme/theme_template.hpp>
+#include "core/config/config.hpp"
+#include "core/theme/theme_template.hpp"
 #include <string>
 #include <unordered_map>

-
 namespace clrsync::core
 {

-template <typename FileType>
-class template_manager
+template <typename FileType> class template_manager
 {
  public:
    template_manager() = default;
--- a/src/core/theme/theme_renderer.hpp
+++ b/src/core/theme/theme_renderer.hpp
@@ -1,8 +1,10 @@
 #ifndef CLRSYNC_CORE_THEME_THEME_RENDERER_HPP
 #define CLRSYNC_CORE_THEME_THEME_RENDERER_HPP
-#include <core/config/config.hpp>
-#include <core/palette/palette_manager.hpp>
-#include <core/theme/template_manager.hpp>
+#include "core/common/error.hpp"
+#include "core/config/config.hpp"
+#include "core/palette/palette_manager.hpp"
+#include "core/theme/template_manager.hpp"
+#include <iostream>
 #include <string>

 namespace clrsync::core
@@ -18,39 +20,54 @@ template <typename FileType> class theme_renderer
        m_template_manager = template_manager<FileType>();
    }

-    void apply_theme(const std::string &theme_name)
+    Result<void> apply_theme(const std::string &theme_name)
    {
        auto palette = m_pal_manager.get_palette(theme_name);
        if (!palette)
-            throw std::runtime_error("Palette not found: " + theme_name);
-        apply_palette_to_all_templates(*palette);
+            return Err<void>(error_code::palette_not_found, "Palette not found", theme_name);
+        return apply_palette_to_all_templates(*palette);
    }
-    void apply_theme_from_path(const std::string &path)
+
+    Result<void> apply_theme_from_path(const std::string &path)
    {
        auto palette = m_pal_manager.load_palette_from_file(path);
-        apply_palette_to_all_templates(palette);
+        return apply_palette_to_all_templates(palette);
    }

  private:
    palette_manager<FileType> m_pal_manager;
    template_manager<FileType> m_template_manager;

-    void apply_palette_to_all_templates(const palette &pal)
+    Result<void> apply_palette_to_all_templates(const palette &pal)
    {
        for (auto &t_pair : m_template_manager.templates())
        {
            auto &tmpl = t_pair.second;
            if (!tmpl.enabled())
                continue;
-            tmpl.load_template();
+
+            auto load_result = tmpl.load_template();
+            if (!load_result)
+                return load_result;
+
            tmpl.apply_palette(pal);
-            tmpl.save_output();
+
+            auto save_result = tmpl.save_output();
+            if (!save_result)
+                return save_result;
+
            if (!tmpl.reload_command().empty())
            {
-                std::system(tmpl.reload_command().c_str());
+                int result = std::system(tmpl.reload_command().c_str());
+                if (result != 0)
+                {
+                    std::cerr << "Warning: Command " << tmpl.reload_command()
+                              << " failed with code " << result << "\n";
                }
            }
        }
+        return Ok();
+    }
 };

 } // namespace clrsync::core
--- a/src/core/theme/theme_template.cpp
+++ b/src/core/theme/theme_template.cpp
@@ -1,5 +1,5 @@
 #include "theme_template.hpp"
-#include "core/utils.hpp"
+#include "core/common/utils.hpp"
 #include <filesystem>
 #include <fstream>
 #include <iostream>
@@ -8,8 +8,8 @@ namespace clrsync::core
 {
 theme_template::theme_template(const std::string &name, const std::string &template_path,
                               const std::string &out_path)
-    : m_name(name), m_template_path(expand_user(template_path)),
-      m_output_path(expand_user(out_path))
+    : m_name(name), m_template_path(normalize_path(template_path).string()),
+      m_output_path(normalize_path(out_path).string())
 {
 }

@@ -30,7 +30,7 @@ const std::string &theme_template::template_path() const

 void theme_template::set_template_path(const std::string &path)
 {
-    m_template_path = expand_user(path);
+    m_template_path = normalize_path(path).string();
 }

 const std::string &theme_template::output_path() const
@@ -40,28 +40,33 @@ const std::string &theme_template::output_path() const

 void theme_template::set_output_path(const std::string &path)
 {
-    m_output_path = expand_user(path);
+    m_output_path = normalize_path(path).string();
 }

-void theme_template::load_template()
+Result<void> theme_template::load_template()
 {
    if (!std::filesystem::exists(m_template_path))
    {
-        std::cerr << "Template file '" << m_template_path << "' is missing\n";
-        return;
+        return Err<void>(error_code::template_not_found, "Template file is missing",
+                         m_template_path);
    }
+
    std::ifstream input(m_template_path, std::ios::binary);
    if (!input)
-        throw std::runtime_error("Failed to open template file: " + m_template_path);
+    {
+        return Err<void>(error_code::template_load_failed, "Failed to open template file",
+                         m_template_path);
+    }

    m_template_data.assign(std::istreambuf_iterator<char>(input), std::istreambuf_iterator<char>());
+    return Ok();
 }

 void theme_template::apply_palette(const core::palette &palette)
 {
    m_processed_data = m_template_data;

-    for (const auto& [key, color] : palette.colors())
+    for (const auto &[key, color] : palette.colors())
    {
        // simple replacement: {foreground}
        replace_all(m_processed_data, "{" + key + "}", color.format("hex"));
@@ -87,14 +92,32 @@ void theme_template::apply_palette(const core::palette &palette)
    }
 }

-void theme_template::save_output() const
+Result<void> theme_template::save_output() const
 {
+    try
+    {
        std::filesystem::create_directories(std::filesystem::path(m_output_path).parent_path());
+    }
+    catch (const std::exception &e)
+    {
+        return Err<void>(error_code::dir_create_failed, e.what(), m_output_path);
+    }
+
    std::ofstream output(m_output_path, std::ios::binary);
    if (!output)
-        throw std::runtime_error("Failed to write output file: " + m_output_path);
+    {
+        return Err<void>(error_code::file_write_failed, "Failed to open output file for writing",
+                         m_output_path);
+    }

    output << m_processed_data;
+    if (!output)
+    {
+        return Err<void>(error_code::file_write_failed, "Failed to write to output file",
+                         m_output_path);
+    }
+
+    return Ok();
 }

 const std::string &theme_template::raw_template() const
--- a/src/core/theme/theme_template.hpp
+++ b/src/core/theme/theme_template.hpp
@@ -1,7 +1,8 @@
 #ifndef clrsync_CORE_IO_THEME_TEMPLATE_HPP
 #define clrsync_CORE_IO_THEME_TEMPLATE_HPP

-#include <core/palette/palette.hpp>
+#include "core/common/error.hpp"
+#include "core/palette/palette.hpp"
 #include <string>

 namespace clrsync::core
@@ -26,11 +27,11 @@ class theme_template

    void set_output_path(const std::string &path);

-    void load_template();
+    Result<void> load_template();

    void apply_palette(const core::palette &palette);

-    void save_output() const;
+    Result<void> save_output() const;

    const std::string &raw_template() const;

--- a/src/core/utils.cpp
+++ b/src/core/utils.cpp
@@ -1,41 +0,0 @@
-#include "utils.hpp"
-#include <iostream>
-
-namespace clrsync::core
-{
-void print_color_keys()
-{
-    for (const auto &key : clrsync::core::COLOR_KEYS)
-    {
-        std::cout << key << std::endl;
-    }
-}
-
-std::string get_default_config_path()
-{
-    auto home = expand_user("~");
-#ifdef _WIN32
-    return home + "\\.config\\clrsync\\config.toml";
-
-#else
-    return home + "/.config/clrsync/config.toml";
-#endif
-}
-
-std::string expand_user(const std::string &path)
-{
-    if (!path.empty() && path[0] == '~')
-    {
-#ifdef _WIN32
-        const char *home = std::getenv("USERPROFILE");
-#else
-        const char *home = std::getenv("HOME");
-#endif
-        if (!home)
-            return path;
-        return std::string(home) + path.substr(1);
-    }
-    return path;
-}
-
-} // namespace clrsync::core
--- a/src/core/version.cpp
+++ b/src/core/version.cpp
@@ -1,10 +0,0 @@
-#include "version.hpp"
-
-namespace clrsync::core
-{
-const std::string version_string()
-{
-    return "v" + std::to_string(VERSION_MAJOR) + "." + std::to_string(VERSION_MINOR) + "." +
-           std::to_string(VERSION_PATCH);
-}
-} // namespace clrsync::core
--- a/src/gui/CMakeLists.txt
+++ b/src/gui/CMakeLists.txt
@@ -1,18 +1,40 @@
 set(GUI_SOURCES
    main.cpp
-    color_scheme_editor.cpp
-    template_editor.cpp
-    palette_controller.cpp
-    template_controller.cpp
-    imgui_helpers.cpp
-    imgui_helpers.hpp
-    about_window.cpp
-    settings_window.cpp
-    font_loader.cpp
+        views/color_scheme_editor.cpp
+        views/color_table_renderer.cpp
+        views/preview_renderer.cpp
+        controllers/theme_applier.cpp
+        views/template_editor.cpp
+        controllers/palette_controller.cpp
+        controllers/template_controller.cpp
+        helpers/imgui_helpers.cpp
+        helpers/imgui_helpers.hpp
+        views/about_window.cpp
+        views/settings_window.cpp
+        platform/windows/font_loader_windows.cpp
+        platform/linux/font_loader_linux.cpp
+        platform/macos/font_loader_macos.cpp
+        platform/linux/file_browser_linux.cpp
+        platform/windows/file_browser_windows.cpp
        ${CMAKE_SOURCE_DIR}/lib/color_text_edit/TextEditor.cpp
+        platform/linux/font_loader_linux.cpp
+        platform/macos/font_loader_macos.cpp
+        platform/windows/font_loader_windows.cpp
+        backend/glfw_opengl.cpp
+        ui_manager.cpp
 )

-add_executable(clrsync_gui ${GUI_SOURCES})
+if(MACOS)
+    list(APPEND GUI_SOURCES
+        platform/macos/file_browser_macos.mm
+    )
+endif()
+
+if(WIN32)
+    add_executable(clrsync_gui WIN32 ${GUI_SOURCES})
+else()
+    add_executable(clrsync_gui ${GUI_SOURCES})
+endif()

 target_include_directories(clrsync_gui PRIVATE 
    ${CMAKE_SOURCE_DIR}/src 
@@ -25,6 +47,22 @@ if(WIN32)
        glfw 
        imgui 
        OpenGL::GL
+        shell32
+        ole32
+        uuid
+        comdlg32
+        shlwapi
+    )
+    if (MSVC)
+        target_link_options(clrsync_gui PRIVATE /ENTRY:mainCRTStartup)
+    endif()
+elseif(APPLE)
+    target_link_libraries(clrsync_gui PRIVATE
+        clrsync_core
+        glfw
+        imgui
+        OpenGL::GL
+        "-framework Cocoa"
    )
 else() 
    target_link_libraries(clrsync_gui PRIVATE
@@ -37,5 +75,9 @@ else()
        Xi 
        Fontconfig::Fontconfig 
        OpenGL::GL
+        ${GTK3_LIBRARIES}
    )
+    
+    target_include_directories(clrsync_gui PRIVATE ${GTK3_INCLUDE_DIRS})
+    target_compile_options(clrsync_gui PRIVATE ${GTK3_CFLAGS_OTHER})
 endif()
--- a/src/gui/about_window.hpp
+++ b/src/gui/about_window.hpp
@@ -1,17 +0,0 @@
-#ifndef CLRSYNC_GUI_ABOUT_WINDOW_HPP
-#define CLRSYNC_GUI_ABOUT_WINDOW_HPP
-
-class about_window
-{
-public:
-    about_window();
-    void render();
-    void show() { m_visible = true; }
-    void hide() { m_visible = false; }
-    bool is_visible() const { return m_visible; }
-
-private:
-    bool m_visible{false};
-};
-
-#endif // CLRSYNC_GUI_ABOUT_WINDOW_HPP
--- a/src/gui/backend/backend.hpp
+++ b/src/gui/backend/backend.hpp
@@ -0,0 +1,38 @@
+#ifndef CLRSYNC_BACKEND_HPP
+#define CLRSYNC_BACKEND_HPP
+
+#include <string>
+
+namespace clrsync::gui::backend{
+
+    struct window_config{
+        std::string title = "clrsync";
+        int width = 1280;
+        int height = 720;
+        bool resizable = true;
+        bool decorated = true;
+        bool transparent_framebuffer = true;
+        float clear_color[4] = {0.1f, 0.1f, 0.1f, 0.0f};
+    };
+    class backend_interface{
+    public:
+        virtual ~backend_interface() = default;
+
+        virtual bool initialize(const window_config& config) = 0;
+        virtual void shutdown() = 0;
+        virtual bool should_close() const = 0;
+        virtual void begin_frame() = 0;
+        virtual void end_frame() = 0;
+
+        virtual void* get_native_window() const = 0;
+        virtual void* get_graphics_context() const = 0;
+        
+        virtual bool init_imgui_backend() = 0;
+        virtual void shutdown_imgui_backend() = 0;
+        virtual void imgui_new_frame() = 0;
+        virtual void imgui_render_draw_data(void* draw_data) = 0;
+    };
+
+}
+
+#endif // CLRSYNC_BACKEND_HPP
--- a/src/gui/backend/glfw_opengl.cpp
+++ b/src/gui/backend/glfw_opengl.cpp
@@ -0,0 +1,141 @@
+#include "gui/backend/glfw_opengl.hpp"
+#include <iostream>
+#include <GLFW/glfw3.h>
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+
+namespace clrsync::gui::backend
+{
+
+glfw_opengl_backend::glfw_opengl_backend() = default;
+
+glfw_opengl_backend::~glfw_opengl_backend()
+{
+    glfw_opengl_backend::shutdown();
+}
+
+bool glfw_opengl_backend::initialize(const window_config &config)
+{
+    glfwSetErrorCallback([](int error, const char* description) {
+        std::cerr << "GLFW Error " << error << ": " << description << std::endl;
+    });
+    
+    if (!glfwInit())
+    {
+        std::cerr << "Failed to initialize GLFW" << std::endl;
+        return false;
+    }
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+#else
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+#endif
+    glfwWindowHint(GLFW_RESIZABLE, config.resizable ? GLFW_TRUE : GLFW_FALSE);
+    glfwWindowHint(GLFW_DECORATED, config.decorated ? GLFW_TRUE : GLFW_FALSE);
+    glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, config.transparent_framebuffer ? GLFW_TRUE : GLFW_FALSE);
+
+    m_window = glfwCreateWindow(config.width, config.height, config.title.c_str(), nullptr, nullptr);
+    if (!m_window)
+    {
+        std::cerr << "Failed to create GLFW window" << std::endl;
+        glfwTerminate();
+        return false;
+    }
+
+    glfwMakeContextCurrent(m_window);
+    glfwSwapInterval(1);
+
+    return true;
+}
+
+void glfw_opengl_backend::shutdown()
+{
+    if (m_window)
+    {
+        glfwDestroyWindow(m_window);
+        m_window = nullptr;
+    }
+    glfwTerminate();
+}
+
+bool glfw_opengl_backend::should_close() const
+{
+    return m_window && glfwWindowShouldClose(m_window);
+}
+
+void glfw_opengl_backend::begin_frame()
+{
+    glfwPollEvents();
+    
+    if (m_window)
+    {
+        int display_w, display_h;
+        glfwGetFramebufferSize(m_window, &display_w, &display_h);
+        glViewport(0, 0, display_w, display_h);
+        glClearColor(0.1f, 0.1f, 0.1f, 0.0f);
+        glClear(GL_COLOR_BUFFER_BIT);
+    }
+}
+
+void glfw_opengl_backend::end_frame()
+{
+    if (m_window)
+    {
+        glfwSwapBuffers(m_window);
+    }
+}
+
+void *glfw_opengl_backend::get_native_window() const
+{
+    return static_cast<void *>(m_window);
+}
+
+void *glfw_opengl_backend::get_graphics_context() const
+{
+    return static_cast<void *>(m_window);
+}
+
+bool glfw_opengl_backend::init_imgui_backend()
+{
+    if (!m_window)
+        return false;
+    
+    if (!ImGui_ImplGlfw_InitForOpenGL(m_window, true))
+        return false;
+    
+#ifdef __APPLE__
+    const char* glsl_version = "#version 150";
+#else
+    const char* glsl_version = "#version 120";
+#endif
+    
+    if (!ImGui_ImplOpenGL3_Init(glsl_version))
+    {
+        ImGui_ImplGlfw_Shutdown();
+        return false;
+    }
+    
+    return true;
+}
+
+void glfw_opengl_backend::shutdown_imgui_backend()
+{
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+}
+
+void glfw_opengl_backend::imgui_new_frame()
+{
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+}
+
+void glfw_opengl_backend::imgui_render_draw_data(void* draw_data)
+{
+    ImGui_ImplOpenGL3_RenderDrawData(static_cast<ImDrawData*>(draw_data));
+}
+
+} // namespace clrsync::gui::backend
--- a/src/gui/backend/glfw_opengl.hpp
+++ b/src/gui/backend/glfw_opengl.hpp
@@ -0,0 +1,36 @@
+#ifndef CLRSYNC_GLFW_OPENGL_HPP
+#define CLRSYNC_GLFW_OPENGL_HPP
+
+#define GL_SILENCE_DEPRECATION
+
+#include <GLFW/glfw3.h>
+
+#include "gui/backend/backend.hpp"
+
+namespace clrsync::gui::backend{
+
+    class glfw_opengl_backend : public backend_interface{
+    public:
+        glfw_opengl_backend();
+        ~glfw_opengl_backend();
+
+        bool initialize(const window_config& config) override;
+        void shutdown() override;
+        bool should_close() const override;
+        void begin_frame() override;
+        void end_frame() override;
+
+        void* get_native_window() const override;
+        void* get_graphics_context() const override;
+        
+        bool init_imgui_backend() override;
+        void shutdown_imgui_backend() override;
+        void imgui_new_frame() override;
+        void imgui_render_draw_data(void* draw_data) override;
+
+    private:
+        GLFWwindow* m_window = nullptr;
+    };
+}
+
+#endif // CLRSYNC_GLFW_OPENGL_HPP
--- a/src/gui/color_scheme_editor.cpp
+++ b/src/gui/color_scheme_editor.cpp
@@ -1,555 +0,0 @@
-#include "color_scheme_editor.hpp"
-#include "template_editor.hpp"
-#include "color_text_edit/TextEditor.h"
-#include "imgui.h"
-#include <iostream>
-#include <ranges>
-
-color_scheme_editor::color_scheme_editor()
-{
-    m_editor.SetLanguageDefinition(TextEditor::LanguageDefinition::CPlusPlus());
-    m_editor.SetText(R"(#include <iostream>
-#include <string>
-#include <vector>
-#include <filesystem>
-#include <cstdlib>
-
-namespace fs = std::filesystem;
-
-// Expands ~ to the user's home directory
-std::string expand_user(const std::string &path)
-{
-    if (path.empty()) return "";
-
-    std::string result;
-    if (path[0] == '~')
-    {
-#ifdef _WIN32
-        const char* home = std::getenv("USERPROFILE");
-#else
-        const char* home = std::getenv("HOME");
-#endif
-        result = home ? std::string(home) : "~";
-        result += path.substr(1);
-    }
-    else
-    {
-        result = path;
-    }
-
-    return result;
-}
-
-// Lists all files in a directory
-std::vector<std::string> list_files(const std::string &dir_path)
-{
-    std::vector<std::string> files;
-    try
-    {
-        for (const auto &entry : fs::directory_iterator(dir_path))
-        {
-            if (entry.is_regular_file())
-                files.push_back(entry.path().string());
-        }
-    }
-    catch (const std::exception &e)
-    {
-        std::cerr << "Error: " << e.what() << std::endl;
-    }
-    return files;
-}
-
-int main()
-{
-    std::string path = expand_user("~/Documents");
-    std::cout << "Listing files in: " << path << std::endl;
-
-    auto files = list_files(path);
-    for (const auto &f : files)
-        std::cout << "  " << f << std::endl;
-
-    return 0;
-})");
-
-    m_editor.SetShowWhitespaces(false);
-    
-    const auto &palettes = m_controller.palettes();
-    
-    const auto &current = m_controller.current_palette();
-    
-    if (!current.colors().empty())
-    {
-        apply_palette_to_imgui();
-        apply_palette_to_editor();
-    }
-    else
-    {
-        std::cout << "WARNING: No palette loaded, skipping theme application\n";
-    }
-}
-
-void color_scheme_editor::notify_palette_changed()
-{
-    if (m_template_editor)
-    {
-        m_template_editor->apply_current_palette(m_controller.current_palette());
-    }
-}
-
-void color_scheme_editor::render_controls_and_colors()
-{
-    ImGui::Begin("Color Schemes");
-
-    render_controls();
-    ImGui::Separator();
-
-    ImGui::BeginChild("ColorTableContent", ImVec2(0, 0), false);
-    render_color_table();
-    ImGui::EndChild();
-
-    ImGui::End();
-}
-
-void color_scheme_editor::render_preview()
-{
-    ImGui::Begin("Color Preview");
-    
-    render_preview_content();
-    
-    ImGui::End();
-}
-
-void color_scheme_editor::render_controls()
-{
-    const auto &current = m_controller.current_palette();
-    const auto &palettes = m_controller.palettes();
-
-    const float avail_width = ImGui::GetContentRegionAvail().x;
-
-    ImGui::Text("Color Scheme:");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(std::min(200.0f, avail_width * 0.3f));
-    if (ImGui::BeginCombo("##scheme", current.name().c_str()))
-    {
-        for (const auto &name : palettes | std::views::keys)
-        {
-            const bool selected = current.name() == name;
-            if (ImGui::Selectable(name.c_str(), selected))
-            {
-                m_controller.select_palette(name);
-                apply_palette_to_imgui();
-                apply_palette_to_editor();
-                notify_palette_changed();
-            }
-            if (selected)
-                ImGui::SetItemDefaultFocus();
-        }
-        ImGui::EndCombo();
-    }
-
-    ImGui::SameLine();
-
-    static char new_palette_name_buf[128] = "";
-    if (ImGui::Button("New"))
-    {
-        new_palette_name_buf[0] = 0;
-        ImGui::OpenPopup("New Palette");
-    }
-
-    if (ImGui::BeginPopupModal("New Palette", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
-    {
-        ImGui::Text("New palette name:");
-        ImGui::InputText("##new_palette_input", new_palette_name_buf,
-                         IM_ARRAYSIZE(new_palette_name_buf));
-
-        ImGui::Separator();
-
-        if (ImGui::Button("Create", ImVec2(120, 0)))
-        {
-            if (strlen(new_palette_name_buf) > 0)
-            {
-                m_controller.create_palette(new_palette_name_buf);
-                apply_palette_to_imgui();
-                apply_palette_to_editor();
-                notify_palette_changed();
-                m_controller.select_palette(new_palette_name_buf);
-                new_palette_name_buf[0] = 0;
-            }
-            ImGui::CloseCurrentPopup();
-        }
-
-        ImGui::SameLine();
-
-        if (ImGui::Button("Cancel", ImVec2(120, 0)))
-        {
-            new_palette_name_buf[0] = 0;
-            ImGui::CloseCurrentPopup();
-        }
-
-        ImGui::EndPopup();
-    }
-
-    ImGui::SameLine();
-    if (ImGui::Button("Save"))
-    {
-        m_controller.save_current_palette();
-    }
-
-    ImGui::SameLine();
-    if (ImGui::Button("Delete"))
-    {
-        m_controller.delete_current_palette();
-    }
-
-    ImGui::SameLine();
-    if (ImGui::Button("Apply"))
-    {
-        m_controller.apply_current_theme();
-    }
-}
-
-void color_scheme_editor::render_color_table()
-{
-    const auto &current = m_controller.current_palette();
-
-    if (current.colors().empty())
-    {
-        ImGui::Text("No palette loaded");
-        return;
-    }
-
-    ImGui::Text("Color Variables");
-    ImGui::Separator();
-
-    auto render_color_row = [&](const std::string &name) {
-        const auto &colors = current.colors();
-        auto it = colors.find(name);
-        if (it == colors.end())
-            return;
-
-        const clrsync::core::color &col = it->second;
-
-        ImGui::TableNextRow();
-
-        ImGui::TableSetColumnIndex(0);
-        ImGui::TextUnformatted(name.c_str());
-
-        ImGui::TableSetColumnIndex(1);
-        {
-            std::string hex_str = col.to_hex_string();
-            char buf[9];
-            strncpy(buf, hex_str.c_str(), sizeof(buf));
-            buf[8] = 0;
-
-            ImGui::SetNextItemWidth(-FLT_MIN);
-            if (ImGui::InputText(("##hex_" + name).c_str(), buf, sizeof(buf),
-                                 ImGuiInputTextFlags_CharsUppercase))
-            {
-                try
-                {
-                    clrsync::core::color new_color;
-                    new_color.from_hex_string(buf);
-                    m_controller.set_color(name, new_color);
-                    apply_palette_to_imgui();
-                    apply_palette_to_editor();
-                    notify_palette_changed();
-                }
-                catch (...)
-                {
-                }
-            }
-        }
-
-        ImGui::TableSetColumnIndex(2);
-        ImGui::PushID(name.c_str());
-        float c[4] = {((col.hex() >> 24) & 0xFF) / 255.0f, ((col.hex() >> 16) & 0xFF) / 255.0f,
-                      ((col.hex() >> 8) & 0xFF) / 255.0f, (col.hex() & 0xFF) / 255.0f};
-
-        ImGui::SetNextItemWidth(-FLT_MIN);
-        if (ImGui::ColorEdit4(("##color_" + name).c_str(), c,
-                              ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel |
-                                  ImGuiColorEditFlags_AlphaBar))
-        {
-            uint32_t r = (uint32_t)(c[0] * 255.0f);
-            uint32_t g = (uint32_t)(c[1] * 255.0f);
-            uint32_t b = (uint32_t)(c[2] * 255.0f);
-            uint32_t a = (uint32_t)(c[3] * 255.0f);
-            uint32_t hex = (r << 24) | (g << 16) | (b << 8) | a;
-
-            m_controller.set_color(name, clrsync::core::color(hex));
-            apply_palette_to_imgui();
-            apply_palette_to_editor();
-            notify_palette_changed();
-        }
-
-        ImGui::PopID();
-    };
-
-    auto draw_table = [&](const char *title, const std::vector<const char *> &keys) {
-        ImGui::TextUnformatted(title);
-
-        if (ImGui::BeginTable(title, 3, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg))
-        {
-            ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, 160.0f);
-            ImGui::TableSetupColumn("HEX", ImGuiTableColumnFlags_WidthFixed, 90.0f);
-            ImGui::TableSetupColumn("Preview", ImGuiTableColumnFlags_WidthStretch);
-            ImGui::TableHeadersRow();
-
-            for (auto *k : keys)
-                render_color_row(k);
-
-            ImGui::EndTable();
-        }
-
-        ImGui::Spacing();
-    };
-
-    draw_table("General UI", {"background", "on_background", "surface", "on_surface",
-                              "surface_variant", "on_surface_variant", "foreground",
-                              "cursor", "accent"});
-
-    draw_table("Borders", {"border_focused", "border"});
-
-    draw_table("Semantic Colors", {"success", "info", "warning", "error",
-                                   "on_success", "on_info", "on_warning", "on_error"});
-
-    draw_table("Editor", {"editor_background", "editor_command", "editor_comment",
-                          "editor_disabled", "editor_emphasis", "editor_error",
-                          "editor_inactive", "editor_line_number", "editor_link",
-                          "editor_main", "editor_selected", "editor_selection_inactive",
-                          "editor_string", "editor_success", "editor_warning"});
-
-    draw_table("Terminal (Base16)", {"base00", "base01", "base02", "base03",
-                                     "base04", "base05", "base06", "base07",
-                                     "base08", "base09", "base0A", "base0B",
-                                     "base0C", "base0D", "base0E", "base0F"});
-}
-
-void color_scheme_editor::render_preview_content()
-{
-    const auto &current = m_controller.current_palette();
-
-    if (current.colors().empty())
-    {
-        ImGui::TextColored(ImVec4(1.0f, 0.3f, 0.3f, 1.0f), "Current palette is empty");
-        return;
-    }
-
-    auto get_color = [&](const std::string &key) -> ImVec4 {
-        auto it = current.colors().find(key);
-        if (it != current.colors().end())
-        {
-            const auto &col = it->second;
-            const uint32_t hex = col.hex();
-            return {((hex >> 24) & 0xFF) / 255.0f, ((hex >> 16) & 0xFF) / 255.0f,
-                    ((hex >> 8) & 0xFF) / 255.0f, ((hex) & 0xFF) / 255.0f};
-        }
-        return {1, 1, 1, 1};
-    };
-
-    const ImVec4 editor_bg = get_color("editor_background");
-    const ImVec4 fg = get_color("foreground");
-    const ImVec4 accent = get_color("accent");
-    const ImVec4 border = get_color("border");
-    const ImVec4 error = get_color("error");
-    const ImVec4 warning = get_color("warning");
-    const ImVec4 success = get_color("success");
-    const ImVec4 info = get_color("info");
-
-    const float avail_height = ImGui::GetContentRegionAvail().y;
-    const float code_preview_height = std::max(250.0f, avail_height * 0.55f);
-
-    ImGui::Text("Code Editor:");
-
-    m_editor.Render("##CodeEditor", ImVec2(0, code_preview_height), true);
-
-    ImGui::Spacing();
-    ImGui::Text("Terminal Preview:");
-    
-    ImGui::PushStyleColor(ImGuiCol_ChildBg, editor_bg);
-    ImGui::BeginChild("TerminalPreview", ImVec2(0, 0), true);
-    ImGui::PushStyleColor(ImGuiCol_Border, border);
-
-    struct term_line
-    {
-        const char *text{};
-        ImVec4 col;
-    };
-    term_line term_lines[] = {
-        {"$ ls -la", fg},
-        {"drwxr-xr-x 5 user group 4096 Dec  2 10:30 .", accent},
-        {"Build successful", success},
-        {"Error: file not found", error},
-        {"Warning: low disk space", warning},
-        {"Info: update available", info},
-    };
-
-    for (auto &[text, col] : term_lines)
-    {
-        ImGui::TextColored(col, "%s", text);
-    }
-
-    ImGui::PopStyleColor(2);
-    ImGui::EndChild();
-}
-
-void color_scheme_editor::apply_palette_to_editor()
-{
-    const auto &current = m_controller.current_palette();
-    if (current.colors().empty())
-        return;
-
-    auto get_color_u32 = [&](const std::string &key, const std::string &fallback = "") -> uint32_t {
-        auto it = current.colors().find(key);
-        if (it == current.colors().end() && !fallback.empty())
-        {
-            it = current.colors().find(fallback);
-        }
-        
-        if (it != current.colors().end())
-        {
-            const auto &col = it->second;
-            const uint32_t hex = col.hex();
-            // Convert from RRGGBBAA to AABBGGRR (ImGui format)
-            const uint32_t r = (hex >> 24) & 0xFF;
-            const uint32_t g = (hex >> 16) & 0xFF;
-            const uint32_t b = (hex >> 8) & 0xFF;
-            const uint32_t a = hex & 0xFF;
-            return (a << 24) | (b << 16) | (g << 8) | r;
-        }
-        return 0xFFFFFFFF;
-    };
-
-    auto palette = m_editor.GetPalette();
-
-    palette[int(TextEditor::PaletteIndex::Default)] = get_color_u32("editor_main");
-    palette[int(TextEditor::PaletteIndex::Keyword)] = get_color_u32("editor_command");
-    palette[int(TextEditor::PaletteIndex::Number)] = get_color_u32("editor_warning");
-    palette[int(TextEditor::PaletteIndex::String)] = get_color_u32("editor_string");
-    palette[int(TextEditor::PaletteIndex::CharLiteral)] = get_color_u32("editor_string");
-    palette[int(TextEditor::PaletteIndex::Punctuation)] = get_color_u32("editor_main");
-    palette[int(TextEditor::PaletteIndex::Preprocessor)] = get_color_u32("editor_emphasis");
-    palette[int(TextEditor::PaletteIndex::Identifier)] = get_color_u32("editor_main");
-    palette[int(TextEditor::PaletteIndex::KnownIdentifier)] = get_color_u32("editor_link");
-    palette[int(TextEditor::PaletteIndex::PreprocIdentifier)] = get_color_u32("editor_link");
-
-    palette[int(TextEditor::PaletteIndex::Comment)] = get_color_u32("editor_comment");
-    palette[int(TextEditor::PaletteIndex::MultiLineComment)] = get_color_u32("editor_comment");
-
-    palette[int(TextEditor::PaletteIndex::Background)] = get_color_u32("editor_background");
-    palette[int(TextEditor::PaletteIndex::Cursor)] = get_color_u32("cursor");
-
-    palette[int(TextEditor::PaletteIndex::Selection)] = get_color_u32("editor_selected");
-    palette[int(TextEditor::PaletteIndex::ErrorMarker)] = get_color_u32("editor_error");
-    palette[int(TextEditor::PaletteIndex::Breakpoint)] = get_color_u32("editor_error");
-
-    palette[int(TextEditor::PaletteIndex::LineNumber)] = get_color_u32("editor_line_number");
-    palette[int(TextEditor::PaletteIndex::CurrentLineFill)] = get_color_u32("surface_variant");
-    palette[int(TextEditor::PaletteIndex::CurrentLineFillInactive)] = get_color_u32("surface");
-
-    palette[int(TextEditor::PaletteIndex::CurrentLineEdge)] = get_color_u32("border_focused");
-
-    m_editor.SetPalette(palette);
-}
-
-void color_scheme_editor::apply_palette_to_imgui() const
-{
-    const auto &current = m_controller.current_palette();
-
-    if (current.colors().empty())
-        return;
-    
-    auto getColor = [&](const std::string &key, const std::string &fallback = "") -> ImVec4 {
-        auto it = current.colors().find(key);
-        if (it == current.colors().end() && !fallback.empty())
-        {
-            it = current.colors().find(fallback);
-        }
-        
-        if (it != current.colors().end())
-        {
-            const uint32_t hex = it->second.hex();
-            return {((hex >> 24) & 0xFF) / 255.0f, ((hex >> 16) & 0xFF) / 255.0f,
-                    ((hex >> 8) & 0xFF) / 255.0f, ((hex) & 0xFF) / 255.0f};
-        }
-        
-        std::cout << "WARNING: Color key '" << key << "' not found!\n";
-        return {1, 1, 1, 1};
-    };
-
-    ImGuiStyle &style = ImGui::GetStyle();
-
-    const ImVec4 bg = getColor("background");
-    const ImVec4 surface = getColor("surface");
-    const ImVec4 surfaceVariant = getColor("surface_variant");
-    const ImVec4 fg = getColor("foreground");
-    const ImVec4 fgInactive = getColor("editor_inactive");
-    const ImVec4 accent = getColor("accent");
-    const ImVec4 border = getColor("border");
-
-    style.Colors[ImGuiCol_WindowBg] = bg;
-    style.Colors[ImGuiCol_ChildBg] = surface;
-    style.Colors[ImGuiCol_PopupBg] = surface;
-
-    style.Colors[ImGuiCol_Border] = border;
-    style.Colors[ImGuiCol_BorderShadow] = ImVec4(0, 0, 0, 0);
-
-    style.Colors[ImGuiCol_Text] = fg;
-    style.Colors[ImGuiCol_TextDisabled] = fgInactive;
-
-    style.Colors[ImGuiCol_Header] = surfaceVariant;
-    style.Colors[ImGuiCol_HeaderHovered] = ImVec4(accent.x, accent.y, accent.z, 0.8f);
-    style.Colors[ImGuiCol_HeaderActive] = accent;
-
-    style.Colors[ImGuiCol_Button] = surfaceVariant;
-    style.Colors[ImGuiCol_ButtonHovered] = ImVec4(accent.x, accent.y, accent.z, 0.6f);
-    style.Colors[ImGuiCol_ButtonActive] = accent;
-
-    style.Colors[ImGuiCol_FrameBg] = surfaceVariant;
-    style.Colors[ImGuiCol_FrameBgHovered] =
-        ImVec4(surfaceVariant.x * 1.1f, surfaceVariant.y * 1.1f, surfaceVariant.z * 1.1f, 1.0f);
-    style.Colors[ImGuiCol_FrameBgActive] =
-        ImVec4(surfaceVariant.x * 1.2f, surfaceVariant.y * 1.2f, surfaceVariant.z * 1.2f, 1.0f);
-
-    style.Colors[ImGuiCol_TitleBg] = surface;
-    style.Colors[ImGuiCol_TitleBgActive] = surfaceVariant;
-    style.Colors[ImGuiCol_TitleBgCollapsed] = surface;
-
-    style.Colors[ImGuiCol_ScrollbarBg] = surface;
-    style.Colors[ImGuiCol_ScrollbarGrab] = surfaceVariant;
-    style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(accent.x, accent.y, accent.z, 0.6f);
-    style.Colors[ImGuiCol_ScrollbarGrabActive] = accent;
-
-    style.Colors[ImGuiCol_SliderGrab] = accent;
-    style.Colors[ImGuiCol_SliderGrabActive] =
-        ImVec4(accent.x * 1.2f, accent.y * 1.2f, accent.z * 1.2f, 1.0f);
-
-    style.Colors[ImGuiCol_CheckMark] = accent;
-    style.Colors[ImGuiCol_ResizeGrip] = surfaceVariant;
-    style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(accent.x, accent.y, accent.z, 0.6f);
-    style.Colors[ImGuiCol_ResizeGripActive] = accent;
-
-    style.Colors[ImGuiCol_Tab] = surface;
-    style.Colors[ImGuiCol_TabHovered] = ImVec4(accent.x, accent.y, accent.z, 0.8f);
-    style.Colors[ImGuiCol_TabActive] = surfaceVariant;
-    style.Colors[ImGuiCol_TabUnfocused] = surface;
-    style.Colors[ImGuiCol_TabUnfocusedActive] = surfaceVariant;
-    style.Colors[ImGuiCol_TabSelectedOverline] = accent;
-
-    style.Colors[ImGuiCol_TableHeaderBg] = surfaceVariant;
-    style.Colors[ImGuiCol_TableBorderStrong] = border;
-    style.Colors[ImGuiCol_TableBorderLight] =
-        ImVec4(border.x * 0.7f, border.y * 0.7f, border.z * 0.7f, border.w);
-
-    style.Colors[ImGuiCol_TableRowBg] = ImVec4(0, 0, 0, 0);
-    style.Colors[ImGuiCol_TableRowBgAlt] = ImVec4(fg.x, fg.y, fg.z, 0.06f);
-
-    style.Colors[ImGuiCol_Separator] = border;
-    style.Colors[ImGuiCol_SeparatorHovered] = accent;
-    style.Colors[ImGuiCol_SeparatorActive] = accent;
-
-    style.Colors[ImGuiCol_MenuBarBg] = surface;
-
-    style.Colors[ImGuiCol_DockingPreview] = ImVec4(accent.x, accent.y, accent.z, 0.7f);
-    style.Colors[ImGuiCol_DockingEmptyBg] = bg;
-}
--- a/src/gui/color_scheme_editor.hpp
+++ b/src/gui/color_scheme_editor.hpp
@@ -1,33 +0,0 @@
-#ifndef CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
-#define CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
-
-#include "color_text_edit/TextEditor.h"
-#include "palette_controller.hpp"
-
-class template_editor;
-
-class color_scheme_editor
-{
-public:
-    color_scheme_editor();
-    
-    void render_controls_and_colors();
-    void render_preview();
-    void set_template_editor(template_editor* editor) { m_template_editor = editor; }
-    const palette_controller& controller() const { return m_controller; }
-
-private:
-    void render_controls();
-    void render_color_table();
-    void render_preview_content();
-    
-    void apply_palette_to_editor();
-    void apply_palette_to_imgui() const;
-    void notify_palette_changed();
-
-    palette_controller m_controller;
-    TextEditor m_editor;
-    template_editor* m_template_editor{nullptr};
-};
-
-#endif // CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
--- a/src/gui/controllers/palette_controller.cpp
+++ b/src/gui/controllers/palette_controller.cpp
@@ -1,4 +1,4 @@
-#include "palette_controller.hpp"
+#include "gui/controllers/palette_controller.hpp"
 #include "core/config/config.hpp"
 #include "core/theme/theme_renderer.hpp"

@@ -11,25 +11,35 @@ palette_controller::palette_controller()
    if (m_palettes.empty())
        return;

-    try {
-        m_current_palette = m_palettes[clrsync::core::config::instance().default_theme()];
-    } catch (...) {
+    auto default_theme = clrsync::core::config::instance().default_theme();
+    auto it = m_palettes.find(default_theme);
+    if (it != m_palettes.end())
+    {
+        m_current_palette = it->second;
+    }
+    else
+    {
        m_current_palette = m_palettes.begin()->second;
    }
 }

-void palette_controller::select_palette(const std::string& name)
+void palette_controller::select_palette(const std::string &name)
 {
    auto it = m_palettes.find(name);
-    if (it != m_palettes.end()) {
+    if (it != m_palettes.end())
+    {
        m_current_palette = it->second;
    }
 }

-void palette_controller::create_palette(const std::string& name)
+void palette_controller::create_palette(const std::string &name)
 {
-    clrsync::core::palette new_palette = m_palette_manager.load_palette_from_file(clrsync::core::config::get_data_dir().string() + "/palettes/cursed.toml");
-    new_palette.set_name(name);
+    clrsync::core::palette new_palette(name);
+
+    for (const auto &[key, hex_value] : clrsync::core::DEFAULT_COLORS)
+    {
+        new_palette.set_color(key, clrsync::core::color(hex_value));
+    }

    auto dir = clrsync::core::config::instance().palettes_path();
    m_palette_manager.save_palette_to_file(new_palette, dir);
@@ -54,10 +64,10 @@ void palette_controller::delete_current_palette()
 void palette_controller::apply_current_theme() const
 {
    clrsync::core::theme_renderer<clrsync::core::io::toml_file> theme_renderer;
-    theme_renderer.apply_theme(m_current_palette.name());
+    (void)theme_renderer.apply_theme(m_current_palette.name());
 }

-void palette_controller::set_color(const std::string& key, const clrsync::core::color& color)
+void palette_controller::set_color(const std::string &key, const clrsync::core::color &color)
 {
    m_current_palette.set_color(key, color);
 }
--- a/src/gui/controllers/palette_controller.hpp
+++ b/src/gui/controllers/palette_controller.hpp
@@ -6,21 +6,28 @@
 #include <string>
 #include <unordered_map>

-class palette_controller {
-public:
+class palette_controller
+{
+  public:
    palette_controller();

-    const clrsync::core::palette& current_palette() const { return m_current_palette; }
-    const std::unordered_map<std::string, clrsync::core::palette>& palettes() const { return m_palettes; }
+    const clrsync::core::palette &current_palette() const
+    {
+        return m_current_palette;
+    }
+    const std::unordered_map<std::string, clrsync::core::palette> &palettes() const
+    {
+        return m_palettes;
+    }

-    void select_palette(const std::string& name);
-    void create_palette(const std::string& name);
+    void select_palette(const std::string &name);
+    void create_palette(const std::string &name);
    void save_current_palette();
    void delete_current_palette();
    void apply_current_theme() const;
-    void set_color(const std::string& key, const clrsync::core::color& color);
+    void set_color(const std::string &key, const clrsync::core::color &color);

-private:
+  private:
    void reload_palettes();

    clrsync::core::palette_manager<clrsync::core::io::toml_file> m_palette_manager;
--- a/src/gui/controllers/template_controller.cpp
+++ b/src/gui/controllers/template_controller.cpp
@@ -0,0 +1,64 @@
+#include "gui/controllers/template_controller.hpp"
+#include "core/config/config.hpp"
+
+template_controller::template_controller()
+{
+    m_templates = m_template_manager.templates();
+}
+
+void template_controller::set_template_enabled(const std::string &key, bool enabled)
+{
+    auto it = m_templates.find(key);
+    if (it != m_templates.end())
+    {
+        it->second.set_enabled(enabled);
+        (void)clrsync::core::config::instance().update_template(key, it->second);
+    }
+}
+
+void template_controller::set_template_input_path(const std::string &key, const std::string &path)
+{
+    auto it = m_templates.find(key);
+    if (it != m_templates.end())
+    {
+        it->second.set_template_path(path);
+        (void)clrsync::core::config::instance().update_template(key, it->second);
+    }
+}
+
+void template_controller::set_template_output_path(const std::string &key, const std::string &path)
+{
+    auto it = m_templates.find(key);
+    if (it != m_templates.end())
+    {
+        it->second.set_output_path(path);
+        (void)clrsync::core::config::instance().update_template(key, it->second);
+    }
+}
+
+void template_controller::set_template_reload_command(const std::string &key,
+                                                      const std::string &cmd)
+{
+    auto it = m_templates.find(key);
+    if (it != m_templates.end())
+    {
+        it->second.set_reload_command(cmd);
+        (void)clrsync::core::config::instance().update_template(key, it->second);
+    }
+}
+
+bool template_controller::remove_template(const std::string &key)
+{
+    auto result = clrsync::core::config::instance().remove_template(key);
+    if (result)
+    {
+        m_templates.erase(key);
+        return true;
+    }
+    return false;
+}
+
+void template_controller::refresh()
+{
+    m_templates = m_template_manager.templates();
+}
--- a/src/gui/controllers/template_controller.hpp
+++ b/src/gui/controllers/template_controller.hpp
@@ -1,22 +1,29 @@
 #ifndef CLRSYNC_GUI_TEMPLATE_CONTROLLER_HPP
 #define CLRSYNC_GUI_TEMPLATE_CONTROLLER_HPP

-#include "core/theme/theme_template.hpp"
-#include "core/theme/template_manager.hpp"
 #include "core/io/toml_file.hpp"
+#include "core/theme/template_manager.hpp"
+#include "core/theme/theme_template.hpp"
 #include <string>
 #include <unordered_map>

-class template_controller {
-public:
+class template_controller
+{
+  public:
    template_controller();
-    [[nodiscard]] const std::unordered_map<std::string, clrsync::core::theme_template>& templates() const { return m_templates; }
-    void set_template_enabled(const std::string& key, bool enabled);
-    void set_template_output_path(const std::string& key, const std::string& path);
-    void set_template_reload_command(const std::string& key, const std::string& cmd);
+    [[nodiscard]] const std::unordered_map<std::string, clrsync::core::theme_template> &templates()
+        const
+    {
+        return m_templates;
+    }
+    void set_template_enabled(const std::string &key, bool enabled);
+    void set_template_input_path(const std::string &key, const std::string &path);
+    void set_template_output_path(const std::string &key, const std::string &path);
+    void set_template_reload_command(const std::string &key, const std::string &cmd);
+    bool remove_template(const std::string &key);
    void refresh();

-private:
+  private:
    clrsync::core::template_manager<clrsync::core::io::toml_file> m_template_manager;
    std::unordered_map<std::string, clrsync::core::theme_template> m_templates;
 };
--- a/src/gui/controllers/theme_applier.cpp
+++ b/src/gui/controllers/theme_applier.cpp
@@ -0,0 +1,162 @@
+#include "gui/controllers/theme_applier.hpp"
+#include "imgui.h"
+
+namespace theme_applier
+{
+
+static uint32_t get_color_u32(const clrsync::core::palette &current, const std::string &key)
+{
+    const auto &col = current.get_color(key);
+    const uint32_t hex = col.hex();
+    // Convert from RRGGBBAA to AABBGGRR (ImGui format)
+    const uint32_t r = (hex >> 24) & 0xFF;
+    const uint32_t g = (hex >> 16) & 0xFF;
+    const uint32_t b = (hex >> 8) & 0xFF;
+    const uint32_t a = hex & 0xFF;
+    return (a << 24) | (b << 16) | (g << 8) | r;
+}
+
+void apply_to_editor(TextEditor &editor, const clrsync::core::palette &current)
+{
+    auto palette = editor.GetPalette();
+
+    palette[int(TextEditor::PaletteIndex::Default)] = get_color_u32(current, "editor_main");
+    palette[int(TextEditor::PaletteIndex::Keyword)] = get_color_u32(current, "editor_command");
+    palette[int(TextEditor::PaletteIndex::Number)] = get_color_u32(current, "editor_warning");
+    palette[int(TextEditor::PaletteIndex::String)] = get_color_u32(current, "editor_string");
+    palette[int(TextEditor::PaletteIndex::CharLiteral)] = get_color_u32(current, "editor_string");
+    palette[int(TextEditor::PaletteIndex::Punctuation)] = get_color_u32(current, "editor_main");
+    palette[int(TextEditor::PaletteIndex::Preprocessor)] =
+        get_color_u32(current, "editor_emphasis");
+    palette[int(TextEditor::PaletteIndex::Identifier)] = get_color_u32(current, "editor_main");
+    palette[int(TextEditor::PaletteIndex::KnownIdentifier)] = get_color_u32(current, "editor_link");
+    palette[int(TextEditor::PaletteIndex::PreprocIdentifier)] =
+        get_color_u32(current, "editor_link");
+
+    palette[int(TextEditor::PaletteIndex::Comment)] = get_color_u32(current, "editor_comment");
+    palette[int(TextEditor::PaletteIndex::MultiLineComment)] =
+        get_color_u32(current, "editor_comment");
+
+    palette[int(TextEditor::PaletteIndex::Background)] =
+        get_color_u32(current, "editor_background");
+    palette[int(TextEditor::PaletteIndex::Cursor)] = get_color_u32(current, "cursor");
+
+    palette[int(TextEditor::PaletteIndex::Selection)] = get_color_u32(current, "editor_selected");
+    palette[int(TextEditor::PaletteIndex::ErrorMarker)] = get_color_u32(current, "editor_error");
+    palette[int(TextEditor::PaletteIndex::Breakpoint)] = get_color_u32(current, "editor_error");
+
+    palette[int(TextEditor::PaletteIndex::LineNumber)] =
+        get_color_u32(current, "editor_line_number");
+
+    palette[int(TextEditor::PaletteIndex::CurrentLineFill)] =
+        get_color_u32(current, "surface_variant");
+    palette[int(TextEditor::PaletteIndex::CurrentLineFillInactive)] =
+        get_color_u32(current, "surface");
+
+    palette[int(TextEditor::PaletteIndex::CurrentLineEdge)] =
+        get_color_u32(current, "border_focused");
+
+    editor.SetPalette(palette);
+}
+
+void apply_to_imgui(const clrsync::core::palette &current)
+{
+    auto getColor = [&](const std::string &key) -> ImVec4 {
+        const auto &col = current.get_color(key);
+        const uint32_t hex = col.hex();
+        return {((hex >> 24) & 0xFF) / 255.0f, ((hex >> 16) & 0xFF) / 255.0f,
+                ((hex >> 8) & 0xFF) / 255.0f, ((hex) & 0xFF) / 255.0f};
+    };
+
+    ImGuiStyle &style = ImGui::GetStyle();
+
+    const ImVec4 bg = getColor("background");
+    const ImVec4 onBg = getColor("on_background");
+    const ImVec4 surface = getColor("surface");
+    const ImVec4 onSurface = getColor("on_surface");
+    const ImVec4 surfaceVariant = getColor("surface_variant");
+    const ImVec4 onSurfaceVariant = getColor("on_surface_variant");
+    const ImVec4 fg = getColor("foreground");
+    const ImVec4 fgInactive = getColor("editor_inactive");
+    const ImVec4 accent = getColor("accent");
+    const ImVec4 border = getColor("border");
+
+    const ImVec4 error = getColor("error");
+    const ImVec4 onError = getColor("on_error");
+    const ImVec4 success = getColor("success");
+    const ImVec4 onSuccess = getColor("on_success");
+    const ImVec4 warning = getColor("warning");
+    const ImVec4 onWarning = getColor("on_warning");
+    const ImVec4 info = getColor("info");
+    const ImVec4 onInfo = getColor("on_info");
+
+    style.Colors[ImGuiCol_WindowBg] = bg;
+    style.Colors[ImGuiCol_ChildBg] = surface;
+    style.Colors[ImGuiCol_PopupBg] = surface;
+
+    style.Colors[ImGuiCol_Border] = border;
+    style.Colors[ImGuiCol_BorderShadow] = ImVec4(0, 0, 0, 0);
+
+    style.Colors[ImGuiCol_Text] = onSurface;
+    style.Colors[ImGuiCol_TextDisabled] = onSurfaceVariant;
+    style.Colors[ImGuiCol_TextSelectedBg] = accent;
+
+    style.Colors[ImGuiCol_Header] = surfaceVariant;
+    style.Colors[ImGuiCol_HeaderHovered] = ImVec4(accent.x, accent.y, accent.z, 0.8f);
+    style.Colors[ImGuiCol_HeaderActive] = accent;
+
+    style.Colors[ImGuiCol_Button] = surfaceVariant;
+    style.Colors[ImGuiCol_ButtonHovered] = ImVec4(accent.x, accent.y, accent.z, 0.6f);
+    style.Colors[ImGuiCol_ButtonActive] = accent;
+
+    style.Colors[ImGuiCol_FrameBg] = surfaceVariant;
+    style.Colors[ImGuiCol_FrameBgHovered] =
+        ImVec4(surfaceVariant.x * 1.1f, surfaceVariant.y * 1.1f, surfaceVariant.z * 1.1f, 1.0f);
+    style.Colors[ImGuiCol_FrameBgActive] =
+        ImVec4(surfaceVariant.x * 1.2f, surfaceVariant.y * 1.2f, surfaceVariant.z * 1.2f, 1.0f);
+
+    style.Colors[ImGuiCol_TitleBg] = surface;
+    style.Colors[ImGuiCol_TitleBgActive] = surfaceVariant;
+    style.Colors[ImGuiCol_TitleBgCollapsed] = surface;
+
+    style.Colors[ImGuiCol_ScrollbarBg] = surface;
+    style.Colors[ImGuiCol_ScrollbarGrab] = surfaceVariant;
+    style.Colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(accent.x, accent.y, accent.z, 0.6f);
+    style.Colors[ImGuiCol_ScrollbarGrabActive] = accent;
+
+    style.Colors[ImGuiCol_SliderGrab] = accent;
+    style.Colors[ImGuiCol_SliderGrabActive] =
+        ImVec4(accent.x * 1.2f, accent.y * 1.2f, accent.z * 1.2f, 1.0f);
+
+    style.Colors[ImGuiCol_CheckMark] = accent;
+    style.Colors[ImGuiCol_ResizeGrip] = surfaceVariant;
+    style.Colors[ImGuiCol_ResizeGripHovered] = ImVec4(accent.x, accent.y, accent.z, 0.6f);
+    style.Colors[ImGuiCol_ResizeGripActive] = accent;
+
+    style.Colors[ImGuiCol_Tab] = surface;
+    style.Colors[ImGuiCol_TabHovered] = ImVec4(accent.x, accent.y, accent.z, 0.8f);
+    style.Colors[ImGuiCol_TabActive] = surfaceVariant;
+    style.Colors[ImGuiCol_TabUnfocused] = surface;
+    style.Colors[ImGuiCol_TabUnfocusedActive] = surfaceVariant;
+    style.Colors[ImGuiCol_TabSelectedOverline] = accent;
+
+    style.Colors[ImGuiCol_TableHeaderBg] = surfaceVariant;
+    style.Colors[ImGuiCol_TableBorderStrong] = border;
+    style.Colors[ImGuiCol_TableBorderLight] =
+        ImVec4(border.x * 0.7f, border.y * 0.7f, border.z * 0.7f, border.w);
+
+    style.Colors[ImGuiCol_TableRowBg] = ImVec4(0, 0, 0, 0);
+    style.Colors[ImGuiCol_TableRowBgAlt] =
+        ImVec4(onSurfaceVariant.x, onSurfaceVariant.y, onSurfaceVariant.z, 0.06f);
+
+    style.Colors[ImGuiCol_Separator] = border;
+    style.Colors[ImGuiCol_SeparatorHovered] = accent;
+    style.Colors[ImGuiCol_SeparatorActive] = accent;
+
+    style.Colors[ImGuiCol_MenuBarBg] = surface;
+
+    style.Colors[ImGuiCol_DockingPreview] = ImVec4(accent.x, accent.y, accent.z, 0.7f);
+    style.Colors[ImGuiCol_DockingEmptyBg] = bg;
+}
+
+} // namespace theme_applier
--- a/src/gui/controllers/theme_applier.hpp
+++ b/src/gui/controllers/theme_applier.hpp
@@ -0,0 +1,13 @@
+#ifndef CLRSYNC_GUI_THEME_APPLIER_HPP
+#define CLRSYNC_GUI_THEME_APPLIER_HPP
+
+#include "color_text_edit/TextEditor.h"
+#include "core/palette/palette.hpp"
+
+namespace theme_applier
+{
+void apply_to_imgui(const clrsync::core::palette &pal);
+void apply_to_editor(TextEditor &editor, const clrsync::core::palette &pal);
+} // namespace theme_applier
+
+#endif // CLRSYNC_GUI_THEME_APPLIER_HPP
--- a/src/gui/font_loader.cpp
+++ b/src/gui/font_loader.cpp
@@ -1,228 +0,0 @@
-#include "font_loader.hpp"
-#include "core/config/config.hpp"
-#include "imgui_internal.h"
-#include <imgui.h>
-#include <algorithm>
-
-#if defined(_WIN32)
-
-#include <algorithm>
-#include <windows.h>
-#include <winreg.h>
-
-static std::string search_registry_for_font(HKEY root_key, const char* subkey, const std::string& font_name_lower, const char* default_font_dir)
-{
-    HKEY hKey;
-    LONG result = RegOpenKeyExA(root_key, subkey, 0, KEY_READ, &hKey);
-
-    if (result != ERROR_SUCCESS)
-        return {};
-
-    char value_name[512];
-    BYTE value_data[512];
-    DWORD value_name_size, value_data_size, type;
-    DWORD index = 0;
-
-    std::string found_path;
-
-    while (true)
-    {
-        value_name_size = sizeof(value_name);
-        value_data_size = sizeof(value_data);
-
-        result = RegEnumValueA(hKey, index++, value_name, &value_name_size, nullptr, &type, value_data, &value_data_size);
-
-        if (result != ERROR_SUCCESS)
-            break;
-
-        if (type != REG_SZ)
-            continue;
-
-        std::string reg_font_name = value_name;
-        std::transform(reg_font_name.begin(), reg_font_name.end(), reg_font_name.begin(), ::tolower);
-
-        if (reg_font_name.find(font_name_lower) != std::string::npos)
-        {
-            std::string font_file = reinterpret_cast<char*>(value_data);
-
-            // If path is not absolute, prepend default font directory
-            if (font_file.find(":\\") == std::string::npos)
-            {
-                found_path = std::string(default_font_dir) + "\\" + font_file;
-            }
-            else
-            {
-                found_path = font_file;
-            }
-            break;
-        }
-    }
-
-    RegCloseKey(hKey);
-    return found_path;
-}
-
-std::string font_loader::find_font_windows(const char* font_name)
-{
-    std::string font_name_lower = font_name;
-    std::transform(font_name_lower.begin(), font_name_lower.end(), font_name_lower.begin(), ::tolower);
-
-    char windows_dir[MAX_PATH];
-    GetWindowsDirectoryA(windows_dir, MAX_PATH);
-    std::string system_fonts_dir = std::string(windows_dir) + "\\Fonts";
-
-    // First, try system-wide fonts (HKEY_LOCAL_MACHINE)
-    std::string path = search_registry_for_font(
-        HKEY_LOCAL_MACHINE,
-        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
-        font_name_lower,
-        system_fonts_dir.c_str()
-    );
-
-    if (!path.empty())
-        return path;
-
-    // If not found, try per-user fonts (HKEY_CURRENT_USER)
-    char local_appdata[MAX_PATH];
-    if (GetEnvironmentVariableA("LOCALAPPDATA", local_appdata, MAX_PATH) > 0)
-    {
-        std::string user_fonts_dir = std::string(local_appdata) + "\\Microsoft\\Windows\\Fonts";
-
-        path = search_registry_for_font(
-            HKEY_CURRENT_USER,
-            "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
-            font_name_lower,
-            user_fonts_dir.c_str()
-        );
-    }
-
-    return path;
-}
-#endif
-
-#if defined(__APPLE__)
-
-#include <CoreText/CoreText.h>
-
-std::vector<unsigned char> font_loader::load_font_macos(const char* font_name)
-{
-    std::vector<unsigned char> out;
-
-    CFStringRef cf_name = CFStringCreateWithCString(nullptr, font_name, kCFStringEncodingUTF8);
-    if (!cf_name)
-        return out;
-
-    CTFontDescriptorRef desc = CTFontDescriptorCreateWithNameAndSize(cf_name, 12);
-    CFRelease(cf_name);
-
-    if (!desc)
-        return out;
-
-    CTFontRef font = CTFontCreateWithFontDescriptor(desc, 0, nullptr);
-    CFRelease(desc);
-
-    if (!font)
-        return out;
-
-    CFDataRef data = CTFontCopyTable(font, kCTFontTableCFF, 0);
-    if (!data)
-        data = CTFontCopyTable(font, kCTFontTableHead, 0);
-
-    if (data)
-    {
-        CFIndex size = CFDataGetLength(data);
-        out.resize(size);
-        CFDataGetBytes(data, CFRangeMake(0, size), out.data());
-        CFRelease(data);
-    }
-
-    CFRelease(font);
-    return out;
-}
-
-#endif
-
-#if !defined(_WIN32) && !defined(__APPLE__)
-
-#include <fontconfig/fontconfig.h>
-
-std::string font_loader::find_font_linux(const char* font_name)
-{
-    FcInit();
-
-    FcPattern* pattern = FcNameParse(reinterpret_cast<const FcChar8*>(font_name));
-    if (!pattern)
-        return {};
-
-    FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
-    FcDefaultSubstitute(pattern);
-
-    FcResult result;
-    FcPattern* match = FcFontMatch(nullptr, pattern, &result);
-
-    std::string out;
-
-    if (match)
-    {
-        FcChar8* file = nullptr;
-        if (FcPatternGetString(match, FC_FILE, 0, &file) == FcResultMatch)
-            out = reinterpret_cast<const char*>(file);
-
-        FcPatternDestroy(match);
-    }
-
-    FcPatternDestroy(pattern);
-    return out;
-}
-
-#endif
-
-std::string font_loader::find_font_path(const char* font_name)
-{
-#if defined(_WIN32)
-    return find_font_windows(font_name);
-
-#elif defined(__APPLE__)
-    (void)font_name;
-    return {};
-
-#else
-    return find_font_linux(font_name);
-
-#endif
-}
-
-ImFont* font_loader::load_font(const char* font_name, float size_px)
-{
-#if defined(__APPLE__)
-    std::vector<unsigned char> buf = load_font_macos(font_name);
-    if (buf.empty())
-        return nullptr;
-
-    return ImGui::GetIO().Fonts->AddFontFromMemoryTTF(
-        buf.data(),
-        static_cast<int>(buf.size()),
-        size_px
-    );
-
-#else
-    std::string path = find_font_path(font_name);
-    if (path.empty())
-        return nullptr;
-
-    float scale = ImGui::GetIO().DisplayFramebufferScale.y;
-    return ImGui::GetIO().Fonts->AddFontFromFileTTF(
-        path.c_str(),
-        size_px * scale
-    );
-#endif
-}
-
-void font_loader::push_default_font()
-{
-    ImGui::PushFont(ImGui::GetDefaultFont(), clrsync::core::config::instance().font_size());
-}
-void font_loader::pop_font()
-{
-    ImGui::PopFont();
-}
--- a/src/gui/font_loader.hpp
+++ b/src/gui/font_loader.hpp
@@ -1,30 +0,0 @@
-#ifndef CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
-#define CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
-
-#include <string>
-#include <vector>
-#include <imgui.h>
-
-class font_loader
-{
-public:
-    font_loader() = default;
-
-    // Loads system font by name and returns an ImFont* or nullptr.
-    ImFont* load_font(const char* font_name, float size_px);
-    void push_default_font();
-    void pop_font();
-
-private:
-    std::string find_font_path(const char* font_name);
-
-#if defined(_WIN32)
-    static std::string find_font_windows(const char* font_name);
-#elif defined(__APPLE__)
-    std::vector<unsigned char> load_font_macos(const char* font_name);
-#else
-    std::string find_font_linux(const char* font_name);
-#endif
-};
-
-#endif // CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
--- a/src/gui/helpers/imgui_helpers.cpp
+++ b/src/gui/helpers/imgui_helpers.cpp
@@ -0,0 +1,266 @@
+#include <iostream>
+#include <string>
+
+#include "GLFW/glfw3.h"
+#include "gui/views/settings_window.hpp"
+#include "imgui_impl_glfw.h"
+#include "imgui_impl_opengl3.h"
+
+#include "imgui_helpers.hpp"
+
+#include "imgui_internal.h"
+
+GLFWwindow *init_glfw()
+{
+    glfwSetErrorCallback([](int error, const char *description) {
+        std::cerr << "GLFW Error " << error << ": " << description << std::endl;
+    });
+
+    if (!glfwInit())
+    {
+        std::cerr << "Failed to initialize GLFW\n";
+        return nullptr;
+    }
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+#else
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+#endif
+    glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);
+
+    GLFWwindow *w = glfwCreateWindow(1280, 720, "clrsync", nullptr, nullptr);
+    if (!w)
+    {
+        std::cerr << "Failed to create GLFW window\n";
+        return nullptr;
+    }
+
+    glfwMakeContextCurrent(w);
+    glfwSwapInterval(1);
+    return w;
+}
+
+void init_imgui(GLFWwindow *window, const std::string &ini_path)
+{
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+
+    ImGuiIO &io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.IniFilename = ini_path.c_str();
+
+    ImGui::StyleColorsDark();
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+#ifdef __APPLE__
+    ImGui_ImplOpenGL3_Init("#version 150");
+#else
+    ImGui_ImplOpenGL3_Init("#version 120");
+#endif
+}
+
+void begin_frame()
+{
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+}
+
+void render_menu_bar(about_window *about, settings_window *settings)
+{
+    if (ImGui::BeginMainMenuBar())
+    {
+        if (ImGui::BeginMenu("File"))
+        {
+            if (ImGui::MenuItem("Settings"))
+            {
+                if (settings)
+                    settings->show();
+            }
+            ImGui::Separator();
+            if (ImGui::MenuItem("Exit"))
+            {
+                glfwSetWindowShouldClose(glfwGetCurrentContext(), GLFW_TRUE);
+            }
+            ImGui::EndMenu();
+        }
+
+        if (ImGui::BeginMenu("Help"))
+        {
+            if (ImGui::MenuItem("About"))
+            {
+                if (about)
+                    about->show();
+            }
+            ImGui::EndMenu();
+        }
+        ImGui::EndMainMenuBar();
+    }
+}
+
+void setup_main_dockspace(bool &first_time)
+{
+    const ImGuiViewport *viewport = ImGui::GetMainViewport();
+    ImGui::SetNextWindowPos(viewport->Pos);
+    ImGui::SetNextWindowSize(viewport->Size);
+    ImGui::SetNextWindowViewport(viewport->ID);
+
+    constexpr ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse |
+                                       ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
+                                       ImGuiWindowFlags_NoBringToFrontOnFocus |
+                                       ImGuiWindowFlags_NoNavFocus | ImGuiWindowFlags_MenuBar;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
+    ImGui::Begin("MainDockSpace", nullptr, flags);
+    ImGui::PopStyleVar(3);
+
+    ImGuiID dockspace_id = ImGui::GetID("MainDockSpace");
+
+    if (first_time)
+    {
+        first_time = false;
+
+        ImGui::DockBuilderRemoveNode(dockspace_id);
+        ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace);
+        ImGui::DockBuilderSetNodeSize(dockspace_id, viewport->Size);
+
+        ImGuiID center, right;
+        ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Right, 0.5f, &right, &center);
+
+        ImGuiDockNode *center_node = ImGui::DockBuilderGetNode(center);
+        if (center_node)
+        {
+            center_node->LocalFlags |= ImGuiDockNodeFlags_CentralNode;
+        }
+
+        ImGui::DockBuilderDockWindow("Color Schemes", right);
+        ImGui::DockBuilderDockWindow("Color Preview", center);
+        ImGui::DockBuilderDockWindow("Templates", center);
+
+        ImGui::DockBuilderFinish(dockspace_id);
+    }
+
+    ImGui::DockSpace(dockspace_id, ImVec2{0, 0}, ImGuiDockNodeFlags_None);
+    ImGui::End();
+}
+
+void end_frame(GLFWwindow *window)
+{
+    ImGui::Render();
+    int w, h;
+    glfwGetFramebufferSize(window, &w, &h);
+    glViewport(0, 0, w, h);
+    glClearColor(0.1f, 0.1f, 0.1f, 0.f);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    glfwSwapBuffers(window);
+}
+
+void shutdown(GLFWwindow *window)
+{
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+}
+
+namespace palette_utils
+{
+
+ImVec4 get_color(const clrsync::core::palette &pal, const std::string &key,
+                 const std::string &fallback)
+{
+    auto colors = pal.colors();
+    if (colors.empty())
+        return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+
+    auto it = colors.find(key);
+    if (it == colors.end() && !fallback.empty())
+    {
+        it = colors.find(fallback);
+    }
+
+    if (it != colors.end())
+    {
+        const auto &col = it->second;
+        const uint32_t hex = col.hex();
+        const float r = ((hex >> 24) & 0xFF) / 255.0f;
+        const float g = ((hex >> 16) & 0xFF) / 255.0f;
+        const float b = ((hex >> 8) & 0xFF) / 255.0f;
+        const float a = (hex & 0xFF) / 255.0f;
+        return ImVec4(r, g, b, a);
+    }
+    return ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+}
+
+uint32_t get_color_u32(const clrsync::core::palette &pal, const std::string &key,
+                       const std::string &fallback)
+{
+    auto colors = pal.colors();
+    if (colors.empty())
+        return 0xFFFFFFFF;
+
+    auto it = colors.find(key);
+    if (it == colors.end() && !fallback.empty())
+    {
+        it = colors.find(fallback);
+    }
+
+    if (it != colors.end())
+    {
+        const auto &col = it->second;
+        const uint32_t hex = col.hex();
+        const uint32_t r = (hex >> 24) & 0xFF;
+        const uint32_t g = (hex >> 16) & 0xFF;
+        const uint32_t b = (hex >> 8) & 0xFF;
+        const uint32_t a = hex & 0xFF;
+        return (a << 24) | (b << 16) | (g << 8) | r;
+    }
+    return 0xFFFFFFFF;
+}
+
+bool render_delete_confirmation_popup(const std::string &popup_title, const std::string &item_name,
+                                      const std::string &item_type,
+                                      const clrsync::core::palette &pal,
+                                      const std::function<void()> &on_delete)
+{
+    bool result = false;
+    if (ImGui::BeginPopupModal(popup_title.c_str(), nullptr, ImGuiWindowFlags_AlwaysAutoResize))
+    {
+        ImVec4 warning_color = get_color(pal, "warning", "accent");
+        ImGui::TextColored(warning_color, "Are you sure you want to delete '%s'?",
+                           item_name.c_str());
+        ImGui::Text("This action cannot be undone.");
+
+        ImGui::Spacing();
+        ImGui::Separator();
+        ImGui::Spacing();
+
+        float button_width = 120.0f;
+        float total_width = 2.0f * button_width + ImGui::GetStyle().ItemSpacing.x;
+        float window_width = ImGui::GetContentRegionAvail().x;
+        ImGui::SetCursorPosX((window_width - total_width) * 0.5f);
+
+        if (ImGui::Button("Delete", ImVec2(button_width, 0)))
+        {
+            on_delete();
+            result = true;
+            ImGui::CloseCurrentPopup();
+        }
+
+        ImGui::SameLine();
+        if (ImGui::Button("Cancel", ImVec2(button_width, 0)))
+        {
+            ImGui::CloseCurrentPopup();
+        }
+        ImGui::EndPopup();
+    }
+    return result;
+}
+
+} // namespace palette_utils
--- a/src/gui/helpers/imgui_helpers.hpp
+++ b/src/gui/helpers/imgui_helpers.hpp
@@ -0,0 +1,42 @@
+#ifndef CLRSYNC_IMGUI_HELPERS_HPP
+#define CLRSYNC_IMGUI_HELPERS_HPP
+
+#include "core/palette/palette.hpp"
+#include "gui/views/about_window.hpp"
+#include "imgui.h"
+#include <functional>
+#include <string>
+
+struct GLFWwindow;
+class settings_window;
+
+GLFWwindow *init_glfw();
+void init_imgui(GLFWwindow *window, const std::string &ini_path);
+void begin_frame();
+void setup_main_dockspace(bool &first_time);
+void end_frame(GLFWwindow *window);
+void shutdown(GLFWwindow *window);
+void render_menu_bar(about_window *about, settings_window *settings);
+
+namespace palette_utils
+{
+ImVec4 get_color(const clrsync::core::palette &pal, const std::string &key,
+                 const std::string &fallback = "");
+uint32_t get_color_u32(const clrsync::core::palette &pal, const std::string &key,
+                       const std::string &fallback = "");
+bool render_delete_confirmation_popup(const std::string &popup_title, const std::string &item_name,
+                                      const std::string &item_type,
+                                      const clrsync::core::palette &pal,
+                                      const std::function<void()> &on_delete);
+} // namespace palette_utils
+
+namespace imgui_helpers
+{
+inline ImVec4 get_palette_color(const clrsync::core::palette &pal, const std::string &key,
+                                const std::string &fallback = "")
+{
+    return palette_utils::get_color(pal, key, fallback);
+}
+} // namespace imgui_helpers
+
+#endif // CLRSYNC_IMGUI_HELPERS_HPP
--- a/src/gui/imgui_helpers.cpp
+++ b/src/gui/imgui_helpers.cpp
@@ -1,154 +0,0 @@
-#include <string>
-
-#include "GLFW/glfw3.h"
-#include "gui/settings_window.hpp"
-#include "imgui_impl_glfw.h"
-#include "imgui_impl_opengl3.h"
-
-#include "imgui_helpers.hpp"
-
-#include "imgui_internal.h"
-
-GLFWwindow * init_glfw()
-{
-    if (!glfwInit()) return nullptr;
-
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
-    glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE);
-
-    GLFWwindow* w = glfwCreateWindow(1280, 720, "clrsync", nullptr, nullptr);
-    if (!w) return nullptr;
-
-    glfwMakeContextCurrent(w);
-    glfwSwapInterval(1);
-    return w;
-}
-
-void init_imgui(GLFWwindow* window, const std::string& ini_path)
-{
-    IMGUI_CHECKVERSION();
-    ImGui::CreateContext();
-
-    ImGuiIO& io = ImGui::GetIO();
-    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
-    io.IniFilename = ini_path.c_str();
-
-    ImGui::StyleColorsDark();
-    ImGui_ImplGlfw_InitForOpenGL(window, true);
-    ImGui_ImplOpenGL3_Init("#version 130");
-}
-
-void begin_frame()
-{
-    ImGui_ImplOpenGL3_NewFrame();
-    ImGui_ImplGlfw_NewFrame();
-    ImGui::NewFrame();
-}
-
-void render_menu_bar(about_window* about, settings_window* settings)
-{
-    if (ImGui::BeginMainMenuBar())
-    {
-        if (ImGui::BeginMenu("File"))
-        {
-            if (ImGui::MenuItem("Settings"))
-            {
-                if (settings)
-                    settings->show();
-            }
-            ImGui::Separator();
-            if (ImGui::MenuItem("Exit"))
-            {
-                // Will be handled by checking window should close
-                glfwSetWindowShouldClose(glfwGetCurrentContext(), GLFW_TRUE);
-            }
-            ImGui::EndMenu();
-        }
-
-        if (ImGui::BeginMenu("Help"))
-        {
-            if (ImGui::MenuItem("About"))
-            {
-                if (about)
-                    about->show();
-            }
-            ImGui::EndMenu();
-        }
-        ImGui::EndMainMenuBar();
-    }
-}
-
-void setup_main_dockspace(bool& first_time)
-{
-    const ImGuiViewport* viewport = ImGui::GetMainViewport();
-    ImGui::SetNextWindowPos(viewport->Pos);
-    ImGui::SetNextWindowSize(viewport->Size);
-    ImGui::SetNextWindowViewport(viewport->ID);
-
-    constexpr ImGuiWindowFlags flags =
-        ImGuiWindowFlags_NoTitleBar |
-        ImGuiWindowFlags_NoCollapse |
-        ImGuiWindowFlags_NoResize |
-        ImGuiWindowFlags_NoMove |
-        ImGuiWindowFlags_NoBringToFrontOnFocus |
-        ImGuiWindowFlags_NoNavFocus |
-        ImGuiWindowFlags_MenuBar;
-
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
-    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0,0));
-    ImGui::Begin("MainDockSpace", nullptr, flags);
-    ImGui::PopStyleVar(3);
-
-    ImGuiID dockspace_id = ImGui::GetID("MainDockSpace");
-
-    if (first_time)
-    {
-        first_time = false;
-
-        ImGui::DockBuilderRemoveNode(dockspace_id);
-        ImGui::DockBuilderAddNode(dockspace_id, ImGuiDockNodeFlags_DockSpace);
-        ImGui::DockBuilderSetNodeSize(dockspace_id, viewport->Size);
-
-        ImGuiID center, right;
-        ImGui::DockBuilderSplitNode(dockspace_id, ImGuiDir_Right, 0.5f, &right, &center);
-
-        ImGuiDockNode* center_node = ImGui::DockBuilderGetNode(center);
-        if (center_node)
-        {
-            center_node->LocalFlags |= ImGuiDockNodeFlags_CentralNode;
-        }
-
-        ImGui::DockBuilderDockWindow("Color Schemes", right);
-        ImGui::DockBuilderDockWindow("Templates", center);
-        ImGui::DockBuilderDockWindow("Color Preview", center);
-        
-        ImGui::DockBuilderFinish(dockspace_id);
-    }
-
-    ImGui::DockSpace(dockspace_id, ImVec2{0,0}, ImGuiDockNodeFlags_None);
-    ImGui::End();
-}
-
-void end_frame(GLFWwindow* window)
-{
-    ImGui::Render();
-    int w, h;
-    glfwGetFramebufferSize(window, &w, &h);
-    glViewport(0, 0, w, h);
-    glClearColor(0.1f, 0.1f, 0.1f, 0.f);
-    glClear(GL_COLOR_BUFFER_BIT);
-    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
-
-    glfwSwapBuffers(window);
-}
-
-void shutdown(GLFWwindow* window)
-{
-    ImGui_ImplOpenGL3_Shutdown();
-    ImGui_ImplGlfw_Shutdown();
-    ImGui::DestroyContext();
-    glfwDestroyWindow(window);
-    glfwTerminate();
-}
--- a/src/gui/imgui_helpers.hpp
+++ b/src/gui/imgui_helpers.hpp
@@ -1,18 +0,0 @@
-#ifndef CLRSYNC_IMGUI_HELPERS_HPP
-#define CLRSYNC_IMGUI_HELPERS_HPP
-
-#include "gui/about_window.hpp"
-#include <string>
-
-struct GLFWwindow;
-class settings_window;
-
-GLFWwindow * init_glfw();
-void init_imgui(GLFWwindow* window, const std::string& ini_path);
-void begin_frame();
-void setup_main_dockspace(bool& first_time);
-void end_frame(GLFWwindow* window);
-void shutdown(GLFWwindow* window);
-void render_menu_bar(about_window* about, settings_window* settings);
-
-#endif // CLRSYNC_IMGUI_HELPERS_HPP
--- a/src/gui/main.cpp
+++ b/src/gui/main.cpp
@@ -1,35 +1,56 @@
+#include <iostream>
 #include <memory>

 #include <GLFW/glfw3.h>
 #include <GLFW/glfw3native.h>

-
+#include "core/common/error.hpp"
+#include "core/common/utils.hpp"
 #include "core/config/config.hpp"
 #include "core/io/toml_file.hpp"
-#include "core/utils.hpp"

-#include "color_scheme_editor.hpp"
-#include "gui/font_loader.hpp"
-#include "gui/settings_window.hpp"
-#include "imgui_helpers.hpp"
-#include "template_editor.hpp"
-#include "about_window.hpp"
+#include "gui/backend/glfw_opengl.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "gui/ui_manager.hpp"
+#include "gui/views/about_window.hpp"
+#include "gui/views/color_scheme_editor.hpp"
+#include "gui/views/settings_window.hpp"
+#include "gui/views/template_editor.hpp"

-
-int main(int, char**)
+int main(int, char **)
 {
    auto config_path = clrsync::core::get_default_config_path();
    auto conf = std::make_unique<clrsync::core::io::toml_file>(config_path);
-    clrsync::core::config::instance().initialize(std::move(conf));
+
+    auto init_result = clrsync::core::config::instance().initialize(std::move(conf));
+    if (!init_result)
+    {
+        std::cerr << "Fatal error: " << init_result.error().description() << std::endl;
+        std::cerr
+            << "Hint: Set CLRSYNC_CONFIG_PATH environment variable or ensure config exists at: "
+            << config_path << std::endl;
+        return 1;
+    }

    std::filesystem::path base = config_path;
    static std::string ini_path = (base.parent_path() / "layout.ini").string();
    bool first_time = !std::filesystem::exists(ini_path);

-    GLFWwindow* window = init_glfw();
-    if (!window) return 1;
+    printf("GLFW Version: %s\n", glfwGetVersionString());

-    printf("GLFV Version: %s\n", glfwGetVersionString());
+    auto backend = clrsync::gui::backend::glfw_opengl_backend();
+    auto window_config = clrsync::gui::backend::window_config();
+    window_config.title = "clrsync";
+    window_config.width = 1280;
+    window_config.height = 720;
+    window_config.transparent_framebuffer = true;
+
+    if (!backend.initialize(window_config))
+    {
+        std::cerr << "Failed to initialize backend." << std::endl;
+        return 1;
+    }

    std::cout << "GLFW runtime platform: ";
    switch (glfwGetPlatform()) {
@@ -40,13 +61,23 @@ int main(int, char**)
        default: std::cout << "Unknown\n";
    }

+    clrsync::gui::ui_manager ui_manager(&backend);
    
-    init_imgui(window, ini_path);
+    clrsync::gui::ui_config ui_cfg;
+    ui_cfg.ini_path = ini_path;
+    ui_cfg.enable_docking = true;
+    ui_cfg.enable_keyboard_nav = true;
+    
+    if (!ui_manager.initialize(ui_cfg))
+    {
+        std::cerr << "Failed to initialize UI manager." << std::endl;
+        return 1;
+    }

    font_loader loader;

-    ImFont* font =
-        loader.load_font(clrsync::core::config::instance().font().c_str(), clrsync::core::config::instance().font_size());
+    ImFont *font = loader.load_font(clrsync::core::config::instance().font().c_str(),
+                                    clrsync::core::config::instance().font_size());

    if (font)
        ImGui::GetIO().FontDefault = font;
@@ -57,25 +88,32 @@ int main(int, char**)
    settings_window settingsWindow;

    colorEditor.set_template_editor(&templateEditor);
+    colorEditor.set_settings_window(&settingsWindow);
    templateEditor.apply_current_palette(colorEditor.controller().current_palette());
+    settingsWindow.set_palette(colorEditor.controller().current_palette());

-    while (!glfwWindowShouldClose(window))
+    while (!backend.should_close())
    {
-        glfwPollEvents();
+        backend.begin_frame();
+        
        loader.push_default_font();
-        begin_frame();
+        ui_manager.begin_frame();

        render_menu_bar(&aboutWindow, &settingsWindow);
        setup_main_dockspace(first_time);
+        templateEditor.render();
        colorEditor.render_controls_and_colors();
        colorEditor.render_preview();
-        templateEditor.render();
-        aboutWindow.render();
+        aboutWindow.render(colorEditor.controller().current_palette());
        settingsWindow.render();

        loader.pop_font();
-        end_frame(window);
+        
+        ui_manager.end_frame();
+        backend.end_frame();
    }
-    shutdown(window);
+
+    ui_manager.shutdown();
+    backend.shutdown();
    return 0;
 }
--- a/src/gui/platform/file_browser.hpp
+++ b/src/gui/platform/file_browser.hpp
@@ -0,0 +1,21 @@
+#ifndef CLRSYNC_GUI_FILE_BROWSER_HPP
+#define CLRSYNC_GUI_FILE_BROWSER_HPP
+
+#include <string>
+#include <vector>
+
+namespace file_dialogs
+{
+std::string open_file_dialog(const std::string &title = "Open File",
+                             const std::string &initial_path = "",
+                             const std::vector<std::string> &filters = {});
+
+std::string save_file_dialog(const std::string &title = "Save File",
+                             const std::string &initial_path = "",
+                             const std::vector<std::string> &filters = {});
+
+std::string select_folder_dialog(const std::string &title = "Select Folder",
+                                 const std::string &initial_path = "");
+} // namespace file_dialogs
+
+#endif // CLRSYNC_GUI_FILE_BROWSER_HPP
--- a/src/gui/platform/font_loader.hpp
+++ b/src/gui/platform/font_loader.hpp
@@ -0,0 +1,31 @@
+#ifndef CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
+#define CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
+
+#include <imgui.h>
+#include <string>
+#include <vector>
+
+class font_loader
+{
+  public:
+    font_loader() = default;
+
+    ImFont *load_font(const char *font_name, float size_px);
+    void push_default_font();
+    void pop_font();
+
+    std::vector<std::string> get_system_fonts();
+
+  private:
+    std::string find_font_path(const char *font_name);
+
+#if defined(_WIN32)
+    static std::string find_font_windows(const char *font_name);
+#elif defined(__APPLE__)
+    std::vector<unsigned char> load_font_macos(const char *font_name);
+#else
+    std::string find_font_linux(const char *font_name);
+#endif
+};
+
+#endif // CLRSYNC_GUI_SYSTEM_FONT_LOADER_HPP
--- a/src/gui/platform/linux/file_browser_linux.cpp
+++ b/src/gui/platform/linux/file_browser_linux.cpp
@@ -0,0 +1,133 @@
+#ifdef __linux__
+
+#include "gui/platform/file_browser.hpp"
+#include <gtk/gtk.h>
+#include <filesystem>
+
+namespace file_dialogs
+{
+
+std::string open_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    if (!gtk_init_check(nullptr, nullptr))
+    {
+        return "";
+    }
+
+    GtkFileChooserNative *native = gtk_file_chooser_native_new(
+        title.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_OPEN, "_Open", "_Cancel");
+
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+
+    if (!initial_path.empty())
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::exists(p))
+        {
+            if (std::filesystem::is_directory(p))
+            {
+                gtk_file_chooser_set_current_folder(chooser, initial_path.c_str());
+            }
+            else
+            {
+                gtk_file_chooser_set_current_folder(chooser, p.parent_path().c_str());
+                gtk_file_chooser_set_current_name(chooser, p.filename().c_str());
+            }
+        }
+    }
+
+    std::string result;
+    if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(native)) == GTK_RESPONSE_ACCEPT)
+    {
+        char *filename = gtk_file_chooser_get_filename(chooser);
+        if (filename)
+        {
+            result = filename;
+            g_free(filename);
+        }
+    }
+
+    g_object_unref(native);
+    while (gtk_events_pending())
+        gtk_main_iteration();
+    return result;
+}
+
+std::string save_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    if (!gtk_init_check(nullptr, nullptr))
+    {
+        return "";
+    }
+
+    GtkFileChooserNative *native = gtk_file_chooser_native_new(
+        title.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_SAVE, "_Save", "_Cancel");
+
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+    gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
+
+    if (!initial_path.empty())
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::exists(p.parent_path()))
+        {
+            gtk_file_chooser_set_current_folder(chooser, p.parent_path().c_str());
+            gtk_file_chooser_set_current_name(chooser, p.filename().c_str());
+        }
+    }
+
+    std::string result;
+    if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(native)) == GTK_RESPONSE_ACCEPT)
+    {
+        char *filename = gtk_file_chooser_get_filename(chooser);
+        if (filename)
+        {
+            result = filename;
+            g_free(filename);
+        }
+    }
+
+    g_object_unref(native);
+    while (gtk_events_pending())
+        gtk_main_iteration();
+    return result;
+}
+
+std::string select_folder_dialog(const std::string &title, const std::string &initial_path)
+{
+    if (!gtk_init_check(nullptr, nullptr))
+    {
+        return "";
+    }
+
+    GtkFileChooserNative *native = gtk_file_chooser_native_new(
+        title.c_str(), nullptr, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "_Select", "_Cancel");
+
+    GtkFileChooser *chooser = GTK_FILE_CHOOSER(native);
+
+    if (!initial_path.empty() && std::filesystem::exists(initial_path))
+    {
+        gtk_file_chooser_set_current_folder(chooser, initial_path.c_str());
+    }
+
+    std::string result;
+    if (gtk_native_dialog_run(GTK_NATIVE_DIALOG(native)) == GTK_RESPONSE_ACCEPT)
+    {
+        char *filename = gtk_file_chooser_get_filename(chooser);
+        if (filename)
+        {
+            result = filename;
+            g_free(filename);
+        }
+    }
+
+    g_object_unref(native);
+    while (gtk_events_pending())
+        gtk_main_iteration();
+    return result;
+}
+
+} // namespace file_dialogs
+#endif
--- a/src/gui/platform/linux/font_loader_linux.cpp
+++ b/src/gui/platform/linux/font_loader_linux.cpp
@@ -0,0 +1,95 @@
+#ifdef __linux__
+
+#include "core/config/config.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "imgui_internal.h"
+#include <algorithm>
+#include <fontconfig/fontconfig.h>
+#include <imgui.h>
+
+std::string font_loader::find_font_linux(const char *font_name)
+{
+    FcInit();
+
+    FcPattern *pattern = FcNameParse(reinterpret_cast<const FcChar8 *>(font_name));
+    if (!pattern)
+        return {};
+
+    FcConfigSubstitute(nullptr, pattern, FcMatchPattern);
+    FcDefaultSubstitute(pattern);
+
+    FcResult result;
+    FcPattern *match = FcFontMatch(nullptr, pattern, &result);
+
+    std::string out;
+
+    if (match)
+    {
+        FcChar8 *file = nullptr;
+        if (FcPatternGetString(match, FC_FILE, 0, &file) == FcResultMatch)
+            out = reinterpret_cast<const char *>(file);
+
+        FcPatternDestroy(match);
+    }
+
+    FcPatternDestroy(pattern);
+    return out;
+}
+
+std::string font_loader::find_font_path(const char *font_name)
+{
+    return find_font_linux(font_name);
+}
+
+ImFont *font_loader::load_font(const char *font_name, float size_px)
+{
+    std::string path = find_font_path(font_name);
+    if (path.empty())
+        return nullptr;
+
+    float scale = ImGui::GetIO().DisplayFramebufferScale.y;
+    return ImGui::GetIO().Fonts->AddFontFromFileTTF(path.c_str(), size_px * scale);
+}
+
+void font_loader::push_default_font()
+{
+    ImGui::PushFont(ImGui::GetDefaultFont(), clrsync::core::config::instance().font_size());
+}
+
+void font_loader::pop_font()
+{
+    ImGui::PopFont();
+}
+
+std::vector<std::string> font_loader::get_system_fonts()
+{
+    std::vector<std::string> fonts;
+
+    FcInit();
+    FcPattern *pattern = FcPatternCreate();
+    FcObjectSet *os = FcObjectSetBuild(FC_FAMILY, nullptr);
+    FcFontSet *fs = FcFontList(nullptr, pattern, os);
+
+    if (fs)
+    {
+        for (int i = 0; i < fs->nfont; i++)
+        {
+            FcChar8 *family = nullptr;
+            if (FcPatternGetString(fs->fonts[i], FC_FAMILY, 0, &family) == FcResultMatch)
+            {
+                std::string font_name = reinterpret_cast<const char *>(family);
+                if (std::find(fonts.begin(), fonts.end(), font_name) == fonts.end())
+                    fonts.push_back(font_name);
+            }
+        }
+        FcFontSetDestroy(fs);
+    }
+
+    FcObjectSetDestroy(os);
+    FcPatternDestroy(pattern);
+
+    std::sort(fonts.begin(), fonts.end());
+    return fonts;
+}
+
+#endif
--- a/src/gui/platform/macos/file_browser_macos.mm
+++ b/src/gui/platform/macos/file_browser_macos.mm
@@ -0,0 +1,78 @@
+#ifdef __APPLE__
+#include "gui/platform/file_browser.hpp"
+#include <filesystem>
+#include <Cocoa/Cocoa.h>
+
+namespace file_dialogs {
+
+std::string open_file_dialog(const std::string& title, 
+                             const std::string& initial_path,
+                             const std::vector<std::string>& filters) {
+    @autoreleasepool {
+        NSOpenPanel* panel = [NSOpenPanel openPanel];
+        [panel setTitle:[NSString stringWithUTF8String:title.c_str()]];
+        [panel setCanChooseFiles:YES];
+        [panel setCanChooseDirectories:NO];
+        [panel setAllowsMultipleSelection:NO];
+        
+        if (!initial_path.empty()) {
+            NSURL* url = [NSURL fileURLWithPath:[NSString stringWithUTF8String:initial_path.c_str()]];
+            [panel setDirectoryURL:url];
+        }
+        
+        if ([panel runModal] == NSModalResponseOK) {
+            NSURL* url = [[panel URLs] objectAtIndex:0];
+            return std::string([[url path] UTF8String]);
+        }
+    }
+    return "";
+}
+
+std::string save_file_dialog(const std::string& title,
+                             const std::string& initial_path,
+                             const std::vector<std::string>& filters) {
+    @autoreleasepool {
+        NSSavePanel* panel = [NSSavePanel savePanel];
+        [panel setTitle:[NSString stringWithUTF8String:title.c_str()]];
+        
+        if (!initial_path.empty()) {
+            std::filesystem::path p(initial_path);
+            if (std::filesystem::exists(p.parent_path())) {
+                NSURL* url = [NSURL fileURLWithPath:[NSString stringWithUTF8String:p.parent_path().c_str()]];
+                [panel setDirectoryURL:url];
+                [panel setNameFieldStringValue:[NSString stringWithUTF8String:p.filename().c_str()]];
+            }
+        }
+        
+        if ([panel runModal] == NSModalResponseOK) {
+            NSURL* url = [panel URL];
+            return std::string([[url path] UTF8String]);
+        }
+    }
+    return "";
+}
+
+std::string select_folder_dialog(const std::string& title,
+                                 const std::string& initial_path) {
+    @autoreleasepool {
+        NSOpenPanel* panel = [NSOpenPanel openPanel];
+        [panel setTitle:[NSString stringWithUTF8String:title.c_str()]];
+        [panel setCanChooseFiles:NO];
+        [panel setCanChooseDirectories:YES];
+        [panel setAllowsMultipleSelection:NO];
+        
+        if (!initial_path.empty()) {
+            NSURL* url = [NSURL fileURLWithPath:[NSString stringWithUTF8String:initial_path.c_str()]];
+            [panel setDirectoryURL:url];
+        }
+        
+        if ([panel runModal] == NSModalResponseOK) {
+            NSURL* url = [[panel URLs] objectAtIndex:0];
+            return std::string([[url path] UTF8String]);
+        }
+    }
+    return "";
+}
+
+}
+#endif
--- a/src/gui/platform/macos/font_loader_macos.cpp
+++ b/src/gui/platform/macos/font_loader_macos.cpp
@@ -0,0 +1,115 @@
+#ifdef __APPLE__
+
+#include "core/config/config.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "imgui_internal.h"
+#include <CoreText/CoreText.h>
+#include <algorithm>
+#include <imgui.h>
+
+std::vector<unsigned char> font_loader::load_font_macos(const char *font_name)
+{
+    std::vector<unsigned char> out;
+
+    CFStringRef cf_name = CFStringCreateWithCString(nullptr, font_name, kCFStringEncodingUTF8);
+    if (!cf_name)
+        return out;
+
+    CTFontDescriptorRef desc = CTFontDescriptorCreateWithNameAndSize(cf_name, 12);
+    CFRelease(cf_name);
+
+    if (!desc)
+        return out;
+
+    CFURLRef url = (CFURLRef)CTFontDescriptorCopyAttribute(desc, kCTFontURLAttribute);
+    CFRelease(desc);
+
+    if (!url)
+        return out;
+
+    CFDataRef data = nullptr;
+    Boolean success = CFURLCreateDataAndPropertiesFromResource(kCFAllocatorDefault, url, &data,
+                                                               nullptr, nullptr, nullptr);
+    CFRelease(url);
+
+    if (success && data)
+    {
+        CFIndex size = CFDataGetLength(data);
+        if (size > 100)
+        {
+            out.resize(size);
+            CFDataGetBytes(data, CFRangeMake(0, size), out.data());
+        }
+        CFRelease(data);
+    }
+
+    return out;
+}
+
+std::string font_loader::find_font_path(const char *font_name)
+{
+    (void)font_name;
+    return {};
+}
+
+ImFont *font_loader::load_font(const char *font_name, float size_px)
+{
+    std::vector<unsigned char> buf = load_font_macos(font_name);
+    if (buf.empty())
+        return nullptr;
+
+    return ImGui::GetIO().Fonts->AddFontFromMemoryTTF(buf.data(), static_cast<int>(buf.size()),
+                                                      size_px);
+}
+
+void font_loader::push_default_font()
+{
+    ImGui::PushFont(ImGui::GetDefaultFont(), clrsync::core::config::instance().font_size());
+}
+
+void font_loader::pop_font()
+{
+    ImGui::PopFont();
+}
+
+std::vector<std::string> font_loader::get_system_fonts()
+{
+    std::vector<std::string> fonts;
+
+    CTFontCollectionRef collection = CTFontCollectionCreateFromAvailableFonts(nullptr);
+    if (collection)
+    {
+        CFArrayRef fontDescriptors = CTFontCollectionCreateMatchingFontDescriptors(collection);
+        CFRelease(collection);
+
+        if (fontDescriptors)
+        {
+            CFIndex count = CFArrayGetCount(fontDescriptors);
+            for (CFIndex i = 0; i < count; i++)
+            {
+                CTFontDescriptorRef descriptor =
+                    (CTFontDescriptorRef)CFArrayGetValueAtIndex(fontDescriptors, i);
+                CFStringRef fontName = (CFStringRef)CTFontDescriptorCopyAttribute(
+                    descriptor, kCTFontDisplayNameAttribute);
+
+                if (fontName)
+                {
+                    char buffer[256];
+                    if (CFStringGetCString(fontName, buffer, sizeof(buffer), kCFStringEncodingUTF8))
+                    {
+                        std::string font_name = buffer;
+                        if (std::find(fonts.begin(), fonts.end(), font_name) == fonts.end())
+                            fonts.push_back(font_name);
+                    }
+                    CFRelease(fontName);
+                }
+            }
+            CFRelease(fontDescriptors);
+        }
+    }
+
+    std::sort(fonts.begin(), fonts.end());
+    return fonts;
+}
+
+#endif
--- a/src/gui/platform/windows/file_browser_windows.cpp
+++ b/src/gui/platform/windows/file_browser_windows.cpp
@@ -0,0 +1,167 @@
+#ifdef _WIN32
+
+// clang-format off
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <commdlg.h>
+#include <shlobj.h>
+#include <shlwapi.h>
+// clang-format on
+
+#include "gui/platform/file_browser.hpp"
+#include <filesystem>
+
+namespace file_dialogs
+{
+
+std::string open_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    OPENFILENAMEA ofn;
+    char file[MAX_PATH] = "";
+
+    std::string filter_str = "All Files (*.*)\0*.*\0";
+
+    ZeroMemory(&ofn, sizeof(ofn));
+    ofn.lStructSize = sizeof(ofn);
+    ofn.hwndOwner = GetActiveWindow();
+    ofn.lpstrFile = file;
+    ofn.nMaxFile = sizeof(file);
+    ofn.lpstrFilter = filter_str.c_str();
+    ofn.nFilterIndex = 1;
+    ofn.lpstrTitle = title.c_str();
+    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
+
+    if (!initial_path.empty() && std::filesystem::exists(initial_path))
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::is_directory(p))
+        {
+            ofn.lpstrInitialDir = initial_path.c_str();
+        }
+        else
+        {
+            std::string dir = p.parent_path().string();
+            std::string name = p.filename().string();
+            ofn.lpstrInitialDir = dir.c_str();
+            strncpy(file, name.c_str(), sizeof(file) - 1);
+        }
+    }
+
+    if (GetOpenFileNameA(&ofn))
+    {
+        return std::string(file);
+    }
+    return "";
+}
+
+std::string save_file_dialog(const std::string &title, const std::string &initial_path,
+                             const std::vector<std::string> &filters)
+{
+    OPENFILENAMEA ofn;
+    char file[MAX_PATH] = "";
+
+    std::string filter_str = "All Files\0*.*\0\0";
+
+    ZeroMemory(&ofn, sizeof(ofn));
+    ofn.lStructSize = sizeof(ofn);
+    ofn.hwndOwner = GetActiveWindow();
+    ofn.lpstrFile = file;
+    ofn.nMaxFile = sizeof(file);
+    ofn.lpstrFilter = filter_str.c_str();
+    ofn.nFilterIndex = 1;
+    ofn.lpstrTitle = title.c_str();
+    ofn.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_NOCHANGEDIR;
+
+    if (!initial_path.empty())
+    {
+        std::filesystem::path p(initial_path);
+        if (std::filesystem::exists(p) && std::filesystem::is_directory(p))
+        {
+            ofn.lpstrInitialDir = initial_path.c_str();
+        }
+        else
+        {
+            std::string dir = p.parent_path().string();
+            std::string name = p.filename().string();
+            if (std::filesystem::exists(dir))
+            {
+                ofn.lpstrInitialDir = dir.c_str();
+                strncpy(file, name.c_str(), sizeof(file) - 1);
+            }
+        }
+    }
+
+    if (GetSaveFileNameA(&ofn))
+    {
+        return std::string(file);
+    }
+    return "";
+}
+
+std::string select_folder_dialog(const std::string &title, const std::string &initial_path)
+{
+    IFileOpenDialog *pFileOpen;
+
+    HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, NULL, CLSCTX_ALL, IID_IFileOpenDialog,
+                                  reinterpret_cast<void **>(&pFileOpen));
+
+    if (SUCCEEDED(hr))
+    {
+        DWORD dwFlags;
+        if (SUCCEEDED(pFileOpen->GetOptions(&dwFlags)))
+        {
+            pFileOpen->SetOptions(dwFlags | FOS_PICKFOLDERS);
+        }
+
+        std::wstring wtitle(title.begin(), title.end());
+        pFileOpen->SetTitle(wtitle.c_str());
+
+        if (!initial_path.empty() && std::filesystem::exists(initial_path))
+        {
+            IShellItem *psi = NULL;
+            std::wstring winitial(initial_path.begin(), initial_path.end());
+            hr = SHCreateItemFromParsingName(winitial.c_str(), NULL, IID_IShellItem, (void **)&psi);
+            if (SUCCEEDED(hr))
+            {
+                pFileOpen->SetFolder(psi);
+                psi->Release();
+            }
+        }
+
+        hr = pFileOpen->Show(GetActiveWindow());
+
+        if (SUCCEEDED(hr))
+        {
+            IShellItem *pItem;
+            hr = pFileOpen->GetResult(&pItem);
+            if (SUCCEEDED(hr))
+            {
+                PWSTR pszFilePath;
+                hr = pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszFilePath);
+
+                if (SUCCEEDED(hr))
+                {
+                    std::wstring wpath(pszFilePath);
+                    int size = WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, nullptr, 0,
+                                                   nullptr, nullptr);
+                    std::string result(size - 1, 0);
+                    WideCharToMultiByte(CP_UTF8, 0, wpath.c_str(), -1, &result[0], size, nullptr,
+                                        nullptr);
+                    CoTaskMemFree(pszFilePath);
+                    pItem->Release();
+                    pFileOpen->Release();
+                    return result;
+                }
+                pItem->Release();
+            }
+        }
+        pFileOpen->Release();
+    }
+
+    return "";
+}
+
+} // namespace file_dialogs
+
+#endif
--- a/src/gui/platform/windows/font_loader_windows.cpp
+++ b/src/gui/platform/windows/font_loader_windows.cpp
@@ -0,0 +1,170 @@
+#ifdef _WIN32
+#include "core/config/config.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "imgui_internal.h"
+#include <algorithm>
+#include <imgui.h>
+#include <windows.h>
+#include <winreg.h>
+
+static std::string search_registry_for_font(HKEY root_key, const char *subkey,
+                                            const std::string &font_name_lower,
+                                            const char *default_font_dir)
+{
+    HKEY hKey;
+    LONG result = RegOpenKeyExA(root_key, subkey, 0, KEY_READ, &hKey);
+
+    if (result != ERROR_SUCCESS)
+        return {};
+
+    char value_name[512];
+    BYTE value_data[512];
+    DWORD value_name_size, value_data_size, type;
+    DWORD index = 0;
+
+    std::string found_path;
+
+    while (true)
+    {
+        value_name_size = sizeof(value_name);
+        value_data_size = sizeof(value_data);
+
+        result = RegEnumValueA(hKey, index++, value_name, &value_name_size, nullptr, &type,
+                               value_data, &value_data_size);
+
+        if (result != ERROR_SUCCESS)
+            break;
+
+        if (type != REG_SZ)
+            continue;
+
+        std::string reg_font_name = value_name;
+        std::transform(reg_font_name.begin(), reg_font_name.end(), reg_font_name.begin(),
+                       ::tolower);
+
+        std::string reg_font_name_clean = reg_font_name;
+        size_t type_pos = reg_font_name_clean.find(" (");
+        if (type_pos != std::string::npos)
+            reg_font_name_clean = reg_font_name_clean.substr(0, type_pos);
+
+        if (reg_font_name_clean == font_name_lower)
+        {
+            std::string font_file = reinterpret_cast<char *>(value_data);
+
+            // If path is not absolute, prepend default font directory
+            if (font_file.find(":\\") == std::string::npos)
+            {
+                found_path = std::string(default_font_dir) + "\\" + font_file;
+            }
+            else
+            {
+                found_path = font_file;
+            }
+            break;
+        }
+    }
+
+    RegCloseKey(hKey);
+    return found_path;
+}
+
+std::string font_loader::find_font_windows(const char *font_name)
+{
+    std::string font_name_lower = font_name;
+    std::transform(font_name_lower.begin(), font_name_lower.end(), font_name_lower.begin(),
+                   ::tolower);
+
+    char windows_dir[MAX_PATH];
+    GetWindowsDirectoryA(windows_dir, MAX_PATH);
+    std::string system_fonts_dir = std::string(windows_dir) + "\\Fonts";
+
+    // First, try system-wide fonts (HKEY_LOCAL_MACHINE)
+    std::string path = search_registry_for_font(
+        HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
+        font_name_lower, system_fonts_dir.c_str());
+
+    if (!path.empty())
+        return path;
+
+    // If not found, try per-user fonts (HKEY_CURRENT_USER)
+    char local_appdata[MAX_PATH];
+    if (GetEnvironmentVariableA("LOCALAPPDATA", local_appdata, MAX_PATH) > 0)
+    {
+        std::string user_fonts_dir = std::string(local_appdata) + "\\Microsoft\\Windows\\Fonts";
+
+        path = search_registry_for_font(HKEY_CURRENT_USER,
+                                        "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts",
+                                        font_name_lower, user_fonts_dir.c_str());
+    }
+
+    return path;
+}
+
+std::string font_loader::find_font_path(const char *font_name)
+{
+    return find_font_windows(font_name);
+}
+
+ImFont *font_loader::load_font(const char *font_name, float size_px)
+{
+    std::string path = find_font_path(font_name);
+    if (path.empty())
+        return nullptr;
+
+    float scale = ImGui::GetIO().DisplayFramebufferScale.y;
+    return ImGui::GetIO().Fonts->AddFontFromFileTTF(path.c_str(), size_px * scale);
+}
+
+void font_loader::push_default_font()
+{
+    ImGui::PushFont(ImGui::GetDefaultFont(), clrsync::core::config::instance().font_size());
+}
+
+void font_loader::pop_font()
+{
+    ImGui::PopFont();
+}
+
+std::vector<std::string> font_loader::get_system_fonts()
+{
+    std::vector<std::string> fonts;
+
+    auto enumerate_registry_fonts = [&fonts](HKEY root_key, const char *subkey) {
+        HKEY hKey;
+        if (RegOpenKeyExA(root_key, subkey, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
+            return;
+
+        char value_name[512];
+        DWORD value_name_size;
+        DWORD index = 0;
+
+        while (true)
+        {
+            value_name_size = sizeof(value_name);
+            LONG result = RegEnumValueA(hKey, index++, value_name, &value_name_size, nullptr,
+                                        nullptr, nullptr, nullptr);
+
+            if (result != ERROR_SUCCESS)
+                break;
+
+            std::string font_name = value_name;
+            size_t pos = font_name.find(" (");
+            if (pos != std::string::npos)
+                font_name = font_name.substr(0, pos);
+
+            if (std::find(fonts.begin(), fonts.end(), font_name) == fonts.end())
+                fonts.push_back(font_name);
+        }
+
+        RegCloseKey(hKey);
+    };
+
+    enumerate_registry_fonts(HKEY_LOCAL_MACHINE,
+                             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts");
+    enumerate_registry_fonts(HKEY_CURRENT_USER,
+                             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts");
+
+    std::sort(fonts.begin(), fonts.end());
+    return fonts;
+}
+#endif
--- a/src/gui/settings_window.cpp
+++ b/src/gui/settings_window.cpp
@@ -1,201 +0,0 @@
-#include "settings_window.hpp"
-#include "core/config/config.hpp"
-#include "gui/font_loader.hpp"
-#include "imgui.h"
-#include <cstring>
-
-settings_window::settings_window()
-    : m_font_size(14)
-{
-    m_default_theme[0] = '\0';
-    m_palettes_path[0] = '\0';
-    m_font[0] = '\0';
-    load_settings();
-}
-
-void settings_window::render()
-{
-    if (!m_visible)
-        return;
-
-    ImGui::SetNextWindowSize(ImVec2(600, 400), ImGuiCond_FirstUseEver);
-    
-    if (ImGui::Begin("Settings", &m_visible))
-    {
-        ImGui::Text("General Settings");
-        ImGui::Separator();
-        ImGui::Spacing();
-        
-        ImGui::Text("Default Theme:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(300.0f);
-        ImGui::InputText("##default_theme", m_default_theme, sizeof(m_default_theme));
-        if (ImGui::IsItemHovered())
-        {
-            ImGui::SetTooltip("The default color scheme to load on startup");
-        }
-        
-        ImGui::Spacing();
-        
-        ImGui::Text("Palettes Path:");
-        ImGui::SetNextItemWidth(-FLT_MIN);
-        ImGui::InputText("##palettes_path", m_palettes_path, sizeof(m_palettes_path));
-        if (ImGui::IsItemHovered())
-        {
-            ImGui::SetTooltip("Directory where color palettes are stored\nSupports ~ for home directory");
-        }
-        
-        ImGui::Spacing();
-        
-        ImGui::Text("Font:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(300.0f);
-        ImGui::InputText("##font", m_font, sizeof(m_font));
-        if (ImGui::IsItemHovered())
-        {
-            ImGui::SetTooltip("Font");
-        }
-        
-        ImGui::Spacing();
-        
-        ImGui::Text("Font Size:");
-        ImGui::SameLine();
-        ImGui::SetNextItemWidth(100.0f);
-        ImGui::InputInt("##font_size", &m_font_size, 1, 1);
-        if (m_font_size < 8) m_font_size = 8;
-        if (m_font_size > 48) m_font_size = 48;
-        if (ImGui::IsItemHovered())
-        {
-            ImGui::SetTooltip("Font size");
-        }
-        
-        ImGui::Spacing();
-        ImGui::Spacing();
-        
-        if (!m_error_message.empty())
-        {
-            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f));
-            ImGui::TextWrapped("%s", m_error_message.c_str());
-            ImGui::PopStyleColor();
-            ImGui::Spacing();
-        }
-        
-        ImGui::Separator();
-        ImGui::Spacing();
-        
-        if (ImGui::Button("OK", ImVec2(120, 0)))
-        {
-            apply_settings();
-            m_visible = false;
-            m_error_message = "";
-        }
-        
-        ImGui::SameLine();
-        if (ImGui::Button("Apply", ImVec2(120, 0)))
-        {
-            apply_settings();
-        }
-        
-        ImGui::SameLine();
-        if (ImGui::Button("Reset to Defaults", ImVec2(150, 0)))
-        {
-            strncpy(m_default_theme, "dark", sizeof(m_default_theme));
-            strncpy(m_palettes_path, "~/.config/clrsync/palettes", sizeof(m_palettes_path));
-            strncpy(m_font, "JetBrains Mono Nerd Font", sizeof(m_font));
-            m_font_size = 14;
-            m_error_message = "";
-        }
-        
-        ImGui::SameLine();
-        if (ImGui::Button("Cancel", ImVec2(120, 0)))
-        {
-            load_settings();
-            m_visible = false;
-            m_error_message = "";
-        }
-    }
-    ImGui::End();
-}
-
-void settings_window::load_settings()
-{
-    try
-    {
-        auto& cfg = clrsync::core::config::instance();
-        
-        std::string default_theme = cfg.default_theme();
-        strncpy(m_default_theme, default_theme.c_str(), sizeof(m_default_theme) - 1);
-        m_default_theme[sizeof(m_default_theme) - 1] = '\0';
-        
-        std::string palettes_path = cfg.palettes_path();
-        strncpy(m_palettes_path, palettes_path.c_str(), sizeof(m_palettes_path) - 1);
-        m_palettes_path[sizeof(m_palettes_path) - 1] = '\0';
-        
-        std::string font = cfg.font();
-        strncpy(m_font, font.c_str(), sizeof(m_font) - 1);
-        m_font[sizeof(m_font) - 1] = '\0';
-        
-        m_font_size = cfg.font_size();
-        
-        m_error_message = "";
-    }
-    catch (const std::exception& e)
-    {
-        m_error_message = std::string("Failed to load settings: ") + e.what();
-        
-        // Set defaults on error
-        strncpy(m_default_theme, "dark", sizeof(m_default_theme));
-        strncpy(m_palettes_path, "~/.config/clrsync/palettes", sizeof(m_palettes_path));
-        strncpy(m_font, "JetBrains Mono Nerd Font", sizeof(m_font));
-        m_font_size = 14;
-    }
-}
-
-void settings_window::apply_settings()
-{
-    try
-    {
-        auto& cfg = clrsync::core::config::instance();
-        
-        if (strlen(m_default_theme) == 0)
-        {
-            m_error_message = "Default theme cannot be empty";
-            return;
-        }
-        
-        if (strlen(m_palettes_path) == 0)
-        {
-            m_error_message = "Palettes path cannot be empty";
-            return;
-        }
-        
-        if (strlen(m_font) == 0)
-        {
-            m_error_message = "Font cannot be empty";
-            return;
-        }
-        
-        if (m_font_size < 8 || m_font_size > 48)
-        {
-            m_error_message = "Font size must be between 8 and 48";
-            return;
-        }
-        
-        cfg.set_default_theme(m_default_theme);
-        cfg.set_palettes_path(m_palettes_path);
-        cfg.set_font(m_font);
-        cfg.set_font_size(m_font_size);
-
-
-        font_loader fn_loader;
-        auto font = fn_loader.load_font(m_font, m_font_size);
-        if (font)
-            ImGui::GetIO().FontDefault = font;
-        
-        m_error_message = "";
-    }
-    catch (const std::exception& e)
-    {
-        m_error_message = std::string("Failed to apply settings: ") + e.what();
-    }
-}
--- a/src/gui/settings_window.hpp
+++ b/src/gui/settings_window.hpp
@@ -1,30 +0,0 @@
-#ifndef CLRSYNC_GUI_SETTINGS_WINDOW_HPP
-#define CLRSYNC_GUI_SETTINGS_WINDOW_HPP
-
-#include <string>
-
-class settings_window
-{
-public:
-    settings_window();
-    void render();
-    void show() { m_visible = true; }
-    void hide() { m_visible = false; }
-    bool is_visible() const { return m_visible; }
-
-private:
-    void load_settings();
-    void save_settings();
-    void apply_settings();
-
-    bool m_visible{false};
-    
-    char m_default_theme[128];
-    char m_palettes_path[512];
-    char m_font[128];
-    int m_font_size;
-    
-    std::string m_error_message;
-};
-
-#endif // CLRSYNC_GUI_SETTINGS_WINDOW_HPP
--- a/src/gui/template_controller.cpp
+++ b/src/gui/template_controller.cpp
@@ -1,39 +0,0 @@
-#include "template_controller.hpp"
-#include "core/config/config.hpp"
-
-template_controller::template_controller()
-{
-    m_templates = m_template_manager.templates();
-}
-
-void template_controller::set_template_enabled(const std::string& key, bool enabled)
-{
-    auto it = m_templates.find(key);
-    if (it != m_templates.end()) {
-        it->second.set_enabled(enabled);
-        clrsync::core::config::instance().update_template(key, it->second);
-    }
-}
-
-void template_controller::set_template_output_path(const std::string& key, const std::string& path)
-{
-    auto it = m_templates.find(key);
-    if (it != m_templates.end()) {
-        it->second.set_output_path(path);
-        clrsync::core::config::instance().update_template(key, it->second);
-    }
-}
-
-void template_controller::set_template_reload_command(const std::string& key, const std::string& cmd)
-{
-    auto it = m_templates.find(key);
-    if (it != m_templates.end()) {
-        it->second.set_reload_command(cmd);
-        clrsync::core::config::instance().update_template(key, it->second);
-    }
-}
-
-void template_controller::refresh()
-{
-    m_templates = m_template_manager.templates();
-}
--- a/src/gui/template_editor.cpp
+++ b/src/gui/template_editor.cpp
@@ -1,457 +0,0 @@
-#include "template_editor.hpp"
-#include "core/config/config.hpp"
-#include "core/theme/theme_template.hpp"
-#include "imgui.h"
-#include <filesystem>
-#include <fstream>
-#include <ranges>
-
-template_editor::template_editor() : m_template_name("new_template")
-{
-    TextEditor::LanguageDefinition lang;
-    lang.mName = "Template";
-
-    lang.mCommentStart = "/*";
-    lang.mCommentEnd = "*/";
-    lang.mSingleLineComment = "#";
-
-    lang.mTokenRegexStrings.push_back(std::make_pair<std::string, TextEditor::PaletteIndex>(
-        "\\{[a-zA-Z_][a-zA-Z0-9_]*(\\.[a-zA-Z_][a-zA-Z0-9_]*)?\\}",
-        TextEditor::PaletteIndex::KnownIdentifier));
-
-    lang.mTokenRegexStrings.push_back(std::make_pair<std::string, TextEditor::PaletteIndex>(
-        "\"([^\"]*)\"", TextEditor::PaletteIndex::String));
-    lang.mTokenRegexStrings.push_back(std::make_pair<std::string, TextEditor::PaletteIndex>(
-        "'([^']*)'", TextEditor::PaletteIndex::String));
-
-    m_editor.SetLanguageDefinition(lang);
-    m_editor.SetText("# Enter your template here\n# Use {color_key} for color variables\n# "
-                     "Examples: {color.hex}, {color.rgb}, {color.r}\n\n");
-    m_editor.SetShowWhitespaces(false);
-}
-
-void template_editor::apply_current_palette(const clrsync::core::palette &pal)
-{
-    auto colors = pal.colors();
-    if (colors.empty())
-        return;
-    auto get_color_u32 = [&](const std::string &key, const std::string &fallback = "") -> uint32_t {
-        auto it = colors.find(key);
-        if (it == colors.end() && !fallback.empty())
-        {
-            it = colors.find(fallback);
-        }
-
-        if (it != colors.end())
-        {
-            const auto &col = it->second;
-            const uint32_t hex = col.hex();
-            // Convert from RRGGBBAA to AABBGGRR (ImGui format)
-            const uint32_t r = (hex >> 24) & 0xFF;
-            const uint32_t g = (hex >> 16) & 0xFF;
-            const uint32_t b = (hex >> 8) & 0xFF;
-            const uint32_t a = hex & 0xFF;
-            return (a << 24) | (b << 16) | (g << 8) | r;
-        }
-        return 0xFFFFFFFF;
-    };
-
-    auto palette = m_editor.GetPalette();
-
-    palette[int(TextEditor::PaletteIndex::Default)] = get_color_u32("editor_main", "foreground");
-    palette[int(TextEditor::PaletteIndex::Keyword)] = get_color_u32("editor_command", "accent");
-    palette[int(TextEditor::PaletteIndex::Number)] = get_color_u32("editor_warning", "warning");
-    palette[int(TextEditor::PaletteIndex::String)] = get_color_u32("editor_string", "success");
-    palette[int(TextEditor::PaletteIndex::CharLiteral)] = get_color_u32("editor_string", "success");
-    palette[int(TextEditor::PaletteIndex::Punctuation)] =
-        get_color_u32("editor_main", "foreground");
-    palette[int(TextEditor::PaletteIndex::Preprocessor)] =
-        get_color_u32("editor_emphasis", "accent");
-    palette[int(TextEditor::PaletteIndex::Identifier)] = get_color_u32("editor_main", "foreground");
-    palette[int(TextEditor::PaletteIndex::KnownIdentifier)] = get_color_u32("editor_link", "info");
-    palette[int(TextEditor::PaletteIndex::PreprocIdentifier)] =
-        get_color_u32("editor_link", "info");
-
-    palette[int(TextEditor::PaletteIndex::Comment)] =
-        get_color_u32("editor_comment", "editor_inactive");
-    palette[int(TextEditor::PaletteIndex::MultiLineComment)] =
-        get_color_u32("editor_comment", "editor_inactive");
-
-    palette[int(TextEditor::PaletteIndex::Background)] =
-        get_color_u32("editor_background", "background");
-    palette[int(TextEditor::PaletteIndex::Cursor)] = get_color_u32("cursor", "accent");
-
-    palette[int(TextEditor::PaletteIndex::Selection)] =
-        get_color_u32("editor_selected", "surface_variant");
-    palette[int(TextEditor::PaletteIndex::ErrorMarker)] = get_color_u32("editor_error", "error");
-    palette[int(TextEditor::PaletteIndex::Breakpoint)] = get_color_u32("editor_error", "error");
-
-    palette[int(TextEditor::PaletteIndex::LineNumber)] =
-        get_color_u32("editor_line_number", "editor_inactive");
-    palette[int(TextEditor::PaletteIndex::CurrentLineFill)] = get_color_u32("surface_variant");
-    palette[int(TextEditor::PaletteIndex::CurrentLineFillInactive)] = get_color_u32("surface");
-
-    palette[int(TextEditor::PaletteIndex::CurrentLineEdge)] =
-        get_color_u32("border_focused", "border");
-
-    m_editor.SetPalette(palette);
-}
-
-void template_editor::render()
-{
-    ImGui::Begin("Templates");
-
-    render_controls();
-    ImGui::Separator();
-
-    const float panel_width = ImGui::GetContentRegionAvail().x;
-    constexpr float left_panel_width = 200.0f;
-    const float right_panel_width = panel_width - left_panel_width - 10;
-
-    ImGui::BeginChild("TemplateList", ImVec2(left_panel_width, 0), true);
-    render_template_list();
-    ImGui::EndChild();
-
-    ImGui::SameLine();
-
-    ImGui::BeginChild("EditorPanel", ImVec2(right_panel_width, 0), false);
-    render_editor();
-    ImGui::EndChild();
-
-    ImGui::End();
-}
-
-void template_editor::render_controls()
-{
-    if (ImGui::Button("New Template"))
-    {
-        new_template();
-    }
-
-    if (ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows) &&
-        ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyPressed(ImGuiKey_S))
-    {
-        save_template();
-    }
-
-    ImGui::SameLine();
-    if (ImGui::Button("Save"))
-    {
-        save_template();
-    }
-
-    ImGui::SameLine();
-    ImGui::Text("Template Name:");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(150.0f);
-    char name_buf[256] = {0};
-    snprintf(name_buf, sizeof(name_buf), "%s", m_template_name.c_str());
-    if (ImGui::InputText("##template_name", name_buf, sizeof(name_buf)))
-    {
-        m_template_name = name_buf;
-        if (!m_template_name.empty())
-        {
-            m_validation_error = "";
-        }
-    }
-
-    ImGui::SameLine();
-    if (ImGui::Checkbox("Enabled", &m_enabled))
-    {
-        if (m_is_editing_existing)
-        {
-            m_template_controller.set_template_enabled(m_template_name, m_enabled);
-        }
-    }
-
-    ImGui::Text("Output Path:");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(-FLT_MIN);
-    char path_buf[512] = {0};
-    snprintf(path_buf, sizeof(path_buf), "%s", m_output_path.c_str());
-    if (ImGui::InputText("##output_path", path_buf, sizeof(path_buf)))
-    {
-        m_output_path = path_buf;
-        if (!m_output_path.empty())
-        {
-            m_validation_error = "";
-        }
-        if (m_is_editing_existing)
-        {
-            m_template_controller.set_template_output_path(m_template_name, m_output_path);
-        }
-    }
-
-    ImGui::Text("Reload Command:");
-    ImGui::SameLine();
-    ImGui::SetNextItemWidth(-FLT_MIN);
-    char reload_buf[512] = {0};
-    snprintf(reload_buf, sizeof(reload_buf), "%s", m_reload_command.c_str());
-    if (ImGui::InputText("##reload_cmd", reload_buf, sizeof(reload_buf)))
-    {
-        m_reload_command = reload_buf;
-        if (m_is_editing_existing)
-        {
-            m_template_controller.set_template_reload_command(m_template_name, m_reload_command);
-        }
-    }
-
-    if (!m_validation_error.empty())
-    {
-        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.3f, 0.3f, 1.0f));
-        ImGui::TextWrapped("%s", m_validation_error.c_str());
-        ImGui::PopStyleColor();
-    }
-}
-
-void template_editor::render_editor()
-{
-    if (!m_is_editing_existing)
-    {
-        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.4f, 0.8f, 0.4f, 1.0f));
-        ImGui::Text("New Template");
-        ImGui::PopStyleColor();
-    }
-    else
-    {
-        ImGui::Text("%s", m_template_name.c_str());
-        auto trim_right = [](const std::string &s) -> std::string {
-            size_t end = s.find_last_not_of("\r\n");
-            return (end == std::string::npos) ? "" : s.substr(0, end + 1);
-        };
-
-        std::string current_content = trim_right(m_editor.GetText());
-        std::string saved_content = trim_right(m_saved_content);
-
-        m_has_unsaved_changes = (current_content != saved_content);
-        if (m_has_unsaved_changes)
-        {
-            ImGui::SameLine();
-            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.6f, 0.2f, 1.0f));
-            ImGui::Text("●");
-            ImGui::PopStyleColor();
-        }
-    }
-
-    ImGui::Separator();
-
-    m_editor.Render("##TemplateEditor", ImVec2(0, 0), true);
-}
-
-void template_editor::render_template_list()
-{
-    ImGui::Text("Templates");
-    ImGui::Separator();
-
-    if (!m_is_editing_existing)
-    {
-        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.4f, 0.8f, 0.4f, 1.0f));
-        ImGui::Selectable("* New Template *", true);
-        ImGui::PopStyleColor();
-        ImGui::Separator();
-    }
-
-    const auto &templates = m_template_controller.templates();
-
-    for (const auto &key : templates | std::views::keys)
-    {
-        const bool selected = (m_template_name == key && m_is_editing_existing);
-        if (ImGui::Selectable(key.c_str(), selected))
-        {
-            load_template(key);
-        }
-    }
-}
-
-bool template_editor::is_valid_path(const std::string &path)
-{
-    const std::string invalid_chars = "<>|\"";
-    for (const char c : invalid_chars)
-    {
-        if (path.find(c) != std::string::npos)
-        {
-            return false;
-        }
-    }
-
-    if (path.find_first_not_of(" \t\n\r./\\") == std::string::npos)
-    {
-        return false;
-    }
-
-    try
-    {
-        std::filesystem::path fs_path(path);
-
-        const auto parent = fs_path.parent_path();
-
-        if (parent.empty())
-        {
-            return false;
-        }
-
-        if (!parent.empty() && !std::filesystem::exists(parent))
-        {
-            if (parent.string().find_first_of("<>|\"") != std::string::npos)
-            {
-                return false;
-            }
-        }
-
-        const auto filename = fs_path.filename().string();
-        if (filename.empty() || filename == "." || filename == "..")
-        {
-            return false;
-        }
-
-        return true;
-    }
-    catch (...)
-    {
-        return false;
-    }
-}
-
-void template_editor::save_template()
-{
-    std::string trimmed_name = m_template_name;
-    trimmed_name.erase(0, trimmed_name.find_first_not_of(" \t\n\r"));
-    trimmed_name.erase(trimmed_name.find_last_not_of(" \t\n\r") + 1);
-
-    std::string trimmed_path = m_output_path;
-    trimmed_path.erase(0, trimmed_path.find_first_not_of(" \t\n\r"));
-    trimmed_path.erase(trimmed_path.find_last_not_of(" \t\n\r") + 1);
-
-    if (trimmed_name.empty())
-    {
-        m_validation_error = "Error: Template name cannot be empty!";
-        return;
-    }
-
-    if (trimmed_path.empty())
-    {
-        m_validation_error = "Error: Output path cannot be empty!";
-        return;
-    }
-
-    if (!is_valid_path(trimmed_path))
-    {
-        m_validation_error =
-            "Error: Output path is invalid! Must be a valid file path with directory.";
-        return;
-    }
-
-    m_validation_error = "";
-
-    try
-    {
-        auto &cfg = clrsync::core::config::instance();
-        std::string palettes_path = cfg.palettes_path();
-        std::filesystem::path templates_dir =
-            std::filesystem::path(palettes_path).parent_path() / "templates";
-
-        if (!std::filesystem::exists(templates_dir))
-        {
-            std::filesystem::create_directories(templates_dir);
-        }
-
-        std::filesystem::path template_file;
-        if (m_is_editing_existing)
-        {
-            const auto &existing_template = cfg.template_by_name(trimmed_name);
-            template_file = existing_template.template_path();
-        }
-        else
-        {
-            template_file = templates_dir / trimmed_name;
-        }
-
-        std::string template_content = m_editor.GetText();
-
-        std::ofstream out(template_file);
-        if (out.is_open())
-        {
-            out << template_content;
-            out.close();
-        }
-
-        clrsync::core::theme_template tmpl(trimmed_name, template_file.string(), trimmed_path);
-        tmpl.set_reload_command(m_reload_command);
-        tmpl.set_enabled(m_enabled);
-
-        cfg.update_template(trimmed_name, tmpl);
-
-        m_template_name = trimmed_name;
-        m_output_path = trimmed_path;
-        m_is_editing_existing = true;
-        m_saved_content = m_editor.GetText();
-        m_has_unsaved_changes = false;
-
-        refresh_templates();
-    }
-    catch (const std::exception &e)
-    {
-        m_validation_error = std::string("Error saving template: ") + e.what();
-    }
-}
-
-void template_editor::load_template(const std::string &name)
-{
-    const auto &templates = m_template_controller.templates();
-    auto it = templates.find(name);
-
-    if (it != templates.end())
-    {
-        const auto &tmpl = it->second;
-        m_template_name = name;
-        m_output_path = tmpl.output_path();
-        m_reload_command = tmpl.reload_command();
-        m_enabled = tmpl.enabled();
-        m_is_editing_existing = true;
-        m_validation_error = "";
-
-        try
-        {
-            std::ifstream in(tmpl.template_path());
-            if (in.is_open())
-            {
-                std::string content;
-                std::string line;
-                while (std::getline(in, line))
-                {
-                    content += line + "\n";
-                }
-                in.close();
-
-                m_editor.SetText(content);
-                m_saved_content = content;
-                m_has_unsaved_changes = false;
-            }
-        }
-        catch (const std::exception &e)
-        {
-            m_validation_error = std::string("Error loading template: ") + e.what();
-        }
-    }
-}
-
-void template_editor::new_template()
-{
-    m_template_name = "new_template";
-    std::string default_content =
-        "# Enter your template here\n# Use {color_key} for color variables\n# "
-        "Examples: {color.hex}, {color.rgb}, {color.r}\n\n";
-    m_editor.SetText(default_content);
-    m_saved_content = default_content;
-    m_output_path = "";
-    m_reload_command = "";
-    m_enabled = true;
-    m_is_editing_existing = false;
-    m_validation_error = "";
-    m_has_unsaved_changes = false;
-}
-
-void template_editor::refresh_templates()
-{
-    m_template_controller.refresh();
-}
--- a/src/gui/template_editor.hpp
+++ b/src/gui/template_editor.hpp
@@ -1,42 +0,0 @@
-#ifndef CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
-#define CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
-
-#include "template_controller.hpp"
-#include <core/palette/palette.hpp>
-#include "color_text_edit/TextEditor.h"
-#include <string>
-
-class template_editor
-{
-public:
-    template_editor();
-    void render();
-    void apply_current_palette(const clrsync::core::palette& pal);
-
-private:
-    void render_controls();
-    void render_editor();
-    void render_template_list();
-
-    void save_template();
-    void load_template(const std::string &name);
-    void new_template();
-    void refresh_templates();
-
-    bool is_valid_path(const std::string &path);
-
-    template_controller m_template_controller;
-    TextEditor m_editor;
-    
-    std::string m_template_name;
-    std::string m_output_path;
-    std::string m_reload_command;
-    std::string m_validation_error;
-    std::string m_saved_content;
-    bool m_has_unsaved_changes = false;
-    
-    bool m_enabled{true};
-    bool m_is_editing_existing{false};
-};
-
-#endif // CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
--- a/src/gui/ui_manager.cpp
+++ b/src/gui/ui_manager.cpp
@@ -0,0 +1,71 @@
+#include "gui/ui_manager.hpp"
+#include "gui/backend/backend.hpp"
+
+#include <imgui.h>
+
+namespace clrsync::gui
+{
+ui_manager::ui_manager(backend::backend_interface* backend)
+    : m_backend(backend)
+{
+}
+
+ui_manager::~ui_manager()
+{
+    shutdown();
+}
+
+bool ui_manager::initialize(const ui_config& config)
+{
+    IMGUI_CHECKVERSION();
+    m_imgui_context = ImGui::CreateContext();
+    if (!m_imgui_context)
+    {
+        return false;
+    }
+
+    ImGuiIO& io = ImGui::GetIO();
+    
+    if (config.enable_docking)
+        io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    
+    if (config.enable_keyboard_nav)
+        io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
+    
+    if (!config.ini_path.empty())
+        io.IniFilename = config.ini_path.c_str();
+
+    ImGui::StyleColorsDark();
+
+    if (!m_backend->init_imgui_backend())
+    {
+        ImGui::DestroyContext(static_cast<ImGuiContext*>(m_imgui_context));
+        m_imgui_context = nullptr;
+        return false;
+    }
+
+    return true;
+}
+
+void ui_manager::shutdown()
+{
+    if (m_imgui_context)
+    {
+        m_backend->shutdown_imgui_backend();
+        ImGui::DestroyContext(static_cast<ImGuiContext*>(m_imgui_context));
+        m_imgui_context = nullptr;
+    }
+}
+
+void ui_manager::begin_frame()
+{
+    m_backend->imgui_new_frame();
+    ImGui::NewFrame();
+}
+
+void ui_manager::end_frame()
+{
+    ImGui::Render();
+    m_backend->imgui_render_draw_data(ImGui::GetDrawData());
+}
+}
--- a/src/gui/ui_manager.hpp
+++ b/src/gui/ui_manager.hpp
@@ -0,0 +1,38 @@
+#ifndef CLRSYNC_UI_MANAGER_HPP
+#define CLRSYNC_UI_MANAGER_HPP
+#include <string>
+
+namespace clrsync::gui::backend
+{
+class backend_interface;
+}
+
+namespace clrsync::gui
+{
+
+struct ui_config
+{
+    std::string ini_path = "";
+    bool enable_docking = true;
+    bool enable_keyboard_nav = true;
+};
+
+class ui_manager
+{
+public:
+    explicit ui_manager(backend::backend_interface *backend);
+    ~ui_manager();
+
+    bool initialize(const ui_config& config = ui_config());
+    void shutdown();
+
+    void begin_frame();
+    void end_frame();
+
+private:
+    backend::backend_interface *m_backend;
+    void *m_imgui_context = nullptr;
+};
+}
+
+#endif
--- a/src/gui/views/about_window.cpp
+++ b/src/gui/views/about_window.cpp
@@ -1,12 +1,13 @@
-#include "about_window.hpp"
-#include "core/version.hpp"
+#include "gui/views/about_window.hpp"
+#include "core/common/version.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
 #include "imgui.h"

 about_window::about_window()
 {
 }

-void about_window::render()
+void about_window::render(const clrsync::core::palette &pal)
 {
    if (!m_visible)
        return;
@@ -18,24 +19,24 @@ void about_window::render()
        const float window_width = ImGui::GetContentRegionAvail().x;

        ImGui::PushFont(ImGui::GetFont());
-        const char* title = "clrsync";
+        const char *title = "clrsync";
        const float title_size = ImGui::CalcTextSize(title).x;
        ImGui::SetCursorPosX((window_width - title_size) * 0.5f);
-        ImGui::TextColored(ImVec4(0.4f, 0.8f, 1.0f, 1.0f), "%s", title);
+        ImVec4 title_color = palette_utils::get_color(pal, "info", "accent");
+        ImGui::TextColored(title_color, "%s", title);
        ImGui::PopFont();

        std::string version = "Version " + clrsync::core::version_string();
        const float version_size = ImGui::CalcTextSize(version.c_str()).x;
        ImGui::SetCursorPosX((window_width - version_size) * 0.5f);
-        ImGui::TextColored(ImVec4(0.7f, 0.7f, 0.7f, 1.0f), "%s", version.c_str());
+        ImVec4 subtitle_color = palette_utils::get_color(pal, "editor_inactive", "foreground");
+        ImGui::TextColored(subtitle_color, "%s", version.c_str());

        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Spacing();

-        ImGui::TextWrapped(
-            "A color scheme management tool."
-        );
+        ImGui::TextWrapped("A color scheme management tool.");

        ImGui::Spacing();
        ImGui::Spacing();
@@ -45,24 +46,41 @@ void about_window::render()

        ImGui::Text("Links:");

-        if (ImGui::Button("GitHub Repository", ImVec2(200, 0)))
+        const float button_width = 200.0f;
+        const float spacing = ImGui::GetStyle().ItemSpacing.x;
+        const float total_width = 2.0f * button_width + spacing;
+        ImGui::SetCursorPosX((window_width - total_width) * 0.5f);
+
+        if (ImGui::Button("GitHub Repository", ImVec2(button_width, 0)))
        {
-            #ifdef _WIN32
+#ifdef _WIN32
            system("start https://github.com/obsqrbtz/clrsync");
-            #elif __APPLE__
+#elif __APPLE__
            system("open https://github.com/obsqrbtz/clrsync");
-            #else
+#else
            system("xdg-open https://github.com/obsqrbtz/clrsync");
-            #endif
+#endif
        }
        ImGui::SameLine();

+        if (ImGui::Button("Documentation", ImVec2(button_width, 0)))
+        {
+#ifdef _WIN32
+            system("start https://binarygoose.dev/projects/clrsync/overview/");
+#elif __APPLE__
+            system("open https://binarygoose.dev/projects/clrsync/overview/");
+#else
+            system("xdg-open https://binarygoose.dev/projects/clrsync/overview/");
+#endif
+        }
+
        ImGui::Spacing();
        ImGui::Spacing();
        ImGui::Separator();
        ImGui::Spacing();

-        ImGui::TextColored(ImVec4(0.6f, 0.6f, 0.6f, 1.0f), "MIT License");
+        ImVec4 license_color = palette_utils::get_color(pal, "editor_inactive", "foreground");
+        ImGui::TextColored(license_color, "MIT License");
        ImGui::TextWrapped(
            "Copyright (c) 2025 Daniel Dada\n\n"
            "Permission is hereby granted, free of charge, to any person obtaining a copy "
@@ -72,18 +90,7 @@ void about_window::render()
            "copies of the Software, and to permit persons to whom the Software is "
            "furnished to do so, subject to the following conditions:\n\n"
            "The above copyright notice and this permission notice shall be included in all "
-            "copies or substantial portions of the Software."
-        );
-        
-        ImGui::Spacing();
-        ImGui::Spacing();
-        
-        const float button_width = 120.0f;
-        ImGui::SetCursorPosX((window_width - button_width) * 0.5f);
-        if (ImGui::Button("Close", ImVec2(button_width, 0)))
-        {
-            m_visible = false;
-        }
+            "copies or substantial portions of the Software.");
    }
    ImGui::End();
 }
--- a/src/gui/views/about_window.hpp
+++ b/src/gui/views/about_window.hpp
@@ -0,0 +1,33 @@
+#ifndef CLRSYNC_GUI_ABOUT_WINDOW_HPP
+#define CLRSYNC_GUI_ABOUT_WINDOW_HPP
+
+#include "core/palette/palette.hpp"
+
+class about_window
+{
+  public:
+    about_window();
+    void render(const clrsync::core::palette &pal);
+    void render()
+    {
+        render(m_default_palette);
+    }
+    void show()
+    {
+        m_visible = true;
+    }
+    void hide()
+    {
+        m_visible = false;
+    }
+    bool is_visible() const
+    {
+        return m_visible;
+    }
+
+  private:
+    bool m_visible{false};
+    clrsync::core::palette m_default_palette;
+};
+
+#endif // CLRSYNC_GUI_ABOUT_WINDOW_HPP
--- a/src/gui/views/color_scheme_editor.cpp
+++ b/src/gui/views/color_scheme_editor.cpp
@@ -0,0 +1,201 @@
+#include "color_scheme_editor.hpp"
+#include "gui/controllers/theme_applier.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
+#include "imgui.h"
+#include "settings_window.hpp"
+#include "template_editor.hpp"
+#include <iostream>
+#include <ranges>
+
+color_scheme_editor::color_scheme_editor()
+{
+    const auto &current = m_controller.current_palette();
+
+    if (!current.colors().empty())
+    {
+        theme_applier::apply_to_imgui(current);
+        m_preview.apply_palette(current);
+    }
+    else
+    {
+        std::cout << "WARNING: No palette loaded, skipping theme application\n";
+    }
+}
+
+void color_scheme_editor::notify_palette_changed()
+{
+    if (m_template_editor)
+    {
+        m_template_editor->apply_current_palette(m_controller.current_palette());
+    }
+    if (m_settings_window)
+    {
+        m_settings_window->set_palette(m_controller.current_palette());
+    }
+}
+
+void color_scheme_editor::apply_themes()
+{
+    const auto &current = m_controller.current_palette();
+    theme_applier::apply_to_imgui(current);
+    m_preview.apply_palette(current);
+    notify_palette_changed();
+}
+
+void color_scheme_editor::render_controls_and_colors()
+{
+    ImGui::Begin("Color Schemes");
+
+    render_controls();
+    ImGui::Separator();
+
+    ImGui::BeginChild("ColorTableContent", ImVec2(0, 0), false);
+    m_color_table.render(m_controller.current_palette(), m_controller,
+                         [this]() { apply_themes(); });
+    ImGui::EndChild();
+
+    ImGui::End();
+}
+
+void color_scheme_editor::render_preview()
+{
+    ImGui::Begin("Color Preview");
+
+    m_preview.render(m_controller.current_palette());
+
+    ImGui::End();
+}
+
+void color_scheme_editor::render_controls()
+{
+    const auto &current = m_controller.current_palette();
+    const auto &palettes = m_controller.palettes();
+
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(6, 8));
+    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(8, 5));
+
+    ImGui::AlignTextToFramePadding();
+    ImGui::Text("Palette:");
+    ImGui::SameLine();
+
+    ImGui::SetNextItemWidth(200.0f);
+    if (ImGui::BeginCombo("##scheme", current.name().c_str()))
+    {
+        for (const auto &name : palettes | std::views::keys)
+        {
+            const bool selected = current.name() == name;
+            if (ImGui::Selectable(name.c_str(), selected))
+            {
+                m_controller.select_palette(name);
+                apply_themes();
+            }
+            if (selected)
+                ImGui::SetItemDefaultFocus();
+        }
+        ImGui::EndCombo();
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Select a color palette to edit");
+
+    ImGui::SameLine();
+    ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 8);
+
+    static char new_palette_name_buf[128] = "";
+    if (ImGui::Button(" + New "))
+    {
+        new_palette_name_buf[0] = 0;
+        ImGui::OpenPopup("New Palette");
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Create a new palette");
+
+    if (ImGui::BeginPopupModal("New Palette", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
+    {
+        ImGui::Text("Enter a name for the new palette:");
+        ImGui::Spacing();
+
+        ImGui::SetNextItemWidth(250);
+        ImGui::InputTextWithHint("##new_palette_input", "Palette name...", new_palette_name_buf,
+                                 IM_ARRAYSIZE(new_palette_name_buf));
+
+        ImGui::Spacing();
+        ImGui::Separator();
+        ImGui::Spacing();
+
+        bool can_create = strlen(new_palette_name_buf) > 0;
+
+        if (!can_create)
+            ImGui::BeginDisabled();
+
+        if (ImGui::Button("Create", ImVec2(120, 0)))
+        {
+            m_controller.create_palette(new_palette_name_buf);
+            m_controller.select_palette(new_palette_name_buf);
+            apply_themes();
+            new_palette_name_buf[0] = 0;
+            ImGui::CloseCurrentPopup();
+        }
+
+        if (!can_create)
+            ImGui::EndDisabled();
+
+        ImGui::SameLine();
+
+        if (ImGui::Button("Cancel", ImVec2(120, 0)))
+        {
+            new_palette_name_buf[0] = 0;
+            ImGui::CloseCurrentPopup();
+        }
+
+        ImGui::EndPopup();
+    }
+
+    ImGui::SameLine();
+    if (ImGui::Button(" Save "))
+    {
+        m_controller.save_current_palette();
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Save current palette to file");
+
+    ImGui::SameLine();
+    auto error = palette_utils::get_color(current, "error");
+    auto error_hover = ImVec4(error.x * 1.1f, error.y * 1.1f, error.z * 1.1f, error.w);
+    auto error_active = ImVec4(error.x * 0.8f, error.y * 0.8f, error.z * 0.8f, error.w);
+    auto on_error = palette_utils::get_color(current, "on_error");
+    ImGui::PushStyleColor(ImGuiCol_Button, error);
+    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, error_hover);
+    ImGui::PushStyleColor(ImGuiCol_ButtonActive, error_active);
+    ImGui::PushStyleColor(ImGuiCol_Text, on_error);
+    if (ImGui::Button(" Delete "))
+    {
+        m_show_delete_confirmation = true;
+    }
+    ImGui::PopStyleColor(4);
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Delete current palette");
+
+    if (m_show_delete_confirmation)
+    {
+        ImGui::OpenPopup("Delete Palette?");
+        m_show_delete_confirmation = false;
+    }
+
+    palette_utils::render_delete_confirmation_popup("Delete Palette?", current.name(), "palette",
+                                                    current, [this]() {
+                                                        m_controller.delete_current_palette();
+                                                        apply_themes();
+                                                    });
+
+    ImGui::SameLine();
+    ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 16);
+
+    if (ImGui::Button(" Apply Theme "))
+    {
+        m_controller.apply_current_theme();
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Apply current palette to all enabled templates");
+
+    ImGui::PopStyleVar(2);
+}
--- a/src/gui/views/color_scheme_editor.hpp
+++ b/src/gui/views/color_scheme_editor.hpp
@@ -0,0 +1,44 @@
+#ifndef CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
+#define CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
+
+#include "gui/controllers/palette_controller.hpp"
+#include "gui/views/color_table_renderer.hpp"
+#include "gui/views/preview_renderer.hpp"
+
+class template_editor;
+class settings_window;
+
+class color_scheme_editor
+{
+  public:
+    color_scheme_editor();
+
+    void render_controls_and_colors();
+    void render_preview();
+    void set_template_editor(template_editor *editor)
+    {
+        m_template_editor = editor;
+    }
+    void set_settings_window(settings_window *window)
+    {
+        m_settings_window = window;
+    }
+    const palette_controller &controller() const
+    {
+        return m_controller;
+    }
+
+  private:
+    void render_controls();
+    void apply_themes();
+    void notify_palette_changed();
+
+    palette_controller m_controller;
+    color_table_renderer m_color_table;
+    preview_renderer m_preview;
+    template_editor *m_template_editor{nullptr};
+    settings_window *m_settings_window{nullptr};
+    bool m_show_delete_confirmation{false};
+};
+
+#endif // CLRSYNC_GUI_COLOR_SCHEME_EDITOR_HPP
--- a/src/gui/views/color_table_renderer.cpp
+++ b/src/gui/views/color_table_renderer.cpp
@@ -0,0 +1,202 @@
+#include "gui/views/color_table_renderer.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
+#include "imgui.h"
+#include <algorithm>
+#include <cctype>
+#include <vector>
+
+bool color_table_renderer::matches_filter(const std::string &name) const
+{
+    if (m_filter_text[0] == '\0')
+        return true;
+
+    std::string filter_lower = m_filter_text;
+    std::string name_lower = name;
+
+    std::transform(filter_lower.begin(), filter_lower.end(), filter_lower.begin(),
+                   [](unsigned char c) { return std::tolower(c); });
+    std::transform(name_lower.begin(), name_lower.end(), name_lower.begin(),
+                   [](unsigned char c) { return std::tolower(c); });
+
+    return name_lower.find(filter_lower) != std::string::npos;
+}
+
+void color_table_renderer::render_color_row(const std::string &name,
+                                            const clrsync::core::palette &current,
+                                            palette_controller &controller,
+                                            const OnColorChangedCallback &on_changed)
+{
+    if (!matches_filter(name))
+        return;
+
+    const clrsync::core::color &col = current.get_color(name);
+
+    ImGui::TableNextRow();
+
+    ImGui::TableSetColumnIndex(0);
+    const float key_col_width = ImGui::GetContentRegionAvail().x;
+
+    ImVec4 text_color = palette_utils::get_color(current, "info", "accent");
+    ImGui::PushStyleColor(ImGuiCol_Text, text_color);
+    const bool copied = ImGui::Selectable(name.c_str(), false, 0, ImVec2(key_col_width, 0.0f));
+    ImGui::PopStyleColor();
+
+    if (ImGui::IsItemHovered())
+    {
+        ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
+        ImGui::SetTooltip("Click to copy: {%s.hex}", name.c_str());
+    }
+    if (copied)
+    {
+        std::string template_var = "{" + name + ".hex}";
+        ImGui::SetClipboardText(template_var.c_str());
+    }
+
+    ImGui::TableSetColumnIndex(1);
+    {
+        std::string hex_str = col.to_hex_string();
+        char buf[9];
+        strncpy(buf, hex_str.c_str(), sizeof(buf));
+        buf[8] = 0;
+
+        ImGui::SetNextItemWidth(-FLT_MIN);
+        if (ImGui::InputText(("##hex_" + name).c_str(), buf, sizeof(buf),
+                             ImGuiInputTextFlags_CharsUppercase))
+        {
+            try
+            {
+                clrsync::core::color new_color;
+                new_color.from_hex_string(buf);
+                controller.set_color(name, new_color);
+                if (on_changed)
+                    on_changed();
+            }
+            catch (...)
+            {
+            }
+        }
+    }
+
+    ImGui::TableSetColumnIndex(2);
+    ImGui::PushID(name.c_str());
+    float c[4] = {((col.hex() >> 24) & 0xFF) / 255.0f, ((col.hex() >> 16) & 0xFF) / 255.0f,
+                  ((col.hex() >> 8) & 0xFF) / 255.0f, (col.hex() & 0xFF) / 255.0f};
+
+    ImGui::SetNextItemWidth(-FLT_MIN);
+    if (ImGui::ColorEdit4(("##color_" + name).c_str(), c,
+                          ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel |
+                              ImGuiColorEditFlags_AlphaBar | ImGuiColorEditFlags_AlphaPreviewHalf))
+    {
+        uint32_t r = (uint32_t)(c[0] * 255.0f);
+        uint32_t g = (uint32_t)(c[1] * 255.0f);
+        uint32_t b = (uint32_t)(c[2] * 255.0f);
+        uint32_t a = (uint32_t)(c[3] * 255.0f);
+        uint32_t hex = (r << 24) | (g << 16) | (b << 8) | a;
+
+        controller.set_color(name, clrsync::core::color(hex));
+        if (on_changed)
+            on_changed();
+    }
+
+    ImGui::PopID();
+}
+
+void color_table_renderer::render(const clrsync::core::palette &current,
+                                  palette_controller &controller,
+                                  const OnColorChangedCallback &on_changed)
+{
+    if (current.colors().empty())
+    {
+        ImVec4 warning_color = palette_utils::get_color(current, "warning", "accent");
+        ImGui::TextColored(warning_color, "No palette loaded");
+        return;
+    }
+
+    ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(8, 6));
+
+    ImGui::Text("Filter:");
+    ImGui::SameLine();
+    ImGui::SetNextItemWidth(200);
+    bool filter_changed = ImGui::InputTextWithHint("##color_filter", "Search colors...",
+                                                   m_filter_text, sizeof(m_filter_text));
+
+    if (m_filter_text[0] != '\0')
+    {
+        ImGui::SameLine();
+        if (ImGui::SmallButton("X"))
+        {
+            m_filter_text[0] = '\0';
+            filter_changed = true;
+        }
+        if (ImGui::IsItemHovered())
+            ImGui::SetTooltip("Clear filter");
+    }
+
+    ImGui::PopStyleVar();
+
+    ImGui::Spacing();
+    ImGui::Separator();
+    ImGui::Spacing();
+
+    auto draw_table = [&](const char *title, const char *id,
+                          const std::vector<const char *> &keys) {
+        bool has_matches = false;
+        for (auto *k : keys)
+        {
+            if (matches_filter(k))
+            {
+                has_matches = true;
+                break;
+            }
+        }
+
+        if (!has_matches)
+            return;
+
+        ImGui::PushStyleColor(ImGuiCol_Text, palette_utils::get_color(current, "accent"));
+        bool header_open = ImGui::TreeNodeEx(title, ImGuiTreeNodeFlags_DefaultOpen |
+                                                        ImGuiTreeNodeFlags_SpanAvailWidth);
+        ImGui::PopStyleColor();
+
+        if (header_open)
+        {
+            if (ImGui::BeginTable(id, 3,
+                                  ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg |
+                                      ImGuiTableFlags_SizingStretchProp))
+            {
+                ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_WidthFixed, 160.0f);
+                ImGui::TableSetupColumn("HEX", ImGuiTableColumnFlags_WidthFixed, 95.0f);
+                ImGui::TableSetupColumn("Color", ImGuiTableColumnFlags_WidthStretch);
+                ImGui::TableHeadersRow();
+
+                for (auto *k : keys)
+                    render_color_row(k, current, controller, on_changed);
+
+                ImGui::EndTable();
+            }
+            ImGui::TreePop();
+        }
+
+        ImGui::Spacing();
+    };
+
+    draw_table("General UI", "##general_ui",
+               {"background", "on_background", "surface", "on_surface", "surface_variant",
+                "on_surface_variant", "foreground", "cursor", "accent"});
+
+    draw_table("Borders", "##borders", {"border_focused", "border"});
+
+    draw_table(
+        "Semantic Colors", "##semantic",
+        {"success", "info", "warning", "error", "on_success", "on_info", "on_warning", "on_error"});
+
+    draw_table("Editor", "##editor",
+               {"editor_background", "editor_command", "editor_comment", "editor_disabled",
+                "editor_emphasis", "editor_error", "editor_inactive", "editor_line_number",
+                "editor_link", "editor_main", "editor_selected", "editor_selection_inactive",
+                "editor_string", "editor_success", "editor_warning"});
+
+    draw_table("Terminal (Base16)", "##terminal",
+               {"base00", "base01", "base02", "base03", "base04", "base05", "base06", "base07",
+                "base08", "base09", "base0A", "base0B", "base0C", "base0D", "base0E", "base0F"});
+}
--- a/src/gui/views/color_table_renderer.hpp
+++ b/src/gui/views/color_table_renderer.hpp
@@ -0,0 +1,27 @@
+#ifndef CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP
+#define CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP
+
+#include "core/palette/palette.hpp"
+#include "gui/controllers/palette_controller.hpp"
+#include <functional>
+#include <string>
+
+class color_table_renderer
+{
+  public:
+    using OnColorChangedCallback = std::function<void()>;
+
+    void render(const clrsync::core::palette &palette, palette_controller &controller,
+                const OnColorChangedCallback &on_changed);
+
+  private:
+    void render_color_row(const std::string &name, const clrsync::core::palette &palette,
+                          palette_controller &controller, const OnColorChangedCallback &on_changed);
+
+    bool matches_filter(const std::string &name) const;
+
+    char m_filter_text[128] = {0};
+    bool m_show_only_modified{false};
+};
+
+#endif // CLRSYNC_GUI_COLOR_TABLE_RENDERER_HPP
--- a/src/gui/views/preview_renderer.cpp
+++ b/src/gui/views/preview_renderer.cpp
@@ -0,0 +1,246 @@
+#include "gui/views/preview_renderer.hpp"
+#include "gui/controllers/theme_applier.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
+#include "imgui.h"
+#include <algorithm>
+#include <array>
+
+preview_renderer::preview_renderer()
+{
+    m_editor.SetLanguageDefinition(TextEditor::LanguageDefinition::CPlusPlus());
+    m_editor.SetText(R"(#include <iostream>
+#include <string>
+#include <vector>
+#include <filesystem>
+#include <cstdlib>
+
+namespace fs = std::filesystem;
+
+std::string expand_user(const std::string &path)
+{
+    if (path.empty()) return "";
+
+    std::string result;
+    if (path[0] == '~')
+    {
+#ifdef _WIN32
+        const char* home = std::getenv("USERPROFILE");
+#else
+        const char* home = std::getenv("HOME");
+#endif
+        result = home ? std::string(home) : "~";
+        result += path.substr(1);
+    }
+    else
+    {
+        result = path;
+    }
+
+    return result;
+}
+
+std::vector<std::string> list_files(const std::string &dir_path)
+{
+    std::vector<std::string> files;
+    try
+    {
+        for (const auto &entry : fs::directory_iterator(dir_path))
+        {
+            if (entry.is_regular_file())
+                files.push_back(entry.path().string());
+        }
+    }
+    catch (const std::exception &e)
+    {
+        std::cerr << "Error: " << e.what() << std::endl;
+    }
+    return files;
+}
+
+int main()
+{
+    std::string path = expand_user("~/Documents");
+    std::cout << "Listing files in: " << path << std::endl;
+
+    auto files = list_files(path);
+    for (const auto &f : files)
+        std::cout << "  " << f << std::endl;
+
+    return 0;
+})");
+
+    m_editor.SetShowWhitespaces(false);
+}
+
+static ImVec4 hex_to_imvec4(uint32_t hex)
+{
+    return {((hex >> 24) & 0xFF) / 255.0f, ((hex >> 16) & 0xFF) / 255.0f,
+            ((hex >> 8) & 0xFF) / 255.0f, (hex & 0xFF) / 255.0f};
+}
+
+void preview_renderer::apply_palette(const clrsync::core::palette &palette)
+{
+    theme_applier::apply_to_editor(m_editor, palette);
+}
+
+void preview_renderer::render_code_preview()
+{
+    const float avail_height = ImGui::GetContentRegionAvail().y;
+    const float code_preview_height = std::max(250.0f, avail_height * 0.50f);
+
+    ImGui::Text("Code Editor Preview:");
+    ImGui::SameLine();
+    ImGui::TextDisabled("(editor_* colors)");
+    m_editor.Render("##CodeEditor", ImVec2(0, code_preview_height), true);
+}
+
+void preview_renderer::render_terminal_preview(const clrsync::core::palette &current)
+{
+    auto get_color = [&](const std::string &key) -> ImVec4 {
+        const auto &col = current.get_color(key);
+        return hex_to_imvec4(col.hex());
+    };
+    const ImVec4 bg = get_color("base00");
+    const ImVec4 fg = get_color("base07");
+    const ImVec4 cursor_col = get_color("cursor");
+    const ImVec4 border_col = get_color("border");
+
+    const ImVec4 black = get_color("base00");
+    const ImVec4 red = get_color("base01");
+    const ImVec4 green = get_color("base02");
+    const ImVec4 yellow = get_color("base03");
+    const ImVec4 blue = get_color("base04");
+    const ImVec4 magenta = get_color("base05");
+    const ImVec4 cyan = get_color("base06");
+    const ImVec4 white = get_color("base07");
+
+    const ImVec4 bright_black = get_color("base08");
+    const ImVec4 bright_red = get_color("base09");
+    const ImVec4 bright_green = get_color("base0A");
+    const ImVec4 bright_yellow = get_color("base0B");
+    const ImVec4 bright_blue = get_color("base0C");
+    const ImVec4 bright_magenta = get_color("base0D");
+    const ImVec4 bright_cyan = get_color("base0E");
+    const ImVec4 bright_white = get_color("base0F");
+
+    ImGui::Spacing();
+    ImGui::Text("Terminal Preview:");
+    ImGui::SameLine();
+    ImGui::TextDisabled("(base00-base0F colors)");
+
+    ImGui::PushStyleColor(ImGuiCol_ChildBg, bg);
+    ImGui::PushStyleColor(ImGuiCol_Border, border_col);
+
+    const float terminal_height = std::max(200.0f, ImGui::GetContentRegionAvail().y - 10.0f);
+    ImGui::BeginChild("TerminalPreview", ImVec2(0, terminal_height), true);
+
+    ImGui::TextColored(green, "user@host");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(fg, ":");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(blue, "~/projects");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(fg, "$ ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(fg, "ls -la");
+
+    ImGui::TextColored(fg, "total 48");
+    ImGui::TextColored(blue, "drwxr-xr-x");
+    ImGui::SameLine();
+    ImGui::TextColored(fg, " 5 user group  4096 Dec  2 10:30 ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(blue, ".");
+
+    ImGui::TextColored(blue, "drwxr-xr-x");
+    ImGui::SameLine();
+    ImGui::TextColored(fg, " 3 user group  4096 Dec  1 09:15 ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(blue, "..");
+
+    ImGui::TextColored(fg, "-rw-r--r--");
+    ImGui::SameLine();
+    ImGui::TextColored(fg, " 1 user group  1234 Dec  2 10:30 ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(fg, "README.md");
+
+    ImGui::TextColored(fg, "-rwxr-xr-x");
+    ImGui::SameLine();
+    ImGui::TextColored(fg, " 1 user group  8192 Dec  2 10:28 ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(green, "build.sh");
+
+    ImGui::TextColored(cyan, "lrwxrwxrwx");
+    ImGui::SameLine();
+    ImGui::TextColored(fg, " 1 user group    24 Dec  1 15:00 ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(cyan, "config -> ~/.config/app");
+
+    ImGui::Spacing();
+
+    ImGui::TextColored(green, "user@host");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(fg, ":");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(blue, "~/projects");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(fg, "$ ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(fg, "git status");
+
+    ImGui::TextColored(fg, "On branch ");
+    ImGui::SameLine(0, 0);
+    ImGui::TextColored(green, "main");
+    ImGui::TextColored(fg, "Changes to be committed:");
+    ImGui::TextColored(green, "  modified:   src/main.cpp");
+    ImGui::TextColored(green, "  new file:   src/utils.hpp");
+    ImGui::TextColored(fg, "Changes not staged:");
+    ImGui::TextColored(red, "  modified:   README.md");
+
+    ImGui::Spacing();
+
+    ImGui::TextColored(fg, "ANSI Colors (0-7 / 8-15):");
+
+    const float box_size = 20.0f;
+    const float spacing = 4.0f;
+    ImVec2 start_pos = ImGui::GetCursorScreenPos();
+    ImDrawList *draw_list = ImGui::GetWindowDrawList();
+
+    std::array<ImVec4, 8> normal_colors = {black, red, green, yellow, blue, magenta, cyan, white};
+    for (size_t i = 0; i < 8; i++)
+    {
+        ImVec2 p0 = ImVec2(start_pos.x + i * (box_size + spacing), start_pos.y);
+        ImVec2 p1 = ImVec2(p0.x + box_size, p0.y + box_size);
+        draw_list->AddRectFilled(p0, p1, ImGui::ColorConvertFloat4ToU32(normal_colors[i]));
+        draw_list->AddRect(p0, p1, ImGui::ColorConvertFloat4ToU32(border_col));
+    }
+
+    std::array<ImVec4, 8> bright_colors = {bright_black,  bright_red,  bright_green,
+                                           bright_yellow, bright_blue, bright_magenta,
+                                           bright_cyan,   bright_white};
+    for (size_t i = 0; i < 8; i++)
+    {
+        ImVec2 p0 =
+            ImVec2(start_pos.x + i * (box_size + spacing), start_pos.y + box_size + spacing);
+        ImVec2 p1 = ImVec2(p0.x + box_size, p0.y + box_size);
+        draw_list->AddRectFilled(p0, p1, ImGui::ColorConvertFloat4ToU32(bright_colors[i]));
+        draw_list->AddRect(p0, p1, ImGui::ColorConvertFloat4ToU32(border_col));
+    }
+
+    ImGui::Dummy(ImVec2(8 * (box_size + spacing), 2 * box_size + spacing + 4));
+
+    ImGui::PopStyleColor(2);
+    ImGui::EndChild();
+}
+
+void preview_renderer::render(const clrsync::core::palette &current)
+{
+    if (current.colors().empty())
+    {
+        ImVec4 error_color = palette_utils::get_color(current, "error", "accent");
+        ImGui::TextColored(error_color, "Current palette is empty");
+        return;
+    }
+
+    render_code_preview();
+    render_terminal_preview(current);
+}
--- a/src/gui/views/preview_renderer.hpp
+++ b/src/gui/views/preview_renderer.hpp
@@ -0,0 +1,22 @@
+#ifndef CLRSYNC_GUI_PREVIEW_RENDERER_HPP
+#define CLRSYNC_GUI_PREVIEW_RENDERER_HPP
+
+#include "color_text_edit/TextEditor.h"
+#include "core/palette/palette.hpp"
+
+class preview_renderer
+{
+  public:
+    preview_renderer();
+
+    void render(const clrsync::core::palette &palette);
+    void apply_palette(const clrsync::core::palette &palette);
+
+  private:
+    void render_code_preview();
+    void render_terminal_preview(const clrsync::core::palette &palette);
+
+    TextEditor m_editor;
+};
+
+#endif // CLRSYNC_GUI_PREVIEW_RENDERER_HPP
--- a/src/gui/views/settings_window.cpp
+++ b/src/gui/views/settings_window.cpp
@@ -0,0 +1,378 @@
+#include "gui/views/settings_window.hpp"
+#include "core/common/error.hpp"
+#include "core/config/config.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
+#include "gui/platform/file_browser.hpp"
+#include "gui/platform/font_loader.hpp"
+#include "imgui.h"
+#include <cstring>
+
+settings_window::settings_window()
+    : m_font_size(14), m_selected_font_idx(0), m_settings_changed(false), m_current_tab(0)
+{
+    m_default_theme[0] = '\0';
+    m_palettes_path[0] = '\0';
+    m_font[0] = '\0';
+
+    font_loader loader;
+    m_available_fonts = loader.get_system_fonts();
+
+    load_settings();
+}
+
+void settings_window::render()
+{
+    if (!m_visible)
+        return;
+
+    ImGui::SetNextWindowSize(ImVec2(700, 500), ImGuiCond_FirstUseEver);
+    ImGui::SetNextWindowPos(ImGui::GetMainViewport()->GetCenter(), ImGuiCond_FirstUseEver,
+                            ImVec2(0.5f, 0.5f));
+
+    ImGuiWindowFlags window_flags = ImGuiWindowFlags_NoCollapse;
+    if (ImGui::Begin("Settings", &m_visible, window_flags))
+    {
+        if (ImGui::BeginTabBar("SettingsTabs", ImGuiTabBarFlags_None))
+        {
+            if (ImGui::BeginTabItem("General"))
+            {
+                render_general_tab();
+                ImGui::EndTabItem();
+            }
+
+            if (ImGui::BeginTabItem("Appearance"))
+            {
+                render_appearance_tab();
+                ImGui::EndTabItem();
+            }
+
+            ImGui::EndTabBar();
+        }
+
+        render_status_messages();
+
+        ImGui::Separator();
+        render_action_buttons();
+    }
+    ImGui::End();
+}
+
+void settings_window::load_settings()
+{
+    auto &cfg = clrsync::core::config::instance();
+
+    std::string default_theme = cfg.default_theme();
+    strncpy(m_default_theme, default_theme.c_str(), sizeof(m_default_theme) - 1);
+    m_default_theme[sizeof(m_default_theme) - 1] = '\0';
+
+    std::string palettes_path = cfg.palettes_path();
+    strncpy(m_palettes_path, palettes_path.c_str(), sizeof(m_palettes_path) - 1);
+    m_palettes_path[sizeof(m_palettes_path) - 1] = '\0';
+
+    std::string font = cfg.font();
+    strncpy(m_font, font.c_str(), sizeof(m_font) - 1);
+    m_font[sizeof(m_font) - 1] = '\0';
+
+    m_selected_font_idx = 0;
+    for (int i = 0; i < static_cast<int>(m_available_fonts.size()); i++)
+    {
+        if (m_available_fonts[i] == font)
+        {
+            m_selected_font_idx = i;
+            break;
+        }
+    }
+
+    m_font_size = cfg.font_size();
+
+    m_error_message.clear();
+    m_settings_changed = false;
+}
+
+void settings_window::apply_settings()
+{
+    auto &cfg = clrsync::core::config::instance();
+
+    if (strlen(m_default_theme) == 0)
+    {
+        m_error_message = "Default theme cannot be empty";
+        return;
+    }
+
+    if (strlen(m_palettes_path) == 0)
+    {
+        m_error_message = "Palettes path cannot be empty";
+        return;
+    }
+
+    if (strlen(m_font) == 0)
+    {
+        m_error_message = "Font cannot be empty";
+        return;
+    }
+
+    if (m_font_size < 8 || m_font_size > 48)
+    {
+        m_error_message = "Font size must be between 8 and 48";
+        return;
+    }
+
+    auto result1 = cfg.set_default_theme(m_default_theme);
+    if (!result1)
+    {
+        m_error_message = "Failed to set default theme: " + result1.error().description();
+        return;
+    }
+
+    auto result2 = cfg.set_palettes_path(m_palettes_path);
+    if (!result2)
+    {
+        m_error_message = "Failed to set palettes path: " + result2.error().description();
+        return;
+    }
+
+    auto result3 = cfg.set_font(m_font);
+    if (!result3)
+    {
+        m_error_message = "Failed to set font: " + result3.error().description();
+        return;
+    }
+
+    auto result4 = cfg.set_font_size(m_font_size);
+    if (!result4)
+    {
+        m_error_message = "Failed to set font size: " + result4.error().description();
+        return;
+    }
+
+    font_loader fn_loader;
+    auto font = fn_loader.load_font(m_font, m_font_size);
+    if (font)
+        ImGui::GetIO().FontDefault = font;
+
+    m_error_message.clear();
+    m_settings_changed = false;
+}
+
+void settings_window::render_general_tab()
+{
+    ImGui::Spacing();
+
+    auto accent_color = palette_utils::get_color(m_current_palette, "accent");
+    ImGui::TextColored(accent_color, "Theme Settings");
+    ImGui::Separator();
+    ImGui::Spacing();
+
+    ImGui::Text("Default Theme:");
+    ImGui::SameLine();
+    show_help_marker("The default color scheme to load on startup");
+    ImGui::SetNextItemWidth(-100.0f);
+    if (ImGui::InputText("##default_theme", m_default_theme, sizeof(m_default_theme)))
+        m_settings_changed = true;
+
+    ImGui::Spacing();
+
+    ImGui::TextColored(accent_color, "Path Settings");
+    ImGui::Separator();
+    ImGui::Spacing();
+
+    ImGui::Text("Palettes Directory:");
+    ImGui::SameLine();
+    show_help_marker("Directory where color palettes are stored\nSupports ~ for home directory");
+    ImGui::SetNextItemWidth(-120.0f);
+    if (ImGui::InputText("##palettes_path", m_palettes_path, sizeof(m_palettes_path)))
+        m_settings_changed = true;
+    ImGui::SameLine();
+    if (ImGui::Button("Browse"))
+    {
+        std::string selected_path =
+            file_dialogs::select_folder_dialog("Select Palettes Directory", m_palettes_path);
+        if (!selected_path.empty())
+        {
+            strncpy(m_palettes_path, selected_path.c_str(), sizeof(m_palettes_path) - 1);
+            m_palettes_path[sizeof(m_palettes_path) - 1] = '\0';
+            m_settings_changed = true;
+        }
+    }
+}
+
+void settings_window::render_appearance_tab()
+{
+    ImGui::Spacing();
+
+    auto accent_color = palette_utils::get_color(m_current_palette, "accent");
+    ImGui::TextColored(accent_color, "Font Settings");
+    ImGui::Separator();
+    ImGui::Spacing();
+
+    ImGui::Text("Font Family:");
+    ImGui::SameLine();
+    show_help_marker("Select font family for the application interface");
+    ImGui::SetNextItemWidth(-1.0f);
+    if (ImGui::BeginCombo("##font", m_font))
+    {
+        for (int i = 0; i < static_cast<int>(m_available_fonts.size()); i++)
+        {
+            bool is_selected = (i == m_selected_font_idx);
+            if (ImGui::Selectable(m_available_fonts[i].c_str(), is_selected))
+            {
+                m_selected_font_idx = i;
+                strncpy(m_font, m_available_fonts[i].c_str(), sizeof(m_font) - 1);
+                m_font[sizeof(m_font) - 1] = '\0';
+                m_settings_changed = true;
+            }
+            if (is_selected)
+                ImGui::SetItemDefaultFocus();
+        }
+        ImGui::EndCombo();
+    }
+
+    ImGui::Spacing();
+
+    ImGui::Text("Font Size:");
+    ImGui::SameLine();
+    show_help_marker("Font size for the application interface (8-48)");
+    ImGui::SetNextItemWidth(120.0f);
+    int old_size = m_font_size;
+    if (ImGui::SliderInt("##font_size", &m_font_size, 8, 48, "%d px"))
+    {
+        if (old_size != m_font_size)
+            m_settings_changed = true;
+    }
+
+    ImGui::SameLine();
+    if (ImGui::Button("Reset"))
+    {
+        m_font_size = 14;
+        m_settings_changed = true;
+    }
+}
+
+void settings_window::render_status_messages()
+{
+    if (!m_error_message.empty())
+    {
+        ImGui::Spacing();
+
+        auto error_bg_color = palette_utils::get_color(m_current_palette, "error");
+        auto error_text_color = palette_utils::get_color(m_current_palette, "on_error");
+
+        ImGui::PushStyleColor(ImGuiCol_ChildBg, error_bg_color);
+        ImGui::PushStyleColor(ImGuiCol_Border, error_bg_color);
+        ImGui::PushStyleVar(ImGuiStyleVar_ChildRounding, 4.0f);
+        ImGui::PushStyleVar(ImGuiStyleVar_ChildBorderSize, 1.0f);
+
+        if (ImGui::BeginChild("##error_box", ImVec2(0, 0),
+                              ImGuiChildFlags_AutoResizeY | ImGuiChildFlags_Borders))
+        {
+            ImGui::PushStyleColor(ImGuiCol_Text, error_text_color);
+            ImGui::TextWrapped("Error: %s", m_error_message.c_str());
+            ImGui::PopStyleColor();
+
+            ImGui::Spacing();
+
+            ImGui::PushStyleColor(ImGuiCol_Button,
+                                  ImVec4(error_bg_color.x * 0.8f, error_bg_color.y * 0.8f,
+                                         error_bg_color.z * 0.8f, error_bg_color.w));
+            ImGui::PushStyleColor(ImGuiCol_ButtonHovered,
+                                  ImVec4(error_bg_color.x * 0.6f, error_bg_color.y * 0.6f,
+                                         error_bg_color.z * 0.6f, error_bg_color.w));
+            ImGui::PushStyleColor(ImGuiCol_Text, error_text_color);
+
+            if (ImGui::Button("Dismiss##error"))
+                m_error_message.clear();
+
+            ImGui::PopStyleColor(3);
+        }
+        ImGui::EndChild();
+
+        ImGui::PopStyleVar(2);
+        ImGui::PopStyleColor(2);
+    }
+}
+
+void settings_window::render_action_buttons()
+{
+    ImGui::Spacing();
+
+    float button_width = 100.0f;
+    float spacing = ImGui::GetStyle().ItemSpacing.x;
+    float window_width = ImGui::GetContentRegionAvail().x;
+
+    float total_buttons_width = 4 * button_width + 3 * spacing;
+    float start_pos = (window_width - total_buttons_width) * 0.5f;
+
+    if (start_pos > 0)
+        ImGui::SetCursorPosX(ImGui::GetCursorPosX() + start_pos);
+
+    if (ImGui::Button("OK", ImVec2(button_width, 0)))
+    {
+        apply_settings();
+        if (m_error_message.empty())
+        {
+            m_visible = false;
+            m_settings_changed = false;
+        }
+    }
+
+    ImGui::SameLine();
+
+    bool apply_disabled = !m_settings_changed;
+    if (apply_disabled)
+    {
+        ImGui::PushStyleVar(ImGuiStyleVar_Alpha, 0.5f);
+    }
+
+    if (ImGui::Button("Apply", ImVec2(button_width, 0)) && !apply_disabled)
+    {
+        apply_settings();
+        if (m_error_message.empty())
+        {
+            m_settings_changed = false;
+        }
+    }
+
+    if (apply_disabled)
+    {
+        ImGui::PopStyleVar();
+    }
+
+    ImGui::SameLine();
+
+    if (ImGui::Button("Reset", ImVec2(button_width, 0)))
+    {
+        reset_to_defaults();
+    }
+
+    ImGui::SameLine();
+
+    if (ImGui::Button("Cancel", ImVec2(button_width, 0)))
+    {
+        load_settings();
+        m_visible = false;
+        m_error_message.clear();
+        m_settings_changed = false;
+    }
+}
+
+void settings_window::show_help_marker(const char *desc)
+{
+    ImGui::TextDisabled("(?)");
+    if (ImGui::BeginItemTooltip())
+    {
+        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
+        ImGui::TextUnformatted(desc);
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+    }
+}
+
+void settings_window::reset_to_defaults()
+{
+    strncpy(m_default_theme, "dark", sizeof(m_default_theme));
+    strncpy(m_palettes_path, "~/.config/clrsync/palettes", sizeof(m_palettes_path));
+    strncpy(m_font, "JetBrains Mono Nerd Font", sizeof(m_font));
+    m_font_size = 14;
+    m_error_message.clear();
+    m_settings_changed = true;
+}
--- a/src/gui/views/settings_window.hpp
+++ b/src/gui/views/settings_window.hpp
@@ -0,0 +1,60 @@
+#ifndef CLRSYNC_GUI_SETTINGS_WINDOW_HPP
+#define CLRSYNC_GUI_SETTINGS_WINDOW_HPP
+
+#include "core/palette/palette.hpp"
+#include <string>
+#include <vector>
+
+class settings_window
+{
+  public:
+    settings_window();
+    void render();
+    void show()
+    {
+        m_visible = true;
+    }
+    void hide()
+    {
+        m_visible = false;
+    }
+    bool is_visible() const
+    {
+        return m_visible;
+    }
+
+  private:
+    void load_settings();
+    void save_settings();
+    void apply_settings();
+    void render_general_tab();
+    void render_appearance_tab();
+    void render_status_messages();
+    void render_action_buttons();
+    void show_help_marker(const char *desc);
+    void reset_to_defaults();
+
+  public:
+    void set_palette(const clrsync::core::palette &palette)
+    {
+        m_current_palette = palette;
+    }
+
+    bool m_visible{false};
+
+    char m_default_theme[128];
+    char m_palettes_path[512];
+    char m_font[128];
+    int m_font_size;
+
+    std::vector<std::string> m_available_fonts;
+    int m_selected_font_idx;
+
+    std::string m_error_message;
+    bool m_settings_changed;
+    int m_current_tab;
+
+    clrsync::core::palette m_current_palette;
+};
+
+#endif // CLRSYNC_GUI_SETTINGS_WINDOW_HPP
--- a/src/gui/views/template_editor.cpp
+++ b/src/gui/views/template_editor.cpp
@@ -0,0 +1,954 @@
+#include "template_editor.hpp"
+#include "core/common/utils.hpp"
+#include "core/config/config.hpp"
+#include "core/palette/color_keys.hpp"
+#include "core/theme/theme_template.hpp"
+#include "gui/helpers/imgui_helpers.hpp"
+#include "gui/platform/file_browser.hpp"
+#include "imgui.h"
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <ranges>
+
+namespace
+{
+const std::vector<std::string> COLOR_FORMATS = {
+    "hex", "hex_stripped", "hexa", "hexa_stripped", "r", "g", "b", "a", "rgb", "rgba", "h", "s",
+    "l",   "hsl",          "hsla"};
+}
+
+template_editor::template_editor() : m_template_name("new_template")
+{
+    m_autocomplete_bg_color = ImVec4(0.12f, 0.12f, 0.15f, 0.98f);
+    m_autocomplete_border_color = ImVec4(0.4f, 0.4f, 0.45f, 1.0f);
+    m_autocomplete_selected_color = ImVec4(0.25f, 0.45f, 0.75f, 0.9f);
+    m_autocomplete_text_color = ImVec4(0.85f, 0.85f, 0.9f, 1.0f);
+    m_autocomplete_selected_text_color = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);
+    m_autocomplete_dim_text_color = ImVec4(0.6f, 0.6f, 0.7f, 1.0f);
+
+    TextEditor::LanguageDefinition lang;
+    lang.mName = "Template";
+
+    lang.mCommentStart = "/*";
+    lang.mCommentEnd = "*/";
+    lang.mSingleLineComment = "#";
+
+    lang.mTokenRegexStrings.push_back(std::make_pair<std::string, TextEditor::PaletteIndex>(
+        "\\{[a-zA-Z_][a-zA-Z0-9_]*(\\.[a-zA-Z_][a-zA-Z0-9_]*)?\\}",
+        TextEditor::PaletteIndex::KnownIdentifier));
+
+    lang.mTokenRegexStrings.push_back(std::make_pair<std::string, TextEditor::PaletteIndex>(
+        "\"([^\"]*)\"", TextEditor::PaletteIndex::String));
+    lang.mTokenRegexStrings.push_back(std::make_pair<std::string, TextEditor::PaletteIndex>(
+        "'([^']*)'", TextEditor::PaletteIndex::String));
+
+    m_editor.SetLanguageDefinition(lang);
+    m_editor.SetText("# Enter your template here\n# Use {color_key} for color variables\n# "
+                     "Examples: {color.hex}, {color.rgb}, {color.r}\n\n");
+    m_editor.SetShowWhitespaces(false);
+}
+
+void template_editor::apply_current_palette(const clrsync::core::palette &pal)
+{
+    m_current_palette = pal;
+    auto colors = pal.colors();
+    if (colors.empty())
+        return;
+    auto get_color_u32 = [&](const std::string &key, const std::string &fallback = "") -> uint32_t {
+        return palette_utils::get_color_u32(pal, key, fallback);
+    };
+
+    auto palette = m_editor.GetPalette();
+
+    palette[int(TextEditor::PaletteIndex::Default)] = get_color_u32("editor_main", "foreground");
+    palette[int(TextEditor::PaletteIndex::Keyword)] = get_color_u32("editor_command", "accent");
+    palette[int(TextEditor::PaletteIndex::Number)] = get_color_u32("editor_warning", "warning");
+    palette[int(TextEditor::PaletteIndex::String)] = get_color_u32("editor_string", "success");
+    palette[int(TextEditor::PaletteIndex::CharLiteral)] = get_color_u32("editor_string", "success");
+    palette[int(TextEditor::PaletteIndex::Punctuation)] =
+        get_color_u32("editor_main", "foreground");
+    palette[int(TextEditor::PaletteIndex::Preprocessor)] =
+        get_color_u32("editor_emphasis", "accent");
+    palette[int(TextEditor::PaletteIndex::Identifier)] = get_color_u32("editor_main", "foreground");
+    palette[int(TextEditor::PaletteIndex::KnownIdentifier)] = get_color_u32("editor_link", "info");
+    palette[int(TextEditor::PaletteIndex::PreprocIdentifier)] =
+        get_color_u32("editor_link", "info");
+
+    palette[int(TextEditor::PaletteIndex::Comment)] =
+        get_color_u32("editor_comment", "editor_inactive");
+    palette[int(TextEditor::PaletteIndex::MultiLineComment)] =
+        get_color_u32("editor_comment", "editor_inactive");
+
+    palette[int(TextEditor::PaletteIndex::Background)] =
+        get_color_u32("editor_background", "background");
+    palette[int(TextEditor::PaletteIndex::Cursor)] = get_color_u32("cursor", "accent");
+
+    palette[int(TextEditor::PaletteIndex::Selection)] =
+        get_color_u32("editor_selected", "surface_variant");
+    palette[int(TextEditor::PaletteIndex::ErrorMarker)] = get_color_u32("editor_error", "error");
+    palette[int(TextEditor::PaletteIndex::Breakpoint)] = get_color_u32("editor_error", "error");
+
+    palette[int(TextEditor::PaletteIndex::LineNumber)] =
+        get_color_u32("editor_line_number", "editor_inactive");
+    palette[int(TextEditor::PaletteIndex::CurrentLineFill)] = get_color_u32("surface_variant");
+    palette[int(TextEditor::PaletteIndex::CurrentLineFillInactive)] = get_color_u32("surface");
+
+    palette[int(TextEditor::PaletteIndex::CurrentLineEdge)] =
+        get_color_u32("border_focused", "border");
+
+    m_editor.SetPalette(palette);
+
+    m_autocomplete_bg_color = palette_utils::get_color(pal, "surface", "background");
+    m_autocomplete_bg_color.w = 0.98f;
+    m_autocomplete_border_color = palette_utils::get_color(pal, "border", "surface_variant");
+    m_autocomplete_selected_color = palette_utils::get_color(pal, "accent", "surface_variant");
+    m_autocomplete_text_color = palette_utils::get_color(pal, "on_surface", "foreground");
+    m_autocomplete_selected_text_color = palette_utils::get_color(pal, "on_surface", "foreground");
+    m_autocomplete_dim_text_color =
+        palette_utils::get_color(pal, "on_surface_variant", "editor_inactive");
+}
+
+void template_editor::update_autocomplete_suggestions()
+{
+    m_autocomplete_suggestions.clear();
+
+    auto cursor = m_editor.GetCursorPosition();
+    std::string line = m_editor.GetCurrentLineText();
+    int col = cursor.mColumn;
+
+    // Check if inside '{'
+    int brace_pos = -1;
+    for (int i = col - 1; i >= 0; --i)
+    {
+        if (i < (int)line.length())
+        {
+            if (line[i] == '{')
+            {
+                brace_pos = i;
+                break;
+            }
+            else if (line[i] == '}' || line[i] == ' ' || line[i] == '\t')
+            {
+                break;
+            }
+        }
+    }
+
+    if (brace_pos < 0)
+    {
+        m_show_autocomplete = false;
+        m_autocomplete_dismissed = false;
+        return;
+    }
+
+    if (m_autocomplete_dismissed)
+    {
+        bool should_reset_dismissal = false;
+
+        if (cursor.mLine != m_dismiss_position.mLine || brace_pos != m_dismiss_brace_pos ||
+            abs(cursor.mColumn - m_dismiss_position.mColumn) > 3)
+        {
+            should_reset_dismissal = true;
+        }
+
+        if (should_reset_dismissal)
+        {
+            m_autocomplete_dismissed = false;
+        }
+        else
+        {
+            m_show_autocomplete = false;
+            return;
+        }
+    }
+
+    m_autocomplete_prefix = line.substr(brace_pos + 1, col - brace_pos - 1);
+    m_autocomplete_start_pos = TextEditor::Coordinates(cursor.mLine, brace_pos + 1);
+
+    size_t dot_pos = m_autocomplete_prefix.find('.');
+
+    if (dot_pos != std::string::npos)
+    {
+        std::string color_key = m_autocomplete_prefix.substr(0, dot_pos);
+        std::string format_prefix = m_autocomplete_prefix.substr(dot_pos + 1);
+
+        bool valid_key = false;
+        for (size_t i = 0; i < clrsync::core::NUM_COLOR_KEYS; ++i)
+        {
+            if (clrsync::core::COLOR_KEYS[i] == color_key)
+            {
+                valid_key = true;
+                break;
+            }
+        }
+
+        if (valid_key)
+        {
+            for (const auto &fmt : COLOR_FORMATS)
+            {
+                if (format_prefix.empty() || fmt.find(format_prefix) == 0 ||
+                    fmt.find(format_prefix) != std::string::npos)
+                {
+                    m_autocomplete_suggestions.push_back(color_key + "." + fmt);
+                }
+            }
+        }
+    }
+    else
+    {
+        for (size_t i = 0; i < clrsync::core::NUM_COLOR_KEYS; ++i)
+        {
+            std::string key = clrsync::core::COLOR_KEYS[i];
+            if (m_autocomplete_prefix.empty() || key.find(m_autocomplete_prefix) == 0 ||
+                key.find(m_autocomplete_prefix) != std::string::npos)
+            {
+                m_autocomplete_suggestions.push_back(key);
+            }
+        }
+    }
+
+    std::sort(m_autocomplete_suggestions.begin(), m_autocomplete_suggestions.end(),
+              [this](const std::string &a, const std::string &b) {
+                  bool a_prefix = a.find(m_autocomplete_prefix) == 0;
+                  bool b_prefix = b.find(m_autocomplete_prefix) == 0;
+                  if (a_prefix != b_prefix)
+                      return a_prefix;
+                  return a < b;
+              });
+
+    m_show_autocomplete = !m_autocomplete_suggestions.empty();
+    if (m_show_autocomplete && m_autocomplete_selected >= (int)m_autocomplete_suggestions.size())
+    {
+        m_autocomplete_selected = 0;
+    }
+}
+
+void template_editor::render_autocomplete(const ImVec2 &editor_pos)
+{
+    if (!m_show_autocomplete || m_autocomplete_suggestions.empty())
+        return;
+
+    float line_height = ImGui::GetTextLineHeightWithSpacing();
+    float char_width = ImGui::GetFontSize() * 0.5f;
+    auto cursor = m_editor.GetCursorPosition();
+
+    const float line_number_width = 50.0f;
+
+    ImVec2 popup_pos;
+    popup_pos.x =
+        editor_pos.x + line_number_width + (m_autocomplete_start_pos.mColumn * char_width);
+    popup_pos.y = editor_pos.y + ((cursor.mLine + 1) * line_height);
+
+    ImGui::SetNextWindowPos(popup_pos, ImGuiCond_Always);
+    ImGui::SetNextWindowSize(ImVec2(300, 0));
+
+    ImGuiWindowFlags flags = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize |
+                             ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
+                             ImGuiWindowFlags_NoFocusOnAppearing |
+                             ImGuiWindowFlags_AlwaysAutoResize;
+
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(6, 6));
+    ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 6.0f);
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4, 2));
+    ImGui::PushStyleColor(ImGuiCol_WindowBg, m_autocomplete_bg_color);
+    ImGui::PushStyleColor(ImGuiCol_Border, m_autocomplete_border_color);
+
+    if (ImGui::Begin("##autocomplete", nullptr, flags))
+    {
+        ImGui::PushStyleColor(ImGuiCol_Text, m_autocomplete_dim_text_color);
+        if (m_autocomplete_prefix.find('.') != std::string::npos)
+            ImGui::Text("Formats");
+        else
+            ImGui::Text("Color Keys");
+        ImGui::PopStyleColor();
+        ImGui::Separator();
+
+        int max_items = std::min((int)m_autocomplete_suggestions.size(), 8);
+
+        for (int i = 0; i < max_items; ++i)
+        {
+            const auto &suggestion = m_autocomplete_suggestions[i];
+            bool is_selected = (i == m_autocomplete_selected);
+
+            if (is_selected)
+            {
+                ImVec4 selected_hover = m_autocomplete_selected_color;
+                selected_hover.w = std::min(selected_hover.w + 0.1f, 1.0f);
+                ImGui::PushStyleColor(ImGuiCol_Header, m_autocomplete_selected_color);
+                ImGui::PushStyleColor(ImGuiCol_HeaderHovered, selected_hover);
+                ImGui::PushStyleColor(ImGuiCol_Text, m_autocomplete_selected_text_color);
+            }
+            else
+            {
+                ImVec4 normal_bg = m_autocomplete_bg_color;
+                normal_bg.w = 0.5f;
+                ImVec4 hover_bg = m_autocomplete_selected_color;
+                hover_bg.w = 0.3f;
+                ImGui::PushStyleColor(ImGuiCol_Header, normal_bg);
+                ImGui::PushStyleColor(ImGuiCol_HeaderHovered, hover_bg);
+                ImGui::PushStyleColor(ImGuiCol_Text, m_autocomplete_text_color);
+            }
+
+            std::string display_text = "  " + suggestion;
+
+            if (ImGui::Selectable(display_text.c_str(), is_selected, ImGuiSelectableFlags_None,
+                                  ImVec2(0, 0)))
+            {
+                auto start = m_autocomplete_start_pos;
+                auto end = m_editor.GetCursorPosition();
+                m_editor.SetSelection(start, end);
+                m_editor.Delete();
+                m_editor.InsertText(suggestion + "}");
+                m_show_autocomplete = false;
+                m_autocomplete_dismissed = false;
+            }
+
+            ImGui::PopStyleColor(3);
+
+            if (is_selected && ImGui::IsWindowAppearing())
+            {
+                ImGui::SetScrollHereY();
+            }
+        }
+
+        if (m_autocomplete_suggestions.size() > 8)
+        {
+            ImGui::Separator();
+            ImGui::PushStyleColor(ImGuiCol_Text, m_autocomplete_dim_text_color);
+            ImGui::Text("  +%d more", (int)m_autocomplete_suggestions.size() - 8);
+            ImGui::PopStyleColor();
+        }
+
+        ImGui::Separator();
+        ImGui::PushStyleColor(ImGuiCol_Text, m_autocomplete_dim_text_color);
+        ImGui::Text("  Tab/Enter: accept | Esc: dismiss");
+        ImGui::PopStyleColor();
+    }
+    ImGui::End();
+
+    ImGui::PopStyleColor(2);
+    ImGui::PopStyleVar(3);
+}
+
+void template_editor::render()
+{
+    ImGui::Begin("Templates");
+
+    render_controls();
+    ImGui::Separator();
+
+    const float panel_width = ImGui::GetContentRegionAvail().x;
+    constexpr float left_panel_width = 200.0f;
+    const float right_panel_width = panel_width - left_panel_width - 10;
+
+    ImGui::BeginChild("TemplateList", ImVec2(left_panel_width, 0), true);
+    render_template_list();
+    ImGui::EndChild();
+
+    ImGui::SameLine();
+
+    ImGui::BeginChild("EditorPanel", ImVec2(right_panel_width, 0), false);
+    render_editor();
+    ImGui::EndChild();
+
+    if (m_show_delete_confirmation)
+    {
+        ImGui::OpenPopup("Delete Template?");
+        m_show_delete_confirmation = false;
+    }
+
+    palette_utils::render_delete_confirmation_popup(
+        "Delete Template?", m_template_name, "template", m_current_palette, [this]() {
+            bool success = m_template_controller.remove_template(m_template_name);
+            if (success)
+            {
+                new_template();
+                refresh_templates();
+            }
+            else
+            {
+                m_validation_error = "Failed to delete template";
+            }
+        });
+
+    ImGui::End();
+}
+
+void template_editor::render_controls()
+{
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4, 8));
+
+    if (ImGui::Button(" + New "))
+    {
+        new_template();
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Create a new template");
+
+    if (ImGui::IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows) &&
+        ImGui::IsKeyDown(ImGuiKey_LeftCtrl) && ImGui::IsKeyPressed(ImGuiKey_S))
+    {
+        save_template();
+    }
+
+    ImGui::SameLine();
+    if (ImGui::Button(" Save "))
+    {
+        save_template();
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Save template (Ctrl+S)");
+
+    if (m_is_editing_existing)
+    {
+        ImGui::SameLine();
+        auto error = palette_utils::get_color(m_current_palette, "error");
+        auto error_hover = ImVec4(error.x * 1.1f, error.y * 1.1f, error.z * 1.1f, error.w);
+        auto error_active = ImVec4(error.x * 0.8f, error.y * 0.8f, error.z * 0.8f, error.w);
+        auto on_error = palette_utils::get_color(m_current_palette, "on_error");
+        ImGui::PushStyleColor(ImGuiCol_Button, error);
+        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, error_hover);
+        ImGui::PushStyleColor(ImGuiCol_ButtonActive, error_active);
+        ImGui::PushStyleColor(ImGuiCol_Text, on_error);
+        if (ImGui::Button(" Delete "))
+        {
+            delete_template();
+        }
+        if (ImGui::IsItemHovered())
+            ImGui::SetTooltip("Delete this template");
+        ImGui::PopStyleColor(4);
+    }
+
+    ImGui::SameLine();
+    ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 10);
+
+    bool enabled_changed = false;
+    if (m_enabled)
+    {
+        ImVec4 success_color = palette_utils::get_color(m_current_palette, "success", "accent");
+        ImVec4 success_on_color =
+            palette_utils::get_color(m_current_palette, "on_success", "on_surface");
+        ImVec4 success_hover =
+            ImVec4(success_color.x * 1.2f, success_color.y * 1.2f, success_color.z * 1.2f, 0.6f);
+        ImGui::PushStyleColor(ImGuiCol_FrameBg,
+                              ImVec4(success_color.x, success_color.y, success_color.z, 0.5f));
+        ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, success_hover);
+        ImGui::PushStyleColor(ImGuiCol_CheckMark, success_on_color);
+    }
+    else
+    {
+        ImVec4 error_color = palette_utils::get_color(m_current_palette, "error", "accent");
+        ImVec4 error_on_color =
+            palette_utils::get_color(m_current_palette, "on_error", "on_surface");
+        ImVec4 error_hover =
+            ImVec4(error_color.x * 1.2f, error_color.y * 1.2f, error_color.z * 1.2f, 0.6f);
+        ImGui::PushStyleColor(ImGuiCol_FrameBg,
+                              ImVec4(error_color.x, error_color.y, error_color.z, 0.5f));
+        ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, error_hover);
+        ImGui::PushStyleColor(ImGuiCol_CheckMark, error_on_color);
+    }
+
+    enabled_changed = ImGui::Checkbox("Enabled", &m_enabled);
+    ImGui::PopStyleColor(3);
+
+    if (enabled_changed && m_is_editing_existing)
+    {
+        m_template_controller.set_template_enabled(m_template_name, m_enabled);
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Enable/disable this template for theme application");
+
+    ImGui::PopStyleVar();
+
+    ImGui::Spacing();
+
+    ImGui::AlignTextToFramePadding();
+    ImGui::Text("Name:");
+    ImGui::SameLine(80);
+    ImGui::SetNextItemWidth(180.0f);
+    char name_buf[256] = {0};
+    snprintf(name_buf, sizeof(name_buf), "%s", m_template_name.c_str());
+    if (ImGui::InputText("##template_name", name_buf, sizeof(name_buf)))
+    {
+        m_template_name = name_buf;
+        if (!m_template_name.empty())
+        {
+            m_validation_error = "";
+        }
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Unique name for this template");
+
+    ImGui::AlignTextToFramePadding();
+    ImGui::Text("Input:");
+    ImGui::SameLine(80);
+    ImGui::SetNextItemWidth(-120.0f);
+    char input_path_buf[512] = {0};
+    snprintf(input_path_buf, sizeof(input_path_buf), "%s", m_input_path.c_str());
+    if (ImGui::InputTextWithHint("##input_path", "Path to template file...", input_path_buf,
+                                 sizeof(input_path_buf)))
+    {
+        m_input_path = input_path_buf;
+        if (!m_input_path.empty())
+        {
+            m_validation_error = "";
+        }
+        if (m_is_editing_existing)
+        {
+            m_template_controller.set_template_input_path(m_template_name, m_input_path);
+        }
+    }
+    ImGui::SameLine();
+    if (ImGui::Button("Browse##input"))
+    {
+        std::string selected_path =
+            file_dialogs::open_file_dialog("Select Template File", m_input_path);
+        if (!selected_path.empty())
+        {
+            m_input_path = selected_path;
+            if (m_is_editing_existing)
+            {
+                m_template_controller.set_template_input_path(m_template_name, m_input_path);
+            }
+            m_validation_error = "";
+        }
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Path where the template source file is stored");
+
+    ImGui::AlignTextToFramePadding();
+    ImGui::Text("Output:");
+    ImGui::SameLine(80);
+    ImGui::SetNextItemWidth(-120.0f);
+    char path_buf[512] = {0};
+    snprintf(path_buf, sizeof(path_buf), "%s", m_output_path.c_str());
+    if (ImGui::InputTextWithHint("##output_path", "Path for generated config...", path_buf,
+                                 sizeof(path_buf)))
+    {
+        m_output_path = path_buf;
+        if (!m_output_path.empty())
+        {
+            m_validation_error = "";
+        }
+        if (m_is_editing_existing)
+        {
+            m_template_controller.set_template_output_path(m_template_name, m_output_path);
+        }
+    }
+    ImGui::SameLine();
+    if (ImGui::Button("Browse##output"))
+    {
+        std::string selected_path =
+            file_dialogs::save_file_dialog("Select Output File", m_output_path);
+        if (!selected_path.empty())
+        {
+            m_output_path = selected_path;
+            if (m_is_editing_existing)
+            {
+                m_template_controller.set_template_output_path(m_template_name, m_output_path);
+            }
+            m_validation_error = "";
+        }
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Path where the processed config will be written");
+
+    ImGui::AlignTextToFramePadding();
+    ImGui::Text("Reload:");
+    ImGui::SameLine(80);
+    ImGui::SetNextItemWidth(-FLT_MIN);
+    char reload_buf[512] = {0};
+    snprintf(reload_buf, sizeof(reload_buf), "%s", m_reload_command.c_str());
+    if (ImGui::InputTextWithHint("##reload_cmd", "Command to reload app (optional)...", reload_buf,
+                                 sizeof(reload_buf)))
+    {
+        m_reload_command = reload_buf;
+        if (m_is_editing_existing)
+        {
+            m_template_controller.set_template_reload_command(m_template_name, m_reload_command);
+        }
+    }
+    if (ImGui::IsItemHovered())
+        ImGui::SetTooltip("Shell command to run after applying theme (e.g., 'pkill -USR1 kitty')");
+
+    if (!m_validation_error.empty())
+    {
+        ImGui::Spacing();
+        ImVec4 error_color = palette_utils::get_color(m_current_palette, "error", "accent");
+        ImGui::PushStyleColor(ImGuiCol_Text, error_color);
+        ImGui::TextWrapped("%s", m_validation_error.c_str());
+        ImGui::PopStyleColor();
+    }
+}
+
+void template_editor::render_editor()
+{
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 4));
+
+    if (!m_is_editing_existing)
+    {
+        ImVec4 success_color = palette_utils::get_color(m_current_palette, "success", "accent");
+        ImGui::PushStyleColor(ImGuiCol_Text, success_color);
+        ImGui::Text("  New Template");
+        ImGui::PopStyleColor();
+    }
+    else
+    {
+        ImGui::Text("  %s", m_template_name.c_str());
+        auto trim_right = [](const std::string &s) -> std::string {
+            size_t end = s.find_last_not_of("\r\n");
+            return (end == std::string::npos) ? "" : s.substr(0, end + 1);
+        };
+
+        std::string current_content = trim_right(m_editor.GetText());
+        std::string saved_content = trim_right(m_saved_content);
+
+        m_has_unsaved_changes = (current_content != saved_content);
+        if (m_has_unsaved_changes)
+        {
+            ImGui::SameLine();
+            ImVec4 warning_color = palette_utils::get_color(m_current_palette, "warning", "accent");
+            ImGui::PushStyleColor(ImGuiCol_Text, warning_color);
+            ImGui::Text("(unsaved)");
+            ImGui::PopStyleColor();
+        }
+    }
+
+    ImGui::PopStyleVar();
+    ImGui::Separator();
+
+    bool consume_keys = false;
+
+    if (m_show_autocomplete && ImGui::IsKeyPressed(ImGuiKey_Escape, false))
+    {
+        m_show_autocomplete = false;
+        m_autocomplete_dismissed = true;
+
+        m_dismiss_position = m_editor.GetCursorPosition();
+
+        std::string line = m_editor.GetCurrentLineText();
+        m_dismiss_brace_pos = -1;
+        for (int i = m_dismiss_position.mColumn - 1; i >= 0; --i)
+        {
+            if (i < (int)line.length() && line[i] == '{')
+            {
+                m_dismiss_brace_pos = i;
+                break;
+            }
+        }
+
+        consume_keys = true;
+    }
+    else if (m_show_autocomplete && !m_autocomplete_suggestions.empty())
+    {
+        int max_visible = std::min((int)m_autocomplete_suggestions.size(), 8);
+
+        if (ImGui::IsKeyPressed(ImGuiKey_DownArrow, false))
+        {
+            m_autocomplete_selected = (m_autocomplete_selected + 1) % max_visible;
+            consume_keys = true;
+        }
+        else if (ImGui::IsKeyPressed(ImGuiKey_UpArrow, false))
+        {
+            m_autocomplete_selected = (m_autocomplete_selected - 1 + max_visible) % max_visible;
+            consume_keys = true;
+        }
+        else if (ImGui::IsKeyPressed(ImGuiKey_Tab, false) ||
+                 ImGui::IsKeyPressed(ImGuiKey_Enter, false))
+        {
+            auto start = m_autocomplete_start_pos;
+            auto end = m_editor.GetCursorPosition();
+            m_editor.SetSelection(start, end);
+            m_editor.Delete();
+            m_editor.InsertText(m_autocomplete_suggestions[m_autocomplete_selected] + "}");
+            m_show_autocomplete = false;
+            m_autocomplete_dismissed = false;
+            consume_keys = true;
+        }
+    }
+
+    if (consume_keys)
+    {
+        m_editor.SetHandleKeyboardInputs(false);
+    }
+
+    ImVec2 editor_pos = ImGui::GetCursorScreenPos();
+
+    m_editor.Render("##TemplateEditor", ImVec2(0, 0), true);
+
+    if (consume_keys)
+    {
+        m_editor.SetHandleKeyboardInputs(true);
+    }
+
+    update_autocomplete_suggestions();
+    render_autocomplete(editor_pos);
+}
+
+void template_editor::render_template_list()
+{
+    ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 6));
+
+    ImGui::Text("Templates");
+    ImGui::SameLine(ImGui::GetContentRegionAvail().x - 20);
+    ImGui::TextDisabled("(%d)", (int)m_template_controller.templates().size());
+    ImGui::Separator();
+
+    if (!m_is_editing_existing)
+    {
+        ImVec4 success_color = palette_utils::get_color(m_current_palette, "success", "accent");
+        ImVec4 success_bg = ImVec4(success_color.x, success_color.y, success_color.z, 0.5f);
+        ImGui::PushStyleColor(ImGuiCol_Text, success_color);
+        ImGui::PushStyleColor(ImGuiCol_Header, success_bg);
+        ImGui::Selectable("+ New Template", true);
+        ImGui::PopStyleColor(2);
+        ImGui::Separator();
+    }
+
+    const auto &templates = m_template_controller.templates();
+
+    for (const auto &[key, tmpl] : templates)
+    {
+        const bool selected = (m_template_name == key && m_is_editing_existing);
+
+        if (!tmpl.enabled())
+        {
+            ImVec4 disabled_color = palette_utils::get_color(
+                m_current_palette, "on_surface_variant", "editor_inactive");
+            ImGui::PushStyleColor(ImGuiCol_Text, disabled_color);
+        }
+
+        if (ImGui::Selectable(key.c_str(), selected))
+        {
+            load_template(key);
+        }
+
+        if (!tmpl.enabled())
+        {
+            ImGui::PopStyleColor();
+        }
+
+        if (ImGui::IsItemHovered())
+        {
+            ImGui::BeginTooltip();
+            ImGui::Text("Template: %s", key.c_str());
+            ImGui::Separator();
+            ImGui::Text("Status: %s", tmpl.enabled() ? "Enabled" : "Disabled");
+            if (!tmpl.output_path().empty())
+                ImGui::Text("Output: %s", tmpl.output_path().c_str());
+            ImGui::EndTooltip();
+        }
+    }
+
+    ImGui::PopStyleVar();
+}
+
+bool template_editor::is_valid_path(const std::string &path)
+{
+    const std::string invalid_chars = "<>|\"";
+    for (const char c : invalid_chars)
+    {
+        if (path.find(c) != std::string::npos)
+        {
+            return false;
+        }
+    }
+
+    if (path.find_first_not_of(" \t\n\r./\\") == std::string::npos)
+    {
+        return false;
+    }
+
+    try
+    {
+        std::filesystem::path fs_path(path);
+
+        const auto parent = fs_path.parent_path();
+
+        if (parent.empty())
+        {
+            return false;
+        }
+
+        if (!parent.empty() && !std::filesystem::exists(parent))
+        {
+            if (parent.string().find_first_of("<>|\"") != std::string::npos)
+            {
+                return false;
+            }
+        }
+
+        const auto filename = fs_path.filename().string();
+        if (filename.empty() || filename == "." || filename == "..")
+        {
+            return false;
+        }
+
+        return true;
+    }
+    catch (...)
+    {
+        return false;
+    }
+}
+
+void template_editor::save_template()
+{
+    std::string trimmed_name = m_template_name;
+    trimmed_name.erase(0, trimmed_name.find_first_not_of(" \t\n\r"));
+    trimmed_name.erase(trimmed_name.find_last_not_of(" \t\n\r") + 1);
+
+    std::string trimmed_input_path = m_input_path;
+    trimmed_input_path.erase(0, trimmed_input_path.find_first_not_of(" \t\n\r"));
+    trimmed_input_path.erase(trimmed_input_path.find_last_not_of(" \t\n\r") + 1);
+
+    std::string trimmed_path = m_output_path;
+    trimmed_path.erase(0, trimmed_path.find_first_not_of(" \t\n\r"));
+    trimmed_path.erase(trimmed_path.find_last_not_of(" \t\n\r") + 1);
+
+    if (trimmed_name.empty())
+    {
+        m_validation_error = "Error: Template name cannot be empty!";
+        return;
+    }
+
+    if (trimmed_input_path.empty())
+    {
+        m_validation_error = "Error: Input path cannot be empty!";
+        return;
+    }
+
+    if (trimmed_path.empty())
+    {
+        m_validation_error = "Error: Output path cannot be empty!";
+        return;
+    }
+
+    if (!is_valid_path(trimmed_path))
+    {
+        m_validation_error =
+            "Error: Output path is invalid! Must be a valid file path with directory.";
+        return;
+    }
+
+    m_validation_error = "";
+
+    auto &cfg = clrsync::core::config::instance();
+
+    std::filesystem::path template_file = clrsync::core::normalize_path(trimmed_input_path);
+
+    auto parent_dir = template_file.parent_path();
+    if (!parent_dir.empty() && !std::filesystem::exists(parent_dir))
+    {
+        try
+        {
+            std::filesystem::create_directories(parent_dir);
+        }
+        catch (const std::exception &e)
+        {
+            m_validation_error = "Error: Could not create directory for input path";
+            return;
+        }
+    }
+
+    std::string template_content = m_editor.GetText();
+
+    std::ofstream out(template_file);
+    if (!out.is_open())
+    {
+        m_validation_error = "Failed to write template file";
+        return;
+    }
+
+    out << template_content;
+    out.close();
+
+    clrsync::core::theme_template tmpl(trimmed_name, template_file.string(), trimmed_path);
+    tmpl.set_reload_command(m_reload_command);
+    tmpl.set_enabled(m_enabled);
+
+    auto result = cfg.update_template(trimmed_name, tmpl);
+    if (!result)
+    {
+        m_validation_error = "Error saving template: " + result.error().description();
+        return;
+    }
+
+    m_template_name = trimmed_name;
+    m_input_path = trimmed_input_path;
+    m_output_path = trimmed_path;
+    m_is_editing_existing = true;
+    m_saved_content = m_editor.GetText();
+    m_has_unsaved_changes = false;
+
+    refresh_templates();
+}
+
+void template_editor::load_template(const std::string &name)
+{
+    const auto &templates = m_template_controller.templates();
+    auto it = templates.find(name);
+
+    if (it != templates.end())
+    {
+        const auto &tmpl = it->second;
+        m_template_name = name;
+        m_input_path = tmpl.template_path();
+        m_output_path = tmpl.output_path();
+        m_reload_command = tmpl.reload_command();
+        m_enabled = tmpl.enabled();
+        m_is_editing_existing = true;
+        m_validation_error = "";
+
+        std::ifstream in(tmpl.template_path());
+        if (in.is_open())
+        {
+            std::string content;
+            std::string line;
+            while (std::getline(in, line))
+            {
+                content += line + "\n";
+            }
+            in.close();
+
+            m_editor.SetText(content);
+            m_saved_content = content;
+            m_has_unsaved_changes = false;
+        }
+        else
+        {
+            m_validation_error = "Error loading template: Failed to open file";
+        }
+    }
+}
+
+void template_editor::new_template()
+{
+    m_template_name = "new_template";
+    std::string default_content =
+        "# Enter your template here\n# Use {color_key} for color variables\n# "
+        "Examples: {color.hex}, {color.rgb}, {color.r}\n\n";
+    m_editor.SetText(default_content);
+    m_saved_content = default_content;
+    m_input_path = "";
+    m_output_path = "";
+    m_reload_command = "";
+    m_enabled = true;
+    m_is_editing_existing = false;
+    m_validation_error = "";
+    m_has_unsaved_changes = false;
+}
+
+void template_editor::delete_template()
+{
+    if (!m_is_editing_existing || m_template_name.empty())
+        return;
+
+    m_show_delete_confirmation = true;
+}
+
+void template_editor::refresh_templates()
+{
+    m_template_controller.refresh();
+}
--- a/src/gui/views/template_editor.hpp
+++ b/src/gui/views/template_editor.hpp
@@ -0,0 +1,67 @@
+#ifndef CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
+#define CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
+
+#include "color_text_edit/TextEditor.h"
+#include "core/palette/palette.hpp"
+#include "gui/controllers/template_controller.hpp"
+#include "imgui.h"
+#include <string>
+#include <vector>
+
+class template_editor
+{
+  public:
+    template_editor();
+    void render();
+    void apply_current_palette(const clrsync::core::palette &pal);
+
+  private:
+    void render_controls();
+    void render_editor();
+    void render_template_list();
+    void render_autocomplete(const ImVec2 &editor_pos);
+    void update_autocomplete_suggestions();
+
+    void save_template();
+    void load_template(const std::string &name);
+    void new_template();
+    void delete_template();
+    void refresh_templates();
+
+    bool is_valid_path(const std::string &path);
+
+    template_controller m_template_controller;
+    TextEditor m_editor;
+
+    std::string m_template_name;
+    std::string m_input_path;
+    std::string m_output_path;
+    std::string m_reload_command;
+    std::string m_validation_error;
+    std::string m_saved_content;
+    bool m_has_unsaved_changes = false;
+
+    bool m_enabled{true};
+    bool m_is_editing_existing{false};
+    bool m_show_delete_confirmation{false};
+
+    bool m_show_autocomplete{false};
+    bool m_autocomplete_dismissed{false};
+    TextEditor::Coordinates m_dismiss_position;
+    int m_dismiss_brace_pos{-1};
+    std::vector<std::string> m_autocomplete_suggestions;
+    int m_autocomplete_selected{0};
+    std::string m_autocomplete_prefix;
+    TextEditor::Coordinates m_autocomplete_start_pos;
+
+    ImVec4 m_autocomplete_bg_color;
+    ImVec4 m_autocomplete_border_color;
+    ImVec4 m_autocomplete_selected_color;
+    ImVec4 m_autocomplete_text_color;
+    ImVec4 m_autocomplete_selected_text_color;
+    ImVec4 m_autocomplete_dim_text_color;
+
+    clrsync::core::palette m_current_palette;
+};
+
+#endif // CLRSYNC_GUI_TEMPLATE_EDITOR_HPP
Author	SHA1	Message	Date
Daniel Dada	5b641cdd02	fix: typo in font_loader.windows	2025-12-19 08:21:37 +03:00
Daniel Dada	dff3e916fe	bump version	2025-12-19 00:23:02 +03:00
Daniel Dada	2d653834a5	fix(nixos): write to config.temp.toml if config.toml is unwriteable	2025-12-19 00:19:26 +03:00
Daniel Dada	9be0a159ea	fixed limux build	2025-12-18 23:53:06 +03:00
Daniel Dada	0288773ccb	revert removed deps	2025-12-18 23:33:04 +03:00
Daniel Dada	c68ca3dabe	wip: moving backend-related stuff out of the app logic	2025-12-18 16:45:49 +03:00
Daniel Dada	292a748ac4	chore: minor adjustments	2025-12-18 14:57:15 +03:00
Daniel Dada	7641846600	chore: structured src/gui, run clang-format	2025-12-18 13:23:50 +03:00
Daniel Dada	613c2c80f5	build: fix msvc builds	2025-12-18 11:51:28 +03:00
Daniel Dada	1a1747a472	chore: got build working on mac (kind of)	2025-12-18 01:29:32 +03:00
Daniel Dada	57c3c55a94	bump version	2025-12-18 00:45:10 +03:00
Daniel Dada	d4ff415f45	fix: gtk dialogs freezing	2025-12-18 00:42:47 +03:00
Daniel Dada	4c0502d8ee	fix missing XDG_DATA_DIRS on NixOS	2025-12-18 00:11:55 +03:00
Daniel Dada	0acb36445f	adjusted default theme	2025-12-17 16:13:14 +03:00
Daniel Dada	b08ba4d754	fix: coloring	2025-12-17 15:49:48 +03:00
Daniel Dada	231e9f0176	updated preview	2025-12-17 14:46:32 +03:00
Daniel Dada	b98761a172	chore: fixed build deps	2025-12-17 13:42:48 +03:00
Daniel Dada	92b06a9e0c	bump version	2025-12-17 13:33:25 +03:00
Daniel Dada	019b0db522	build: added gtk dep	2025-12-17 13:32:26 +03:00
Daniel Dada	58eff4d97e	chore: cleanup the ui	2025-12-17 13:14:46 +03:00
Daniel Dada	b4ca5e1912	feat: autocomplete in template editor	2025-12-17 11:45:46 +03:00
Daniel Dada	899a5d50c4	removed eyedropper for now	2025-12-17 10:45:35 +03:00
Daniel Dada	2813a8bd05	feat: added eyedropper	2025-12-17 10:21:33 +03:00
Daniel Dada	e6bac8e220	feat: init palettes with default colorscheme to avoid messed up UI	2025-12-17 09:50:14 +03:00
Daniel Dada	5bb8a687ea	fix: added delete confirmation dialog in color_scheme_editor	2025-12-17 08:37:15 +03:00
Daniel Dada	10516212bf	fix (fonts): load exact match	2025-12-17 08:32:56 +03:00
Daniel Dada	89888adf8d	chore: add doc link	2025-12-17 03:11:15 +03:00
Daniel Dada	c58ff17289	feat: font selector	2025-12-17 03:06:24 +03:00
Daniel Dada	ef0854aa39	fix: normalize paths	2025-12-17 02:58:23 +03:00
Daniel Dada	1c2486d476	feat: allow to remove templates	2025-12-17 02:49:52 +03:00
Daniel Dada	d4c563f585	refactor: error handling with err objects	2025-12-17 02:25:21 +03:00
Daniel Dada	f7c290110e	chore: split color_scheme_editor	2025-12-17 01:41:44 +03:00
Daniel Dada	659c5f28e5	versioning	2025-12-16 00:37:18 +03:00
Daniel Dada	cd817446b0	versioning (WIP)	2025-12-15 23:46:47 +03:00
Daniel Dada	a5d6503305	set version in flake	2025-12-15 21:10:23 +03:00
Daniel Dada	8a2b224fd3	set git version	2025-12-15 20:55:54 +03:00
Daniel Dada	4b4af0f8fe	updated test flake workflow	2025-12-15 13:23:31 +03:00
Daniel Dada	d40b436461	updated readme	2025-12-15 13:22:29 +03:00