From 73f716da84d42f6f1d0f09c6cdd88c80f540393a Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sat, 3 May 2025 16:19:38 +0200
Subject: [PATCH 01/23] refactor: new project parser

---
 CMakeLists.txt                                |  37 +-
 .../Application/CWallpaperApplication.cpp     |  21 +-
 .../Assets/CCombinedContainer.cpp             |   6 +-
 .../Assets/CCombinedContainer.h               |   4 +-
 src/WallpaperEngine/Assets/CContainer.h       |   1 +
 src/WallpaperEngine/Core/Core.cpp             |   4 +-
 .../Core/DynamicValues/CDynamicValue.h        |  11 +
 src/WallpaperEngine/Core/Projects/CProperty.h |   4 +
 .../Core/UserSettings/CUserSettingBoolean.cpp |  11 +-
 .../Core/UserSettings/CUserSettingBoolean.h   |   2 +-
 .../Core/UserSettings/CUserSettingFloat.cpp   |  11 +-
 .../Core/UserSettings/CUserSettingFloat.h     |   2 +-
 .../Core/UserSettings/CUserSettingVector3.cpp |  11 +-
 .../Core/UserSettings/CUserSettingVector3.h   |   2 +-
 .../Data/Builders/UserSettingBuilder.h        |  23 +
 .../Data/Builders/VectorBuilder.cpp           |   1 +
 .../Data/Builders/VectorBuilder.h             | 178 ++++++++
 .../Data/Dumpers/StringPrinter.cpp            | 394 ++++++++++++++++++
 .../Data/Dumpers/StringPrinter.h              | 130 ++++++
 src/WallpaperEngine/Data/JSON.cpp             |  12 +
 src/WallpaperEngine/Data/JSON.h               | 168 ++++++++
 src/WallpaperEngine/Data/Model/Effect.h       |  54 +++
 src/WallpaperEngine/Data/Model/Material.h     |  36 ++
 src/WallpaperEngine/Data/Model/Model.h        |  27 ++
 src/WallpaperEngine/Data/Model/Object.h       | 122 ++++++
 src/WallpaperEngine/Data/Model/Project.h      |  38 ++
 src/WallpaperEngine/Data/Model/Types.h        |  86 ++++
 src/WallpaperEngine/Data/Model/UserSetting.h  |  31 ++
 src/WallpaperEngine/Data/Model/Wallpaper.h    | 119 ++++++
 .../Data/Parsers/EffectParser.cpp             |  95 +++++
 .../Data/Parsers/EffectParser.h               |  20 +
 .../Data/Parsers/MaterialParser.cpp           |  86 ++++
 .../Data/Parsers/MaterialParser.h             |  19 +
 .../Data/Parsers/ModelParser.cpp              |  31 ++
 .../Data/Parsers/ModelParser.h                |  15 +
 .../Data/Parsers/ObjectParser.cpp             | 187 +++++++++
 .../Data/Parsers/ObjectParser.h               |  32 ++
 .../Data/Parsers/ProjectParser.cpp            |  68 +++
 .../Data/Parsers/ProjectParser.h              |  24 ++
 .../Data/Parsers/ShaderConstantParser.cpp     |  77 ++++
 .../Data/Parsers/ShaderConstantParser.h       |  15 +
 .../Data/Parsers/UserSettingParser.cpp        |  69 +++
 .../Data/Parsers/UserSettingParser.h          |  16 +
 .../Data/Parsers/WallpaperParser.cpp          | 106 +++++
 .../Data/Parsers/WallpaperParser.h            |  20 +
 src/WallpaperEngine/Data/Utils/TypeCaster.cpp |   1 +
 src/WallpaperEngine/Data/Utils/TypeCaster.h   |  36 ++
 47 files changed, 2429 insertions(+), 34 deletions(-)
 create mode 100644 src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
 create mode 100644 src/WallpaperEngine/Data/Builders/VectorBuilder.cpp
 create mode 100644 src/WallpaperEngine/Data/Builders/VectorBuilder.h
 create mode 100644 src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
 create mode 100644 src/WallpaperEngine/Data/Dumpers/StringPrinter.h
 create mode 100644 src/WallpaperEngine/Data/JSON.cpp
 create mode 100644 src/WallpaperEngine/Data/JSON.h
 create mode 100644 src/WallpaperEngine/Data/Model/Effect.h
 create mode 100644 src/WallpaperEngine/Data/Model/Material.h
 create mode 100644 src/WallpaperEngine/Data/Model/Model.h
 create mode 100644 src/WallpaperEngine/Data/Model/Object.h
 create mode 100644 src/WallpaperEngine/Data/Model/Project.h
 create mode 100644 src/WallpaperEngine/Data/Model/Types.h
 create mode 100644 src/WallpaperEngine/Data/Model/UserSetting.h
 create mode 100644 src/WallpaperEngine/Data/Model/Wallpaper.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/EffectParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/EffectParser.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/MaterialParser.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/ModelParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/ModelParser.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/ObjectParser.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/ProjectParser.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/UserSettingParser.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/WallpaperParser.h
 create mode 100644 src/WallpaperEngine/Data/Utils/TypeCaster.cpp
 create mode 100644 src/WallpaperEngine/Data/Utils/TypeCaster.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d999b35..57bea0f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -198,7 +198,8 @@ if(X11_SUPPORT_FOUND)
         src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp
         src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
         src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp
-        src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h)
+        src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h
+            src/WallpaperEngine/Data/Model/UserSetting.h)
     SET(X11_INCLUDES
         ${X11_INCLUDE_DIR}
         ${XRANDR_INCLUDE_DIR})
@@ -510,9 +511,41 @@ add_executable(
     src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
     src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
 
+    src/WallpaperEngine/Data/Model/Types.h
+    src/WallpaperEngine/Data/Model/Project.h
+    src/WallpaperEngine/Data/Model/Wallpaper.h
+    src/WallpaperEngine/Data/Model/Object.h
+    src/WallpaperEngine/Data/Model/Material.h
+    src/WallpaperEngine/Data/Model/Effect.h
+    src/WallpaperEngine/Data/Model/Model.h
+    src/WallpaperEngine/Data/Utils/TypeCaster.cpp
+    src/WallpaperEngine/Data/Utils/TypeCaster.h
+    src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+    src/WallpaperEngine/Data/Parsers/ProjectParser.h
+    src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
+    src/WallpaperEngine/Data/Parsers/WallpaperParser.h
+    src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
+    src/WallpaperEngine/Data/Parsers/UserSettingParser.h
+    src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
+    src/WallpaperEngine/Data/Parsers/ObjectParser.h
+    src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
+    src/WallpaperEngine/Data/Parsers/MaterialParser.h
+    src/WallpaperEngine/Data/Parsers/ModelParser.cpp
+    src/WallpaperEngine/Data/Parsers/ModelParser.h
+    src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
+    src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
+    src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
+    src/WallpaperEngine/Data/Builders/VectorBuilder.cpp
+    src/WallpaperEngine/Data/Builders/VectorBuilder.h
+
     ${WAYLAND_SOURCES}
     ${X11_SOURCES}
-    ${DEMOMODE_SOURCES})
+    ${DEMOMODE_SOURCES}
+        src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
+        src/WallpaperEngine/Data/Dumpers/StringPrinter.h
+        src/WallpaperEngine/Data/JSON.cpp
+        src/WallpaperEngine/Data/Parsers/EffectParser.cpp
+        src/WallpaperEngine/Data/Parsers/EffectParser.h)
 
 target_link_libraries (linux-wallpaperengine PUBLIC
     ${OPENGL_LIBRARIES}
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index 0c118e1..a83baf3 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -12,6 +12,9 @@
 #include "WallpaperEngine/Core/Wallpapers/CWeb.h"
 #include "WallpaperEngine/Render/Drivers/CVideoFactories.h"
 
+#include "WallpaperEngine/Data/Parsers/ProjectParser.h"
+#include "WallpaperEngine/Data/Dumpers/StringPrinter.h"
+
 #if DEMOMODE
 #include "recording.h"
 #endif /* DEMOMODE */
@@ -37,18 +40,18 @@ CWallpaperApplication::CWallpaperApplication (CApplicationContext& context) :
 void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedContainer>& container, const std::string& bg) const {
     const std::filesystem::path basepath = bg;
 
-    container->add (std::make_shared<CDirectory> (basepath));
+    container->add (std::make_unique<CDirectory> (basepath));
     container->addPkg (basepath / "scene.pkg");
     container->addPkg (basepath / "gifscene.pkg");
 
     try {
-        container->add (std::make_shared <CDirectory> (this->m_context.settings.general.assets));
+        container->add (std::make_unique <CDirectory> (this->m_context.settings.general.assets));
     } catch (CAssetLoadException&) {
         sLog.exception ("Cannot find a valid assets folder, resolved to ", this->m_context.settings.general.assets);
     }
 
     // TODO: move this somewhere else?
-    auto virtualContainer = std::make_shared <CVirtualContainer> ();
+    auto virtualContainer = std::make_unique <CVirtualContainer> ();
 
     //
     // Had to get a little creative with the effects to achieve the same bloom effect without any custom code
@@ -181,7 +184,7 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
         "}"
     );
 
-    container->add (virtualContainer);
+    container->add (std::move(virtualContainer));
 }
 
 void CWallpaperApplication::loadBackgrounds () {
@@ -206,6 +209,16 @@ std::shared_ptr<Core::CProject> CWallpaperApplication::loadBackground (const std
 
     this->setupContainer (container, bg);
 
+    // do the parsing with the new parser first
+    auto json = WallpaperEngine::Data::JSON::JSON::parse (container->readFileAsString ("project.json"));
+    const auto project = WallpaperEngine::Data::Parsers::ProjectParser::parse (json, container);
+
+    auto dumper = WallpaperEngine::Data::Dumpers::StringPrinter ();
+
+    dumper.printWallpaper (*project->wallpaper);
+
+    std::cout << dumper.str () << std::endl;
+
     return Core::CProject::fromFile ("project.json", container);
 }
 
diff --git a/src/WallpaperEngine/Assets/CCombinedContainer.cpp b/src/WallpaperEngine/Assets/CCombinedContainer.cpp
index b4fb32d..c34104b 100644
--- a/src/WallpaperEngine/Assets/CCombinedContainer.cpp
+++ b/src/WallpaperEngine/Assets/CCombinedContainer.cpp
@@ -8,14 +8,14 @@ using namespace WallpaperEngine::Assets;
 
 CCombinedContainer::CCombinedContainer () : CContainer () {}
 
-void CCombinedContainer::add (const std::shared_ptr<CContainer>& container) {
-    this->m_containers.emplace_back (container);
+void CCombinedContainer::add (std::unique_ptr<CContainer> container) {
+    this->m_containers.emplace_back (std::move(container));
 }
 
 void CCombinedContainer::addPkg (const std::filesystem::path& path) {
     try {
         // add the package to the list
-        this->add (std::make_shared<CPackage> (path));
+        this->add (std::make_unique<CPackage> (path));
         sLog.out ("Detected ", path.filename (), " file at ", path, ". Adding to list of searchable paths");
     } catch (CPackageLoadException&) {
         // ignore this error, the package file was not found
diff --git a/src/WallpaperEngine/Assets/CCombinedContainer.h b/src/WallpaperEngine/Assets/CCombinedContainer.h
index 147962e..7d15bb7 100644
--- a/src/WallpaperEngine/Assets/CCombinedContainer.h
+++ b/src/WallpaperEngine/Assets/CCombinedContainer.h
@@ -19,7 +19,7 @@ class CCombinedContainer final : public CContainer {
      *
      * @param container
      */
-    void add (const std::shared_ptr<CContainer>& container);
+    void add (std::unique_ptr<CContainer> container);
     /**
      * Adds the given package to the list
      *
@@ -32,6 +32,6 @@ class CCombinedContainer final : public CContainer {
 
   private:
     /** The list of containers to search files off from */
-    std::vector<std::shared_ptr<CContainer>> m_containers {};
+    std::vector<std::unique_ptr<CContainer>> m_containers {};
 };
 }; // namespace WallpaperEngine::Assets
\ No newline at end of file
diff --git a/src/WallpaperEngine/Assets/CContainer.h b/src/WallpaperEngine/Assets/CContainer.h
index e77228c..4990145 100644
--- a/src/WallpaperEngine/Assets/CContainer.h
+++ b/src/WallpaperEngine/Assets/CContainer.h
@@ -6,6 +6,7 @@
 #include <string>
 
 namespace WallpaperEngine::Assets {
+
 /**
  * File container, provides access to files for backgrounds
  */
diff --git a/src/WallpaperEngine/Core/Core.cpp b/src/WallpaperEngine/Core/Core.cpp
index 176dc99..93effef 100644
--- a/src/WallpaperEngine/Core/Core.cpp
+++ b/src/WallpaperEngine/Core/Core.cpp
@@ -509,7 +509,7 @@ template <typename T> const T* Core::jsonFindUserConfig (
     if (it == data->end () || it->type () == nlohmann::detail::value_t::null)
         return T::fromScalar (defaultValue);
 
-    return T::fromJSON (*it, project);
+    return T::fromJSON (*it, project.getProperties ());
 }
 
 template const CUserSettingBoolean* Core::jsonFindUserConfig (
@@ -530,7 +530,7 @@ template <typename T> const T* Core::jsonFindUserConfig (
     if (it == data.end () || it->type () == nlohmann::detail::value_t::null)
         return T::fromScalar (defaultValue);
 
-    return T::fromJSON (*it, project);
+    return T::fromJSON (*it, project.getProperties ());
 }
 
 template const CUserSettingBoolean* Core::jsonFindUserConfig (
diff --git a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
index c971283..177cb97 100644
--- a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
+++ b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
@@ -5,8 +5,19 @@
 #include <vector>
 #include <glm/glm.hpp>
 
+namespace WallpaperEngine::Data::Parsers {
+class UserSettingParser;
+}
+
+namespace WallpaperEngine::Data::Builders {
+class UserSettingBuilder;
+}
+
 namespace WallpaperEngine::Core::DynamicValues {
 class CDynamicValue {
+    //TODO: THIS SHOULD BE CHANGED ONCE THINGS ARE FINISHED
+    friend class WallpaperEngine::Data::Parsers::UserSettingParser;
+    friend class WallpaperEngine::Data::Builders::UserSettingBuilder;
   public:
     virtual ~CDynamicValue ();
 
diff --git a/src/WallpaperEngine/Core/Projects/CProperty.h b/src/WallpaperEngine/Core/Projects/CProperty.h
index cc179c9..f172ae4 100644
--- a/src/WallpaperEngine/Core/Projects/CProperty.h
+++ b/src/WallpaperEngine/Core/Projects/CProperty.h
@@ -14,6 +14,10 @@ using namespace WallpaperEngine::Core::DynamicValues;
  */
 class CProperty : public CDynamicValue {
   public:
+    using UniquePtr = std::unique_ptr<CProperty>;
+    using SharedPtr = std::shared_ptr<CProperty>;
+    using WeakPtr = std::weak_ptr<CProperty>;
+
     typedef std::function<void(const CProperty*)> function_type;
     virtual ~CProperty () = default;
     static std::shared_ptr<CProperty> fromJSON (const json& data, const std::string& name);
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
index aea3a1a..d2d8611 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
@@ -39,7 +39,7 @@ CUserSettingBoolean::CUserSettingBoolean (
     }
 }
 
-const CUserSettingBoolean* CUserSettingBoolean::fromJSON (const nlohmann::json& data, const CProject& project) {
+const CUserSettingBoolean* CUserSettingBoolean::fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties) {
     bool hasCondition = false;
     std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
     bool defaultValue;
@@ -61,11 +61,10 @@ const CUserSettingBoolean* CUserSettingBoolean::fromJSON (const nlohmann::json&
                     jsonFindRequired <std::string> (userIt, "condition", "Condition for conditional setting must be present");
             }
 
-            for (const auto& [key, property] : project.getProperties ()) {
-                if (key == source) {
-                    sourceProperty = property;
-                    break;
-                }
+            const auto propertyIt = properties.find (source);
+
+            if (propertyIt != properties.end ()) {
+                sourceProperty = propertyIt->second;
             }
 
             if (sourceProperty == nullptr) {
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
index 71188b1..ebfd4a0 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
@@ -12,7 +12,7 @@ class CUserSettingBoolean : public CUserSettingValue {
   public:
     typedef bool data_type;
 
-    static const CUserSettingBoolean* fromJSON (const nlohmann::json& data, const CProject& project);
+    static const CUserSettingBoolean* fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties);
     static const CUserSettingBoolean* fromScalar (bool value);
 
   private:
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
index d6ebe34..36d58e9 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
@@ -33,7 +33,7 @@ CUserSettingFloat::CUserSettingFloat (
     }
 }
 
-const CUserSettingFloat* CUserSettingFloat::fromJSON (const nlohmann::json& data, const CProject& project) {
+const CUserSettingFloat* CUserSettingFloat::fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties) {
     float defaultValue;
     std::string source;
     std::string expectedValue;
@@ -55,11 +55,10 @@ const CUserSettingFloat* CUserSettingFloat::fromJSON (const nlohmann::json& data
                     jsonFindRequired <std::string> (userIt, "condition", "Condition for conditional setting must be present");
             }
 
-            for (const auto& [key, property] : project.getProperties ()) {
-                if (key == source) {
-                    sourceProperty = property;
-                    break;
-                }
+            const auto propertyIt = properties.find (source);
+
+            if (propertyIt != properties.end ()) {
+                sourceProperty = propertyIt->second;
             }
 
             if (sourceProperty == nullptr) {
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
index b359e63..72c13ad 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
@@ -12,7 +12,7 @@ class CUserSettingFloat : public CUserSettingValue {
   public:
     typedef float data_type;
 
-    static const CUserSettingFloat* fromJSON (const nlohmann::json& data, const CProject& project);
+    static const CUserSettingFloat* fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties);
     static const CUserSettingFloat* fromScalar (float value);
 
   private:
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
index aa1e2da..a1c7659 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
@@ -33,7 +33,7 @@ CUserSettingVector3::CUserSettingVector3 (
     }
 }
 
-const CUserSettingVector3* CUserSettingVector3::fromJSON (const nlohmann::json& data, const CProject& project) {
+const CUserSettingVector3* CUserSettingVector3::fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties) {
     bool hasCondition = false;
     std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
     glm::vec3 defaultValue;
@@ -55,11 +55,10 @@ const CUserSettingVector3* CUserSettingVector3::fromJSON (const nlohmann::json&
                     jsonFindRequired <std::string> (userIt, "condition", "Condition for conditional setting must be present");
             }
 
-            for (const auto& [key, property] : project.getProperties ()) {
-                if (key == source) {
-                    sourceProperty = property;
-                    break;
-                }
+            const auto propertyIt = properties.find (source);
+
+            if (propertyIt != properties.end ()) {
+                sourceProperty = propertyIt->second;
             }
 
             if (sourceProperty == nullptr) {
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
index b3d5735..c9609bc 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
@@ -14,7 +14,7 @@ class CUserSettingVector3 : public CUserSettingValue {
   public:
     typedef glm::vec3 data_type;
 
-    static const CUserSettingVector3* fromJSON (const nlohmann::json& data, const CProject& project);
+    static const CUserSettingVector3* fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties);
     static const CUserSettingVector3* fromScalar (glm::vec3 value);
 
   private:
diff --git a/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
new file mode 100644
index 0000000..fbd63c9
--- /dev/null
+++ b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "WallpaperEngine/Data/Model/Types.h"
+#include "WallpaperEngine/Data/Model/UserSetting.h"
+
+namespace WallpaperEngine::Data::Builders {
+using namespace WallpaperEngine::Data::Model;
+class UserSettingBuilder {
+  public:
+    template <typename T>
+    static UserSettingSharedPtr fromValue (T defaultValue) {
+        DynamicValueUniquePtr value = std::make_unique <DynamicValue> ();
+
+        value->update (defaultValue);
+
+        return std::make_shared <UserSetting> (UserSetting {
+            .value = std::move (value),
+            .property = PropertyWeakPtr (),
+            .condition = std::nullopt,
+        });
+    }
+};
+} // namespace WallpaperEngine::Data::Builders
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Builders/VectorBuilder.cpp b/src/WallpaperEngine/Data/Builders/VectorBuilder.cpp
new file mode 100644
index 0000000..03d62e2
--- /dev/null
+++ b/src/WallpaperEngine/Data/Builders/VectorBuilder.cpp
@@ -0,0 +1 @@
+#include "VectorBuilder.h"
diff --git a/src/WallpaperEngine/Data/Builders/VectorBuilder.h b/src/WallpaperEngine/Data/Builders/VectorBuilder.h
new file mode 100644
index 0000000..5bf6f17
--- /dev/null
+++ b/src/WallpaperEngine/Data/Builders/VectorBuilder.h
@@ -0,0 +1,178 @@
+#pragma once
+
+#include <cstring>
+#include <string>
+#include <glm/glm.hpp>
+
+#include "WallpaperEngine/Logging/CLog.h"
+
+namespace WallpaperEngine::Data::Builders {
+class VectorBuilder {
+  private:
+    /**
+     * Convert template that calls the proper std::strto* function
+     * based on the incoming type
+     *
+     * @tparam type
+     * @param str
+     * @return
+     */
+    template <typename type>
+    static type convert (const char* str);
+
+  public:
+    /**
+     * Takes the string and returns the vector size (2, 3 or 4)
+     *
+     * TODO: THIS SHOULD BE MOVED, RENAMED OR PLACED SOMEWHERE WHERE IT MAKES MORE SENSE
+     *
+     * @param str
+     * @return
+     */
+    static int preparseSize (const std::string& str) {
+        const char* p = str.c_str ();
+        const char* first = strchr (p, ' ');
+        const char* second = first ? strchr (first + 1, ' ') : nullptr;
+        const char* third = second ? strchr (second + 1, ' ') : nullptr;
+
+        if (first == nullptr) {
+            sLog.exception ("Invalid vector format: " + str + " (too few values, expected: 2, 3 or 4)");
+        } else if (second == nullptr) {
+            return 2;
+        } else if (third == nullptr) {
+            return 3;
+        } else {
+            return 4;
+        }
+    }
+
+    /**
+     * Takes a string value and parses it into a glm::vec.
+     * This particular parsing uses spaces as separators and basic std::strto* functions
+     * for the actual parsing of the values.
+     *
+     * @tparam length Vector length
+     * @tparam type Vector storage type
+     * @tparam qualifier Precision qualifier
+     *
+     * @param str The string to parse the vector from
+     *
+     * @return
+     */
+    template <int length, typename type, glm::qualifier qualifier>
+    static glm::vec<length, type, qualifier> parse (const std::string& str) {
+        const char* p = str.c_str ();
+
+        // get up to 4 spaces
+        const char* first = strchr (p, ' ');
+        const char* second = first ? strchr (first + 1, ' ') : nullptr;
+        const char* third = second ? strchr (second + 1, ' ') : nullptr;
+
+        // validate lengths against what was found in the strings
+        if constexpr (length == 1) {
+            if (first != nullptr) {
+                sLog.exception ("Invalid vector format: " + str + " (too many values, expected: ", length, ")");
+            }
+        } else if constexpr (length == 2) {
+            if (first == nullptr) {
+                sLog.exception ("Invalid vector format: " + str + " (too few values, expected: ", length, ")");
+            } else if (second != nullptr) {
+                sLog.exception ("Invalid vector format: " + str + " (too many values, expected: ", length, ")");
+            }
+        } else if constexpr (length == 3) {
+            if (first == nullptr || second == nullptr) {
+                sLog.exception ("Invalid vector format: " + str + " (too few values, expected: ", length, ")");
+            } else if (third != nullptr) {
+                sLog.exception ("Invalid vector format: " + str + " (too many values, expected: ", length, ")");
+            }
+        } else if constexpr (length == 4) {
+            if (first == nullptr || second == nullptr || third == nullptr) {
+                sLog.exception ("Invalid vector format: " + str + " (too few values, expected: ", length, ")");
+            }
+        } else {
+            sLog.exception ("Invalid vector length: ", length);
+        }
+
+        // lengths validated, values can be used directly without issues
+        if constexpr (length == 1) {
+            return {
+                convert <type> (p)
+            };
+        } else if constexpr (length == 2) {
+            return {
+                convert <type> (p),
+                convert <type> (first + 1)
+            };
+        } else if constexpr (length == 3) {
+            return {
+                convert <type> (p),
+                convert <type> (first + 1),
+                convert <type> (second + 1)
+            };
+        } else {
+            return {
+                convert <type> (p),
+                convert <type> (first + 1),
+                convert <type> (second + 1),
+                convert <type> (third + 1)
+            };
+        }
+    }
+};
+
+template <>
+inline float VectorBuilder::convert<float> (const char* str) {
+    return std::strtof (str, nullptr);
+}
+
+template <>
+inline int VectorBuilder::convert<int> (const char* str) {
+    return std::strtol (str, nullptr, 10);
+}
+
+template <>
+inline unsigned int VectorBuilder::convert<unsigned int> (const char* str) {
+    return std::strtoul (str, nullptr, 10);
+}
+
+template <>
+inline double VectorBuilder::convert<double> (const char* str) {
+    return std::strtod (str, nullptr);
+}
+
+template <>
+inline uint8_t VectorBuilder::convert<uint8_t> (const char* str) {
+    return std::strtoul (str, nullptr, 10);
+}
+
+template <>
+inline uint16_t VectorBuilder::convert<uint16_t> (const char* str) {
+    return std::strtoul (str, nullptr, 10);
+}
+
+template <>
+inline uint64_t VectorBuilder::convert<uint64_t> (const char* str) {
+    return std::strtoull (str, nullptr, 10);
+}
+
+template <>
+inline int8_t VectorBuilder::convert<int8_t> (const char* str) {
+    return std::strtol (str, nullptr, 10);
+}
+
+template <>
+inline int16_t VectorBuilder::convert<int16_t> (const char* str) {
+    return std::strtol (str, nullptr, 10);
+}
+
+template <>
+inline int64_t VectorBuilder::convert<int64_t> (const char* str) {
+    return std::strtoll (str, nullptr, 10);
+}
+
+template <>
+inline bool VectorBuilder::convert<bool> (const char* str) {
+    return std::strtoul (str, nullptr, 10) > 0;
+}
+
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
new file mode 100644
index 0000000..1c72c1d
--- /dev/null
+++ b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
@@ -0,0 +1,394 @@
+#include <utility>
+
+#include "StringPrinter.h"
+
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+
+using namespace WallpaperEngine::Data::Dumpers;
+using namespace WallpaperEngine::Data::Model;
+
+StringPrinter::StringPrinter (std::string indentationCharacter) :
+    m_out (&this->m_buffer),
+    m_indentationCharacter (std::move(indentationCharacter)) { }
+
+void StringPrinter::printWallpaper (const Wallpaper& wallpaper) {
+    bool isScene = wallpaper.is <Scene> ();
+    bool isVideo = wallpaper.is <Video> ();
+    bool isWeb = wallpaper.is <Web> ();
+
+    if (isVideo) {
+        const auto video = wallpaper.as <Video> ();
+
+        this->m_out << "Video wallpaper: " << video->filename;
+        this->lineEnd ();
+    } else if (isWeb) {
+        const auto web = wallpaper.as <Web> ();
+
+        this->m_out << "Web wallpaper: " << web->filename;
+        this->lineEnd ();
+    } else if (isScene) {
+        const auto scene = wallpaper.as <Scene> ();
+
+        this->m_out << "Scene wallpaper: ";
+        this->increaseIndentation ();
+        this->lineEnd ();
+
+        // TODO: IMPLEMENT FBO PRINTING, AS THIS WASN'T REALLY REFLECTION HOW IT ACTUALLY WORKS
+        this->m_out << "Objects count: " << scene->objects.size ();
+        this->increaseIndentation ();
+
+        for (const auto& object : scene->objects) {
+            this->lineEnd ();
+            this->printObject (*object.second);
+            this->lineEnd ();
+        }
+
+        this->decreaseIndentation ();
+    }
+}
+
+void StringPrinter::printObject (const Object& object) {
+    this->m_out << "Object " << object.id << " " << object.name << ":";
+    this->increaseIndentation ();
+
+    this->lineEnd ();
+    this->m_out << "Dependencies (" << object.dependencies.size () << "): ";
+
+    for (const auto& dependency : object.dependencies) {
+        this->m_out << dependency << ", ";
+    }
+
+    if (object.is <Image> ()) {
+        this->lineEnd ();
+        this->printImage (*object.as <Image> ());
+    } else if (object.is <Sound> ()) {
+        this->lineEnd ();
+        this->printSound (*object.as <Sound> ());
+    }
+
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printImage (const Image& image) {
+    this->printModel (*image.model);
+
+    this->lineEnd ();
+    this->m_out << "Image effects count: " << image.effects.size ();
+    this->increaseIndentation ();
+
+    for (const auto& effect : image.effects) {
+        this->lineEnd ();
+        this->printImageEffect (*effect);
+    }
+
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printSound (const Sound& sound) {
+    this->m_out << "Sounds: " << sound.sounds.size ();
+    this->increaseIndentation ();
+
+    for (const auto& filename : sound.sounds) {
+        this->lineEnd ();
+        this->m_out << "Filename " << filename;
+    }
+
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printModel (const ModelStruct& model) {
+    this->m_out << "Model " << model.filename << ":";
+    this->increaseIndentation ();
+    this->lineEnd ();
+
+    this->m_out << "Autosize: " << model.autosize;
+    this->lineEnd ();
+    this->m_out << "Passthrough: " << model.passthrough;
+    this->lineEnd ();
+    this->m_out << "Fullscreen: " << model.fullscreen;
+    this->lineEnd ();
+    this->m_out << "No padding: " << model.nopadding;
+    this->lineEnd ();
+    this->m_out << "Solid layer: " << model.solidlayer;
+    this->lineEnd ();
+
+    if (model.width.has_value ()) {
+        this->m_out << "Width: " << model.width.value ();
+        this->lineEnd ();
+    }
+
+    if (model.height.has_value ()) {
+        this->m_out << "Height: " << model.height.value ();
+        this->lineEnd ();
+    }
+
+    this->printMaterial (*model.material);
+
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printImageEffect (const ImageEffect& effect) {
+    this->m_out << "Image effect " << effect.id << ":";
+
+    this->increaseIndentation ();
+
+    this->lineEnd ();
+    this->m_out << "Default visibility status: " << effect.visible->value->getBool ();
+
+    this->printEffect (*effect.effect);
+
+    this->lineEnd ();
+    this->m_out << "Effect overrides count: " << effect.passOverrides.size ();
+
+    this->increaseIndentation ();
+
+    for (const auto& override : effect.passOverrides) {
+        this->printImageEffectPassOverride (*override);
+    }
+
+    this->decreaseIndentation ();
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printImageEffectPassOverride (const ImageEffectPassOverride& imageEffectPass) {
+    this->lineEnd ();
+    this->m_out << "Pass override " << imageEffectPass.id << ":";
+    this->increaseIndentation ();
+
+    this->lineEnd ();
+    this->m_out << "Textures count: " << imageEffectPass.textures.size ();
+
+    if (!imageEffectPass.textures.empty ()) {
+        this->increaseIndentation ();
+
+        for (const auto& texture : imageEffectPass.textures) {
+            this->lineEnd ();
+            this->m_out << "Texture " << texture.first << ": " << texture.second;
+        }
+
+        this->decreaseIndentation ();
+    }
+
+    this->lineEnd ();
+    this->m_out << "Combos count: " << imageEffectPass.combos.size ();
+
+    if (!imageEffectPass.combos.empty ()) {
+        this->increaseIndentation ();
+
+        for (const auto& combo : imageEffectPass.combos) {
+            this->lineEnd ();
+            this->m_out << "Combo " << combo.first << "=" << combo.second;
+        }
+
+        this->decreaseIndentation ();
+    }
+
+    this->lineEnd ();
+    this->m_out << "Constants count: " << imageEffectPass.constants.size ();
+
+    if (!imageEffectPass.constants.empty ()) {
+        this->increaseIndentation ();
+
+        for (const auto& constant : imageEffectPass.constants) {
+            this->lineEnd ();
+            this->m_out << "Constant " << constant.first << "=" << constant.second->toString();
+        }
+
+        this->decreaseIndentation ();
+    }
+
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printEffect (const Effect& effect) {
+    this->lineEnd ();
+    this->m_out << "Effect " << effect.name << ":";
+    this->increaseIndentation ();
+
+    if (!effect.description.empty ()) {
+        this->lineEnd ();
+        this->m_out << "Description: " << effect.description;
+    }
+
+    if (!effect.dependencies.empty ()) {
+        this->lineEnd ();
+        this->m_out << "Dependencies count: " << effect.dependencies.size ();
+        this->increaseIndentation ();
+
+        for (const auto& dependency : effect.dependencies) {
+            this->lineEnd ();
+            this->m_out << "Dependency: " << dependency;
+        }
+
+        this->decreaseIndentation ();
+    }
+
+    if (!effect.group.empty ()) {
+        this->lineEnd ();
+        this->m_out << "Group: " << effect.group;
+    }
+
+    if (!effect.preview.empty ()) {
+        this->lineEnd ();
+        this->m_out << "Preview: " << effect.preview;
+    }
+
+    this->lineEnd ();
+    this->m_out << "Passes count: " << effect.passes.size ();
+    this->increaseIndentation ();
+
+    int passId = 0;
+
+    for (const auto& pass : effect.passes) {
+        this->lineEnd ();
+        this->m_out << "Pass " << ++passId << ":";
+        this->increaseIndentation ();
+        this->lineEnd ();
+        this->printEffectPass (*pass);
+        this->decreaseIndentation ();
+    }
+
+    this->decreaseIndentation ();
+
+    this->lineEnd ();
+    this->m_out << "FBOs count: " << effect.fbos.size ();
+    this->increaseIndentation ();
+
+    for (const auto& fbo : effect.fbos) {
+        this->lineEnd ();
+        this->printFBO (*fbo);
+    }
+
+    this->decreaseIndentation ();
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printEffectPass (const EffectPass& effectPass) {
+    if (effectPass.command.has_value ()) {
+        const auto& command = effectPass.command.value ();
+
+        this->m_out << "Command: " << (command.command == Command_Copy ? "copy" : "swap");
+        this->lineEnd ();
+        this->m_out << "Source: " << command.source;
+        this->lineEnd ();
+        this->m_out << "Target: " << command.target;
+    } else {
+        if (effectPass.target.has_value ()) {
+            this->m_out << "Target: " << effectPass.target.value ();
+        }
+
+        if (!effectPass.binds.empty ()) {
+            if (effectPass.target.has_value ()) {
+                this->lineEnd ();
+            }
+
+            this->m_out << "Binds count: " << effectPass.binds.size ();
+            this->increaseIndentation ();
+
+            for (const auto& bind : effectPass.binds) {
+                this->lineEnd ();
+                this->m_out << "Bind " << bind.first << ": " << bind.second;
+            }
+
+            this->decreaseIndentation ();
+        }
+
+        if (effectPass.target.has_value () || !effectPass.binds.empty ()) {
+            this->lineEnd ();
+        }
+
+        this->printMaterial (*effectPass.material);
+    }
+}
+
+void StringPrinter::printFBO (const FBO& fbo) {
+    this->m_out << "FBO " << fbo.name << ":";
+    this->increaseIndentation ();
+
+    this->lineEnd ();
+    this->m_out << "Format: " << fbo.format;
+
+    this->lineEnd ();
+    this->m_out << "Scale: " << fbo.scale;
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printMaterial (const Material& material) {
+    this->m_out << "Material " << material.filename << ":";
+    this->increaseIndentation ();
+    this->lineEnd ();
+    this->m_out << "Passes count: " << material.passes.size ();
+    this->increaseIndentation ();
+
+    for (const auto& pass : material.passes) {
+        this->lineEnd ();
+        this->printMaterialPass (*pass);
+    }
+
+    this->decreaseIndentation ();
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::printMaterialPass (const MaterialPass& materialPass) {
+    this->m_out << "Pass " << materialPass.shader << ":";
+    this->increaseIndentation ();
+
+    this->lineEnd ();
+    this->m_out << "Depth test: " << materialPass.depthtest;
+    this->lineEnd ();
+    this->m_out << "Depth write: " << materialPass.depthwrite;
+    this->lineEnd ();
+    this->m_out << "Blend mode: " << materialPass.blending;
+    this->lineEnd ();
+    this->m_out << "Culling mode: " << materialPass.cullmode;
+
+    if (!materialPass.textures.empty ()) {
+        this->lineEnd ();
+        this->m_out << "Textures count: " << materialPass.textures.size ();
+        this->increaseIndentation ();
+
+        for (const auto& texture : materialPass.textures) {
+            this->lineEnd ();
+            this->m_out << "Texture " << texture.first << ": " << texture.second;
+        }
+
+        this->decreaseIndentation ();
+    }
+
+    if (!materialPass.combos.empty ()) {
+        this->lineEnd ();
+        this->m_out << "Combos count: " << materialPass.combos.size ();
+        this->increaseIndentation ();
+
+        for (const auto& combo : materialPass.combos) {
+            this->lineEnd ();
+            this->m_out << "Combo " << combo.first << ": " << combo.second;
+        }
+
+        this->decreaseIndentation ();
+    }
+
+    this->decreaseIndentation ();
+}
+
+void StringPrinter::indentation () {
+    for (int i = 0; i < this->m_level; i++)
+        this->m_out << this->m_indentationCharacter;
+}
+
+void StringPrinter::lineEnd () {
+    this->m_out << "\n";
+    this->indentation ();
+}
+
+void StringPrinter::increaseIndentation () {
+    this->m_level ++;
+}
+
+void StringPrinter::decreaseIndentation () {
+    this->m_level --;
+}
+
+std::string StringPrinter::str () {
+    return this->m_buffer.str ();
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Dumpers/StringPrinter.h b/src/WallpaperEngine/Data/Dumpers/StringPrinter.h
new file mode 100644
index 0000000..b240c64
--- /dev/null
+++ b/src/WallpaperEngine/Data/Dumpers/StringPrinter.h
@@ -0,0 +1,130 @@
+#pragma once
+
+#include <string>
+#include <sstream>
+
+#include "WallpaperEngine/Data/Model/Types.h"
+
+namespace WallpaperEngine::Data::Dumpers {
+using namespace WallpaperEngine::Data::Model;
+
+class StringPrinter {
+  public:
+    explicit StringPrinter (std::string indentationCharacter = "\t");
+    ~StringPrinter () = default;
+
+    /**
+     * @return The contents of the pretty printer buffer
+     */
+    std::string str ();
+
+    /**
+     * Prints the information of the given wallpaper
+     *
+     * @param wallpaper
+     */
+    void printWallpaper (const Wallpaper& wallpaper);
+
+    /**
+     * Prints the information of the given object
+     *
+     * @param object
+     */
+    void printObject (const Object& object);
+
+    /**
+     * Prints the information of the given image
+     *
+     * @param image
+     */
+    void printImage (const Image& image);
+
+    /**
+     * Prints the information of the given sound
+     *
+     * @param sound
+     */
+    void printSound (const Sound& sound);
+
+    /**
+     * Prints the information of the given model
+     *
+     * @param model
+     */
+    void printModel (const ModelStruct& model);
+
+    /**
+     * Prints the information of the given image effect
+     *
+     * @param imageEffect
+     */
+    void printImageEffect (const ImageEffect& imageEffect);
+
+    /**
+     * Prints the information of the given image effect pass
+     *
+     * @param imageEffectPass
+     */
+    void printImageEffectPassOverride (const ImageEffectPassOverride& imageEffectPass);
+
+    /**
+     * Prints the information of the given FBO
+     *
+     * @param fbo
+     */
+    void printFBO (const FBO& fbo);
+
+    /**
+     * Prints the information of the given material
+     *
+     * @param material
+     */
+    void printMaterial (const Material& material);
+
+    /**
+     * Prints the information of the given material pass
+     *
+     * @param materialPass
+     */
+    void printMaterialPass (const MaterialPass& materialPass);
+
+    /**
+     * Prints the information of the given effect
+     *
+     * @param effect
+     */
+    void printEffect (const Effect& effect);
+
+    /**
+     * Prints the information of the given effect
+     *
+     * @param effectPass
+     */
+    void printEffectPass (const EffectPass& effectPass);
+
+  private:
+    /**
+     * Printss the current identation level
+     */
+    void indentation ();
+
+    /**
+     * Prints an end of line and indentates the next line to the aproppiate level
+     */
+    void lineEnd ();
+
+    /**
+     * Increases the indentation level and prints a new line up to the specified level
+     */
+    void increaseIndentation ();
+    /**
+     * Decreases the indentation level and prints a new line up to the specified level
+     */
+    void decreaseIndentation ();
+
+    int m_level = 0;
+    std::stringbuf m_buffer = {};
+    std::ostream m_out;
+    std::string m_indentationCharacter;
+};
+} // namespace WallpaperEngine::Data::Dumpers
diff --git a/src/WallpaperEngine/Data/JSON.cpp b/src/WallpaperEngine/Data/JSON.cpp
new file mode 100644
index 0000000..41848c1
--- /dev/null
+++ b/src/WallpaperEngine/Data/JSON.cpp
@@ -0,0 +1,12 @@
+#include "JSON.h"
+
+#include "WallpaperEngine/Data/Parsers/UserSettingParser.h"
+
+using namespace WallpaperEngine::Data::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+UserSettingSharedPtr JsonExtensions::user (const std::string& key, const Properties& properties) const {
+    const auto value = this->require (key, "User setting without default value must be present");
+
+    return UserSettingParser::parse (value, properties);
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/JSON.h b/src/WallpaperEngine/Data/JSON.h
new file mode 100644
index 0000000..f3dc81d
--- /dev/null
+++ b/src/WallpaperEngine/Data/JSON.h
@@ -0,0 +1,168 @@
+#pragma once
+
+#include <glm/detail/qualifier.hpp>
+#include <glm/detail/type_vec1.hpp>
+#include <nlohmann/json.hpp>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "WallpaperEngine/Data/Builders/UserSettingBuilder.h"
+#include "WallpaperEngine/Data/Builders/VectorBuilder.h"
+#include "WallpaperEngine/Data/Model/Types.h"
+#include "WallpaperEngine/Logging/CLog.h"
+
+namespace WallpaperEngine::Data::Parsers {
+class UserSettingParser;
+}
+namespace WallpaperEngine::Data::JSON {
+using namespace WallpaperEngine::Data::Builders;
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Model;
+
+// sfinae to detect the type for template specialization
+template <typename T>
+struct is_glm_vec : std::false_type {};
+
+template <glm::length_t L, typename S, glm::qualifier Q>
+struct is_glm_vec<glm::vec<L, S, Q>> : std::true_type {};
+
+// traits used to guess the type of the vector and it's length
+template <typename T>
+struct GlmVecTraits;
+
+template <glm::length_t L, typename T, glm::qualifier Q>
+struct GlmVecTraits<glm::vec<L, T, Q>> {
+    static constexpr int length = L;
+    using type = T;
+    static constexpr glm::qualifier qualifier = Q;
+};
+
+class JsonExtensions;
+
+using JSON = nlohmann::basic_json<
+    std::map,
+    std::vector,
+    std::string,
+    bool,
+    std::int64_t,
+    std::uint64_t,
+    double,
+    std::allocator,
+    nlohmann::adl_serializer,
+    std::vector<std::uint8_t>,
+    JsonExtensions
+>;
+
+/**
+ * Small extensions class that is used as base class of nlohmann's implementation.
+ *
+ * Provides shorthand methods to reduce the amount of handling required for specific situations
+ * (mainly throwing readable exceptions when a value is missing, optional/default values, user settings...)
+ */
+class JsonExtensions {
+  public:
+    using base_type = JSON;
+
+    template <typename T, typename std::enable_if_t<is_glm_vec<T>::value, int> = 0>
+    [[nodiscard]] T get () const {
+        constexpr int length = GlmVecTraits<T>::length;
+        constexpr glm::qualifier qualifier = GlmVecTraits<T>::qualifier;
+
+        // call the specialized version of the function
+        return get <length, typename GlmVecTraits<T>::type, qualifier> ();
+    }
+    template <int length, typename type, glm::qualifier qualifier>
+    [[nodiscard]] glm::vec <length, type, qualifier> get () const {
+        return VectorBuilder::parse <length, type, qualifier> (this->base ().get <std::string> ());
+    }
+    [[nodiscard]] base_type require (const std::string& key, const std::string& message) const {
+        auto base  =  this->base ();
+        auto it = base.find (key);
+
+        if (it == base.end ()) {
+            sLog.exception (message);
+        }
+
+        return *it;
+    }
+    template <typename T>
+    [[nodiscard]] T require (const std::string& key, const std::string& message) const {
+        auto base = this->base ();
+        auto it = base.find (key);
+
+        if (it == base.end ()) {
+            sLog.exception (message);
+        }
+
+        return (*it);
+    }
+    [[nodiscard]] std::optional <base_type> optional (const std::string& key) const noexcept {
+        auto base = this->base ();
+        auto it = base.find (key);
+        auto result = std::optional<base_type> {};
+
+        if (it != base.end ()) {
+            result.emplace (*it);
+        }
+
+        return result;
+    }
+    template <typename T>
+    [[nodiscard]] std::optional <T> optional (const std::string& key) const noexcept {
+        auto base = this->base ();
+        auto it = base.find (key);
+
+        if (it == base.end ()) {
+            return std::nullopt;
+        }
+
+        return *it;
+    }
+    template <typename T>
+    [[nodiscard]] T optional (const std::string& key, T defaultValue) const noexcept {
+        auto base = this->base ();
+        auto it = base.find (key);
+
+        if (it == base.end ()) {
+            return defaultValue;
+        }
+
+        return (*it);
+    }
+    [[nodiscard]] UserSettingSharedPtr user (const std::string& key, const Properties& properties) const;
+    template <typename T>
+    [[nodiscard]] UserSettingSharedPtr user (const std::string& key, const Properties& properties, T defaultValue) const {
+        const auto value = this->optional (key);
+
+        if (!value.has_value ()) {
+            return UserSettingBuilder::fromValue <T> (defaultValue);
+        }
+
+        // performs a second lookup, but handles the actual call to UserSettingParser outside of this header
+        // this resolving the include loop
+        return this->user (key, properties);
+    }
+
+    template <int length, typename type, glm::qualifier qualifier>
+    operator glm::vec <length, type, qualifier> () const {
+        return get <length, type, qualifier> ();
+    }
+    template <typename T, typename std::enable_if_t<is_glm_vec<T>::value> = 0>
+    operator T () const {
+        constexpr int length = GlmVecTraits<T>::length;
+        constexpr glm::qualifier qualifier = GlmVecTraits<T>::qualifier;
+
+        // call the specialized version of the function
+        return operator glm::vec <length, typename GlmVecTraits<T>::type, qualifier> ();
+    }
+  private:
+    /**
+     * @return The base json object to be used by the extension methods
+     */
+    [[nodiscard]] const base_type& base () const {
+        return *static_cast<const base_type*> (this);
+    }
+};
+
+} // namespace WallpaperEngine::Data::JSON
diff --git a/src/WallpaperEngine/Data/Model/Effect.h b/src/WallpaperEngine/Data/Model/Effect.h
new file mode 100644
index 0000000..95d5d36
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Effect.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <string>
+
+#include "Types.h"
+
+namespace WallpaperEngine::Data::Model {
+enum PassCommandType {
+    Command_Copy = 0,
+    Command_Swap = 1
+};
+
+struct FBO {
+    std::string name;
+    std::string format;
+    float scale;
+};
+
+struct PassCommand {
+    /** The type of command to execute */
+    PassCommandType command;
+    /** The target of the command (where to draw to) */
+    std::string target;
+    /** The source of the command (where to draw from) */
+    std::string source;
+};
+
+struct EffectPass {
+    /** The material to use for this effect's pass */
+    MaterialUniquePtr material;
+    /** Texture bindings for this effect's pass */
+    std::map <int, std::string> binds;
+    /** The command this material executes (if specified) */
+    std::optional <PassCommand> command;
+    /** The target this material renders to (if specified) */
+    std::optional <std::string> target;
+};
+struct Effect {
+    /** Effect's name for the UI */
+    std::string name;
+    /** Effect's description for the UI */
+    std::string description;
+    /** Effect's group for the UI */
+    std::string group;
+    /** Effect's preview project */
+    std::string preview;
+    /** Effect's dependencies */
+    std::vector <std::string> dependencies;
+    /** The different passes for this effect */
+    std::vector <EffectPassUniquePtr> passes;
+    /** The fbos declared by this effect */
+    std::vector <FBOUniquePtr> fbos;
+};
+} // namespace WallpaperEngine::Data::Model
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Material.h b/src/WallpaperEngine/Data/Model/Material.h
new file mode 100644
index 0000000..458dbf9
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Material.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <map>
+#include <vector>
+#include <string>
+#include <optional>
+
+#include "Types.h"
+
+namespace WallpaperEngine::Data::Model {
+struct MaterialPass {
+    // TODO: WRITE ENUMS FOR THESE
+    /** Blending mode */
+    std::string blending;
+    /** Culling mode */
+    std::string cullmode;
+    /** Depth test mode */
+    std::string depthtest;
+    /** Depth write mode */
+    std::string depthwrite;
+    /** Shader file to use for this pass */
+    std::string shader;
+    /** List of textures defined for this pass */
+    std::map <int, std::string> textures;
+    /** The combos and their values to pass onto the shader */
+    std::map <std::string, int> combos;
+};
+
+struct Material {
+    /** The name of the file this material is defined in */
+    std::string filename;
+    /** The passes that compose this material */
+    std::vector <MaterialPassUniquePtr> passes;
+};
+
+} // namespace WallpaperEngine::Data::Model
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Model.h b/src/WallpaperEngine/Data/Model/Model.h
new file mode 100644
index 0000000..f858b74
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Model.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Types.h"
+
+namespace WallpaperEngine::Data::Model {
+// TODO: FIND A BETTER NAMING SO THIS DOESN'T COLLIDE WITH THE NAMESPACE ITSELF
+struct ModelStruct {
+    /** The filename of the model */
+    std::string filename;
+    /** The material used for this model */
+    MaterialUniquePtr material;
+    /** Whether this model is a solid layer */
+    bool solidlayer;
+    /** Whether this model is a fullscreen layer */
+    bool fullscreen;
+    /** Whether this model is a passthrough layer */
+    bool passthrough;
+    /** Whether this models's size should be determined automatically or not */
+    bool autosize;
+    /** Whether this models's padding should be disabled or not */
+    bool nopadding;
+    /** Not sure what's used for */
+    std::optional<int> width;
+    /** Not sure what's used for */
+    std::optional<int> height;
+};
+} // namespace WallpaperEngine::Data::Model
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Object.h b/src/WallpaperEngine/Data/Model/Object.h
new file mode 100644
index 0000000..dc7af0a
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Object.h
@@ -0,0 +1,122 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+#include <string>
+
+#include <glm/glm.hpp>
+
+#include "Types.h"
+#include "Effect.h"
+#include "Material.h"
+#include "Model.h"
+#include "WallpaperEngine/Data/Utils/TypeCaster.h"
+
+namespace WallpaperEngine::Data::Model {
+using TypeCaster = WallpaperEngine::Data::Utils::TypeCaster;
+
+struct ObjectData {
+    int id;
+    std::string name;
+    std::vector <int> dependencies;
+};
+
+//TODO: CHECK IF THE SEMANTICS FOR MEMORY ARE RIGHT HERE
+
+/**
+ * Base class for all objects, represents a single object in the scene
+ *
+ * @see Image
+ * @see Sound
+ * @see Particle
+ * @see Text
+ * @see Light
+ */
+class Object : public TypeCaster, public ObjectData {
+  public:
+    explicit Object (ObjectData data) noexcept : ObjectData (std::move (data)), TypeCaster () {};
+    ~Object () override = default;
+};
+
+/**
+ * Overrides effect's passes configuration
+ *
+ * @see ImageEffect
+ * @see EffectPass
+ */
+struct ImageEffectPassOverride {
+    int id;
+    ComboMap combos;
+    ShaderConstantMap constants;
+    std::map <int, std::string> textures;
+};
+
+/**
+ * Override information for an specific effect
+ *
+ * @see ImageEffect
+ * @see Effect
+ * @see EffectPass
+ * @see ImageEffectPass
+ */
+struct ImageEffect {
+    /** Not sure what it's used for */
+    int id;
+    /** Effect's name for the editor */
+    std::string name;
+    /** If this effect is visible or not */
+    UserSettingSharedPtr visible;
+    /** Pass overrides to apply to the effect's passes */
+    std::vector <ImageEffectPassOverrideUniquePtr> passOverrides;
+    /** The effect definition */
+    EffectUniquePtr effect;
+};
+
+struct ImageData {
+    /** The point of origin of the image */
+    UserSettingSharedPtr origin;
+    /** The scale of the image */
+    UserSettingSharedPtr scale;
+    /** The rotation of the image */
+    UserSettingSharedPtr angles;
+    /** If the image is visible or not */
+    UserSettingSharedPtr visible;
+    /** The alpha of the image */
+    UserSettingSharedPtr alpha;
+    /** The color of the image */
+    UserSettingSharedPtr color;
+    // TODO: WRITE A COUPLE OF ENUMS FOR THIS
+    /** The alignment of the image */
+    std::string alignment;
+    /** The size of the image in pixels */
+    glm::vec2 size;
+    /** Parallax depth used for parallax scrolling */
+    glm::vec2 parallaxDepth;
+    /** The color blending mode for this image */
+    int colorBlendMode;
+    /** The brightness of the image */
+    float brightness;
+    /** The material in use for this image */
+    ModelUniquePtr model;
+    /** The effects applied to this image after the material is rendered */
+    std::vector <ImageEffectUniquePtr> effects;
+};
+
+class Image : public Object, public ImageData {
+  public:
+    explicit Image (ObjectData data, ImageData imageData) noexcept : Object (std::move(data)), ImageData (std::move (imageData)) {};
+    ~Image () override = default;
+};
+
+struct SoundData {
+    /** Playback mode, loop, */
+    std::optional <std::string> playbackmode;
+    std::vector <std::string> sounds;
+};
+
+class Sound : public Object, public SoundData {
+  public:
+    explicit Sound (ObjectData data, SoundData soundData) noexcept : Object (std::move(data)), SoundData (std::move (soundData)) {};
+    ~Sound () override = default;
+};
+} // namespace WallpaperEngine::Data::Model
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Project.h b/src/WallpaperEngine/Data/Model/Project.h
new file mode 100644
index 0000000..383ec2e
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Project.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+#include "Types.h"
+
+namespace WallpaperEngine::Data::Model {
+using json = WallpaperEngine::Data::JSON::JSON;
+/**
+ * Represents a wallpaper engine project
+ */
+struct Project {
+  public:
+    enum Type {
+        Type_Scene = 0,
+        Type_Web = 1,
+        Type_Video = 2,
+        Type_Unknown = 3
+    };
+
+    /** Wallpapers title */
+    std::string title;
+    /** Wallpaper's type */
+    Type type;
+    /** Workshop ID of the background or a negative id if not present */
+    std::string workshopId;
+    /** Indicates if the background uses audio processing or not */
+    bool supportsAudioProcessing;
+    /** All the available properties that the project defines for the user to change */
+    Properties properties;
+
+    /** The wallpaper this project defines */
+    WallpaperSharedPtr wallpaper;
+    /** VFS to access the project's files */
+    ContainerWeakPtr container;
+};
+};
diff --git a/src/WallpaperEngine/Data/Model/Types.h b/src/WallpaperEngine/Data/Model/Types.h
new file mode 100644
index 0000000..1e4e860
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Types.h
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <memory>
+
+#include "WallpaperEngine/Assets/CContainer.h"
+#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
+#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
+#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h"
+#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h"
+#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h"
+#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h"
+#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h"
+#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h"
+#include "WallpaperEngine/Core/Projects/CProperty.h"
+
+namespace WallpaperEngine::Data::Model {
+struct Project;
+class Wallpaper;
+class Scene;
+class Web;
+class Video;
+class UserSetting;
+class Object;
+class Sound;
+class Image;
+struct ImageEffect;
+struct ImageEffectPassOverride;
+class Particle;
+struct Material;
+struct MaterialPass;
+struct FBO;
+struct Effect;
+struct EffectPass;
+struct ModelStruct;
+
+// TODO: REMOVE ONCE THESE ARE RENAMED AND MOVED
+using Container = WallpaperEngine::Assets::CContainer;
+using ShaderConstant = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstant;
+using ShaderConstantProperty = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantProperty;
+using ShaderConstantFloat = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantFloat;
+using ShaderConstantInteger = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantInteger;
+using ShaderConstantVector2 = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantVector2;
+using ShaderConstantVector3 = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantVector3;
+using ShaderConstantVector4 = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantVector4;
+
+using Property = WallpaperEngine::Core::Projects::CProperty;
+using PropertySharedPtr = std::shared_ptr <Property>;
+using PropertyWeakPtr = std::weak_ptr <Property>;
+using Properties = std::map <std::string, PropertySharedPtr>;
+using DynamicValue = WallpaperEngine::Core::DynamicValues::CDynamicValue;
+using DynamicValueUniquePtr = std::unique_ptr <DynamicValue>;
+using DynamicValueSharedPtr = std::shared_ptr <DynamicValue>;
+using DynamicValueWeakPtr = std::weak_ptr <DynamicValue>;
+using UserSettingSharedPtr = std::shared_ptr <UserSetting>;
+using UserSettingWeakPtr = std::weak_ptr <UserSetting>;
+using ShaderConstantUniquePtr = std::unique_ptr <ShaderConstant>;
+// TODO: UP TO THIS POINT
+
+using ShaderConstantMap = std::map <std::string, ShaderConstantUniquePtr>;
+
+using ProjectSharedPtr = std::shared_ptr <Project>;
+using WallpaperSharedPtr = std::shared_ptr <Wallpaper>;
+using WallpaperWeakPtr = std::weak_ptr <Wallpaper>;
+using ProjectWeakPtr = std::weak_ptr <Project>;
+using ContainerSharedPtr = std::shared_ptr <Container>;
+using ContainerWeakPtr = std::weak_ptr <Container>;
+using SceneSharedPtr = std::shared_ptr <Scene>;
+using WebSharedPtr = std::shared_ptr <Web>;
+using VideoSharedPtr = std::shared_ptr <Video>;
+using ObjectUniquePtr = std::unique_ptr <Object>;
+using SoundUniquePtr = std::unique_ptr <Sound>;
+using ImageUniquePtr = std::unique_ptr <Image>;
+using ParticleUniquePtr = std::unique_ptr <Particle>;
+using MaterialUniquePtr = std::unique_ptr <Material>;
+using MaterialPassUniquePtr = std::unique_ptr <MaterialPass>;
+using EffectUniquePtr = std::unique_ptr <Effect>;
+using ImageEffectUniquePtr = std::unique_ptr <ImageEffect>;
+using ImageEffectPassOverrideUniquePtr = std::unique_ptr <ImageEffectPassOverride>;
+using EffectPassUniquePtr = std::unique_ptr <EffectPass>;
+using FBOUniquePtr = std::unique_ptr <FBO>;
+using ModelUniquePtr = std::unique_ptr <ModelStruct>;
+
+using ObjectMap = std::map<int, ObjectUniquePtr>;
+using ComboMap = std::map<std::string, int>;
+using TextureMap = std::map<int, std::string>;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/UserSetting.h b/src/WallpaperEngine/Data/Model/UserSetting.h
new file mode 100644
index 0000000..82612b9
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/UserSetting.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include "Types.h"
+
+#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
+#include "WallpaperEngine/Core/Projects/CProperty.h"
+
+namespace WallpaperEngine::Data::Model {
+struct ConditionInfo {
+  public:
+    std::string name;
+    std::string condition;
+};
+struct UserSetting {
+  public:
+    /**
+     * The value of this setting, can be a few different things:
+     * - a value connected to the property
+     * - a default value
+     * - a static value
+     */
+    DynamicValueUniquePtr value;
+    /** The property this setting takes the value from (if specified) */
+    PropertyWeakPtr property;
+    /** Condition required for this setting, this should be possible to run in JS' V8 */
+    std::optional <ConditionInfo> condition;
+};
+} // namespace WallpaperEngine::Data::Model
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Wallpaper.h b/src/WallpaperEngine/Data/Model/Wallpaper.h
new file mode 100644
index 0000000..0045080
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Wallpaper.h
@@ -0,0 +1,119 @@
+#pragma once
+
+#include <memory>
+
+#include <glm/glm.hpp>
+#include <utility>
+
+#include "Types.h"
+#include "Object.h"
+#include "WallpaperEngine/Data/Utils/TypeCaster.h"
+#include "WallpaperEngine/Data/JSON.h"
+
+namespace WallpaperEngine::Data::Model {
+using json = WallpaperEngine::Data::JSON::JSON;
+using TypeCaster = WallpaperEngine::Data::Utils::TypeCaster;
+
+struct WallpaperData {
+    std::string filename;
+    ProjectWeakPtr project;
+};
+
+class Wallpaper : public TypeCaster, public WallpaperData {
+  public:
+    explicit Wallpaper (WallpaperData data) noexcept : WallpaperData (std::move(data)), TypeCaster () {};
+    ~Wallpaper () override = default;
+};
+
+class Video : public Wallpaper {
+  public:
+    explicit Video (WallpaperData data) noexcept : Wallpaper (std::move(data)) {}
+
+    ~Video () override = default;
+};
+
+
+class Web : public Wallpaper {
+  public:
+    explicit Web (WallpaperData data) noexcept : Wallpaper (std::move(data)) {}
+
+    ~Web () override = default;
+};
+
+struct SceneData {
+    struct {
+        glm::vec3 ambient;
+        glm::vec3 skylight;
+        UserSettingSharedPtr clear;
+    } colors;
+    /**
+     * Camera configuration
+     */
+    struct {
+        /** Enable fade effect */
+        bool fade;
+        /** Used by the software to allow the users to preview the background or not? */
+        bool preview;
+
+        /**
+         * Bloom effect configuration
+         */
+        struct {
+            /** If bloom is enabled or not */
+            UserSettingSharedPtr enabled;
+            /** Bloom's strength to pass onto the shader */
+            UserSettingSharedPtr strength;
+            /** Bloom's threshold to pass onto the shader */
+            UserSettingSharedPtr threshold;
+        } bloom;
+        /**
+         * Parallax effect configuration
+         */
+        struct {
+            bool enabled;
+            float amount;
+            float delay;
+            float mouseInfluence;
+        } parallax;
+
+        /**
+         * Shake effect configuration
+         */
+        struct {
+            bool enabled;
+            float amplitude;
+            float roughness;
+            float speed;
+        } shake;
+
+        /**
+         * Position configuration
+         */
+        struct {
+            glm::vec3 center;
+            glm::vec3 eye;
+            glm::vec3 up;
+        } configuration;
+
+        /**
+         * Projection information
+         */
+        struct {
+            int width;
+            int height;
+            bool isAuto;
+        } projection;
+    } camera;
+    ObjectMap objects;
+    ProjectWeakPtr project;
+};
+
+class Scene : public Wallpaper, public SceneData {
+  public:
+    explicit Scene (WallpaperData data, SceneData sceneData) noexcept : SceneData (std::move(sceneData)), Wallpaper (data) {}
+
+    ~Scene () override = default;
+
+    // TODO: ADD OBJECTS HERE
+};
+} // namespace WallpaperEngine::Data::Model
diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
new file mode 100644
index 0000000..8169340
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
@@ -0,0 +1,95 @@
+#include "EffectParser.h"
+#include "MaterialParser.h"
+
+#include "WallpaperEngine/Data/Model/Material.h"
+#include "WallpaperEngine/Data/Model/Effect.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Model;
+
+EffectUniquePtr EffectParser::load (const ProjectWeakPtr& project, const std::string& filename) {
+    const auto effectJson = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
+
+    return parse (effectJson, project);
+}
+
+EffectUniquePtr EffectParser::parse (const JSON& it, const ProjectWeakPtr& project) {
+    const auto dependencies = it.optional ("dependencies");
+
+    return std::make_unique <Effect> (Effect {
+        .name = it.optional <std::string> ("name", ""),
+        .description = it.optional <std::string> ("description", ""),
+        .group = it.optional <std::string> ("group", ""),
+        .preview = it.optional <std::string> ("preview", ""),
+        .dependencies = dependencies.has_value () ? parseDependencies (*dependencies) : std::vector <std::string> {},
+        .passes = parseEffectPasses (it.require ("passes", "Effect file must have passes"), project),
+    });
+}
+
+std::vector <std::string> EffectParser::parseDependencies (const JSON& it) {
+    std::vector <std::string> result = {};
+
+    if (!it.is_array ()) {
+        return result;
+    }
+
+    for (const auto& cur : it) {
+        result.push_back (cur);
+    }
+
+    return result;
+}
+
+std::vector <EffectPassUniquePtr> EffectParser::parseEffectPasses (const JSON& it, const ProjectWeakPtr& project) {
+    std::vector <EffectPassUniquePtr> result = {};
+
+    if (!it.is_array ()) {
+        return result;
+    }
+
+    for (const auto& cur : it) {
+        const auto binds = cur.optional ("binds");
+        std::optional <PassCommand> command = std::nullopt;
+
+        if (cur.contains ("command")) {
+            command = {
+                .command = cur.require <std::string> ("command", "Material command must have a command") == "copy"
+                               ? Command_Copy
+                               : Command_Swap,
+                .target = cur.require <std::string> ("target", "Material command must have a target"),
+                .source = cur.require <std::string> ("source", "Material command must have a source"),
+            };
+        }
+
+        result.push_back (std::make_unique <EffectPass> (EffectPass {
+            .material = MaterialParser::load (project, cur.require <std::string> ("material", "Effect pass must have a material")),
+            .binds = binds.has_value () ? parseBinds (binds.value ()) : std::map<int, std::string> {},
+            .command = command,
+            // target is a bit special: if the material is a command this will be nullopt
+            // and the actual target will be set in the command itself, otherwise it will
+            // be set to whatever is in the json, which is not required to be present for
+            // normal materials
+            .target = command.has_value () ? std::nullopt : cur.optional <std::string> ("target"),
+        }));
+    }
+
+    return result;
+}
+
+std::map <int, std::string> EffectParser::parseBinds (const JSON& it) {
+    std::map <int, std::string> result = {};
+
+    if (!it.is_array ()) {
+        return result;
+    }
+
+    for (const auto& cur : it) {
+        result.emplace (
+            cur.require ("index", "Texture binds must have an index"),
+            cur.require ("name", "Texture bind must name the FBO that should be used")
+        );
+    }
+
+    return result;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.h b/src/WallpaperEngine/Data/Parsers/EffectParser.h
new file mode 100644
index 0000000..b0d0171
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Types.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class EffectParser {
+  public:
+    static EffectUniquePtr load (const ProjectWeakPtr& project, const std::string& filename);
+
+  private:
+    static EffectUniquePtr parse (const JSON& it, const ProjectWeakPtr& project);
+    static std::vector <std::string> parseDependencies (const JSON& it);
+    static std::vector <EffectPassUniquePtr> parseEffectPasses (const JSON& it, const ProjectWeakPtr& project);
+    static std::map <int, std::string> parseBinds (const JSON& it);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
new file mode 100644
index 0000000..df4b71f
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
@@ -0,0 +1,86 @@
+#include "MaterialParser.h"
+
+#include "WallpaperEngine/Data/Model/Material.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Model;
+
+MaterialUniquePtr MaterialParser::load (const ProjectWeakPtr& project, const std::string& filename) {
+    const auto materialJson = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
+
+    return parse (materialJson, project, filename);
+}
+
+MaterialUniquePtr MaterialParser::parse (const JSON& it, const ProjectWeakPtr& project, const std::string& filename) {
+    return std::make_unique <Material> (Material {
+        .filename = filename,
+        //TODO: PARSE PASSES
+        .passes = parsePasses (it.require ("passes", "Material must have passes to render"), project),
+    });
+}
+
+std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it, const ProjectWeakPtr& project) {
+    std::vector <MaterialPassUniquePtr> result = {};
+
+    if (!it.is_array ()) {
+        return result;
+    }
+
+    for (const auto& cur : it) {
+        result.push_back (parsePass (cur, project));
+    }
+
+    return result;
+}
+
+MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, const ProjectWeakPtr& project) {
+    const auto textures = it.optional ("textures");
+    const auto combos = it.optional ("combos");
+    const auto constants = it.optional ("constants");
+
+    return std::make_unique <MaterialPass>(MaterialPass {
+        //TODO: REMOVE THIS UGLY STD::STRING CREATION
+        .blending = it.optional ("blending", std::string ("normal")),
+        .cullmode = it.optional ("cullmode", std::string ("disabled")),
+        .depthtest = it.optional ("depthtest", std::string ("disabled")),
+        .depthwrite = it.optional ("depthwrite", std::string ("disabled")),
+        .shader = it.require <std::string> ("shader", "Material pass must have a shader"),
+        .textures = textures.has_value () ? parseTextures (*textures) : std::map <int, std::string> {},
+        .combos = combos.has_value () ? parseCombos (*combos) : std::map <std::string, int> {},
+    });
+}
+
+std::map <int, std::string> MaterialParser::parseTextures (const JSON& it) {
+    std::map <int, std::string> result = {};
+
+    if (!it.is_array ()) {
+        return result;
+    }
+
+    int index = 0;
+
+    for (const auto& cur : it) {
+        if (!it.is_null ()) {
+            result.emplace (index, cur);
+        }
+
+        index++;
+    }
+
+    return result;
+}
+
+std::map <std::string, int> MaterialParser::parseCombos (const JSON& it) {
+    std::map <std::string, int> result = {};
+
+    if (!it.is_object ()) {
+        return result;
+    }
+
+    for (const auto& cur : it.items ()) {
+        result.emplace (cur.key (), cur.value ());
+    }
+
+    return result;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/MaterialParser.h b/src/WallpaperEngine/Data/Parsers/MaterialParser.h
new file mode 100644
index 0000000..9d390a9
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/MaterialParser.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Types.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class MaterialParser {
+  public:
+    static MaterialUniquePtr load (const ProjectWeakPtr& project, const std::string& filename);
+    static MaterialUniquePtr parse (const JSON& it, const ProjectWeakPtr& project, const std::string& filename);
+    static std::vector <MaterialPassUniquePtr> parsePasses (const JSON& it, const ProjectWeakPtr& project);
+    static MaterialPassUniquePtr parsePass (const JSON& it, const ProjectWeakPtr& project);
+    static std::map <int, std::string> parseTextures (const JSON& it);
+    static std::map <std::string, int> parseCombos (const JSON& it);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/ModelParser.cpp b/src/WallpaperEngine/Data/Parsers/ModelParser.cpp
new file mode 100644
index 0000000..f42b569
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ModelParser.cpp
@@ -0,0 +1,31 @@
+#include "ModelParser.h"
+#include "MaterialParser.h"
+
+#include "WallpaperEngine/Data/Model/Model.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+#include "WallpaperEngine/Data/Model/Material.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Model;
+
+ModelUniquePtr ModelParser::load (const ProjectWeakPtr& project, const std::string& filename) {
+    const auto model = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
+
+    return parse (model, project, filename);
+}
+
+ModelUniquePtr ModelParser::parse (const JSON& file, const ProjectWeakPtr& project, const std::string& filename) {
+    const auto material = file.require <std::string> ("material", "Model must have a material");
+
+    return std::make_unique <ModelStruct> (ModelStruct {
+        .filename = filename,
+        .material = MaterialParser::load (project, material),
+        .solidlayer = file.optional ("solidlayer", false),
+        .fullscreen = file.optional ("fullscreen", false),
+        .passthrough = file.optional ("passthrough", false),
+        .autosize = file.optional ("autosize", false),
+        .nopadding = file.optional ("nopadding", false),
+        .width = file.optional <int> ("width"),
+        .height = file.optional <int> ("height"),
+    });
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/ModelParser.h b/src/WallpaperEngine/Data/Parsers/ModelParser.h
new file mode 100644
index 0000000..b05eaa6
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ModelParser.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Types.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class ModelParser {
+  public:
+    static ModelUniquePtr load (const ProjectWeakPtr& project, const std::string& filename);
+    static ModelUniquePtr parse (const JSON& file, const ProjectWeakPtr& project, const std::string& filename);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
new file mode 100644
index 0000000..6619a2f
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
@@ -0,0 +1,187 @@
+#include "ObjectParser.h"
+#include "ModelParser.h"
+#include "EffectParser.h"
+
+#include "ShaderConstantParser.h"
+#include "WallpaperEngine/Data/Model/Object.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+#include "WallpaperEngine/Logging/CLog.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Model;
+
+ObjectUniquePtr ObjectParser::parse (const JSON& it, const ProjectWeakPtr& project) {
+    const auto imageIt = it.find ("image");
+    const auto soundIt = it.find ("sound");
+    const auto particleIt = it.find ("particle");
+    const auto textIt = it.find ("text");
+    const auto lightIt = it.find ("light");
+    const auto basedata = ObjectData {
+        .id = it.require <int> ("id", "Object must have an id"),
+        .name = it.require <std::string> ("name", "Object must have a name"),
+        .dependencies = parseDependencies (it),
+    };
+
+    if (imageIt != it.end () && imageIt->is_string ()) {
+        return parseImage (it, project, basedata, *imageIt);
+    } else if (soundIt != it.end () && soundIt->is_array ()) {
+        return parseSound (it, project, basedata);
+    } else if (particleIt != it.end ()) {
+        sLog.error ("Particle objects are not supported yet");
+    } else if (textIt != it.end ()) {
+        sLog.error ("Text objects are not supported yet");
+    } else if (lightIt != it.end ()) {
+        sLog.error ("Light objects are not supported yet");
+    } else {
+        // dump the object for now, might want to change later
+        sLog.exception ("Unknown object type found: ", it.dump ());
+    }
+
+    return std::make_unique <Object> (basedata);
+}
+
+std::vector<int> ObjectParser::parseDependencies (const JSON& it) {
+    const auto dependenciesIt = it.find ("dependencies");
+
+    if (dependenciesIt == it.end () || !dependenciesIt->is_array ()) {
+        return {};
+    }
+
+    std::vector<int> result = {};
+
+    for (const auto& cur : *dependenciesIt) {
+        result.push_back (cur);
+    }
+
+    return result;
+}
+
+SoundUniquePtr ObjectParser::parseSound (const JSON& it, const ProjectWeakPtr& project, ObjectData base) {
+    const auto soundIt = it.require ("sound", "Object must have a sound");
+    std::vector<std::string> sounds = {};
+
+    for (const auto& cur : soundIt) {
+        sounds.push_back (cur);
+    }
+
+    return std::make_unique <Sound> (
+        std::move (base),
+        SoundData {
+            .playbackmode = it.optional <std::string> ("playbackmode"),
+            .sounds = sounds,
+        }
+    );
+}
+
+ImageUniquePtr ObjectParser::parseImage (
+    const JSON& it, const ProjectWeakPtr& project, ObjectData base, const std::string& image) {
+    const auto& properties = project.lock ()->properties;
+    const auto& effects = it.optional ("effects");
+
+    return std::make_unique <Image> (
+        std::move (base),
+        ImageData {
+            .origin = it.user ("origin", properties, glm::vec3 (0.0f)),
+            .scale = it.user ("scale", properties, glm::vec3 (1.0f)),
+            .angles = it.user ("angles", properties, glm::vec3 (0.0)),
+            .visible = it.user ("visible", properties, true),
+            .alpha = it.user ("alpha", properties, 1.0f),
+            .color = it.user ("color", properties, glm::vec3 (1.0f)),
+            .alignment = it.optional ("alignment", std::string ("center")),
+            .size = it.optional ("size", glm::vec2 (0.0f)),
+            .parallaxDepth = it.optional ("parallaxDepth", glm::vec2 (0.0f)),
+            .colorBlendMode = it.optional ("colorBlendMode", 0),
+            .brightness = it.optional ("brightness", 1.0f),
+            .model = ModelParser::load (project, image),
+            .effects = effects.has_value () ? parseEffects (*effects, project) : std::vector <ImageEffectUniquePtr> {},
+        }
+    );
+}
+
+std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, const ProjectWeakPtr& project) {
+    if (!it.is_array ()) {
+        return {};
+    }
+
+    std::vector <ImageEffectUniquePtr> result = {};
+
+    for (const auto& cur : it) {
+       result.push_back (parseEffect (cur, project));
+    }
+
+    return result;
+}
+
+ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, const ProjectWeakPtr& project) {
+    const auto& passsOverrides = it.optional ("passes");
+    return std::make_unique <ImageEffect> (ImageEffect {
+        .id = it.require <int> ("id", "Image effect must have an id"),
+        .name = it.require <std::string> ("name", "Image effect must have a name"),
+        .visible = it.user ("visible", project.lock ()->properties, true),
+        .passOverrides = passsOverrides.has_value () ? parseEffectPassOverrides (passsOverrides.value (), project) : std::vector <ImageEffectPassOverrideUniquePtr> {},
+        .effect = EffectParser::load (project, it.require ("file", "Image effect must have an effect"))
+    });
+}
+
+std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOverrides (const JSON& it, const ProjectWeakPtr& project) {
+    if (!it.is_array ()) {
+        return {};
+    }
+
+    std::vector <ImageEffectPassOverrideUniquePtr> result = {};
+
+    for (const auto& cur : it) {
+        result.push_back (parseEffectPass (cur, project));
+    }
+
+    return result;
+}
+
+ImageEffectPassOverrideUniquePtr ObjectParser::parseEffectPass (const JSON& it, const ProjectWeakPtr& project) {
+    const auto& combos = it.optional ("combos");
+    const auto& textures = it.optional ("textures");
+    const auto& constants = it.optional ("constantshadervalues");
+
+    // TODO: PARSE CONSTANT SHADER VALUES AND FIND REFS?
+    return std::make_unique <ImageEffectPassOverride> (ImageEffectPassOverride {
+        .id = it.require <int> ("id", "Image effect pass must have an id"),
+        .combos = combos.has_value () ? parseComboMap (combos.value ()) : ComboMap {},
+        .constants = constants.has_value () ? ShaderConstantParser::parse (constants.value (), project) : ShaderConstantMap {},
+        .textures = textures.has_value () ? parseTextureMap (textures.value ()) : TextureMap {},
+    });
+}
+
+TextureMap ObjectParser::parseTextureMap (const JSON& it) {
+    if (!it.is_array ()) {
+        return {};
+    }
+
+    TextureMap result = {};
+    int textureIndex = -1;
+
+    for (const auto& cur : it) {
+        textureIndex ++;
+
+        if (cur.is_null ()) {
+            continue;
+        }
+
+        result.emplace (textureIndex, cur);
+    }
+
+    return result;
+}
+
+ComboMap ObjectParser::parseComboMap (const JSON& it) {
+    if (!it.is_object ()) {
+        return {};
+    }
+
+    ComboMap result = {};
+
+    for (const auto& cur : it.items ()) {
+        result.emplace (cur.key (), cur.value ());
+    }
+
+    return result;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/ObjectParser.h b/src/WallpaperEngine/Data/Parsers/ObjectParser.h
new file mode 100644
index 0000000..f4967e8
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ObjectParser.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <vector>
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Object.h"
+
+namespace WallpaperEngine::Data::Model {
+struct ObjectData;
+}
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class ObjectParser {
+  public:
+    static ObjectUniquePtr parse (const JSON& it, const ProjectWeakPtr& project);
+
+  private:
+    static std::vector<int> parseDependencies (const JSON& it);
+    static SoundUniquePtr parseSound (const JSON& it, const ProjectWeakPtr& project, ObjectData base);
+    static ImageUniquePtr parseImage (
+        const JSON& it, const ProjectWeakPtr& project, ObjectData base, const std::string& image);
+    static std::vector <ImageEffectUniquePtr> parseEffects (const JSON& it, const ProjectWeakPtr& project);
+    static ImageEffectUniquePtr parseEffect (const JSON& it, const ProjectWeakPtr& project);
+    static std::vector <ImageEffectPassOverrideUniquePtr> parseEffectPassOverrides (const JSON& it, const ProjectWeakPtr& project);
+    static ImageEffectPassOverrideUniquePtr parseEffectPass (const JSON& it, const ProjectWeakPtr& project);
+    static TextureMap parseTextureMap (const JSON& it);
+    static ComboMap parseComboMap (const JSON& it);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
new file mode 100644
index 0000000..df0a1d3
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
@@ -0,0 +1,68 @@
+#include <algorithm>
+
+#include "ProjectParser.h"
+#include "WallpaperEngine/Logging/CLog.h"
+
+#include "WallpaperParser.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+
+static int backgroundId = 0;
+
+ProjectSharedPtr ProjectParser::parse (const JSON& data, const ContainerWeakPtr& container) {
+    const auto general = data.optional ("general");
+    auto type = data.require <std::string> ("type", "Project type missing");
+
+    // lowercase for consistency
+    std::transform (type.begin (), type.end (), type.begin (), tolower);
+
+    auto result = std::make_shared <Project> (Project {
+        .title = data.require <std::string> ("title", "Project title missing"),
+        .type = parseType (type),
+        .workshopId = data.optional ("workshopid", std::to_string (--backgroundId)),
+        .supportsAudioProcessing = general.has_value () && general.value ().optional ("supportsAudioProcessing", false),
+        .properties = parseProperties (general),
+        .container = container,
+    });
+
+    result->wallpaper = WallpaperParser::parse (data.require ("file", "Project's main file missing"), result);
+
+    return result;
+}
+
+Project::Type ProjectParser::parseType (const std::string& type) {
+    if (type == "scene") {
+        return Project::Type_Scene;
+    } else if (type == "video") {
+        return Project::Type_Video;
+    } else if (type == "web") {
+        return Project::Type_Web;
+    }
+
+    sLog.exception ("Unsupported project type ", type);
+}
+
+Properties ProjectParser::parseProperties (const std::optional <JSON>& data) {
+    if (!data.has_value ()) {
+        return {};
+    }
+
+    const auto properties = data.value ().optional ("properties");
+
+    if (!properties.has_value ()) {
+        return {};
+    }
+
+    Properties result = {};
+
+    // TODO: CHANGE THIS ONCE THE PROPERTIES PARSING IS HANDLED IN THE NEW TYPES
+    //  THESE ARE COMPLEX TYPES THAT INCLUDE SOME RUNTIME INFO THAT ISN'T EXPLICITLY DATA
+    //  SO THIS WILL NEED A RETHINK IN THE FUTURE
+    for (const auto& cur : properties.value ().items ()) {
+        const auto& property = Property::fromJSON (cur.value (), cur.key ());
+
+        result.emplace (property->getName (), property);
+    }
+
+    return result;
+}
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.h b/src/WallpaperEngine/Data/Parsers/ProjectParser.h
new file mode 100644
index 0000000..9a6ed61
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <nlohmann/json.hpp>
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+
+using namespace WallpaperEngine::Data::Model;
+
+/**
+ * Parses a project file and returns an object representing it
+ */
+class ProjectParser {
+  public:
+    static ProjectSharedPtr parse (const JSON& data, const ContainerWeakPtr& container);
+
+  private:
+    static Project::Type parseType (const std::string& type);
+    static Properties parseProperties (const std::optional <JSON>& data);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
new file mode 100644
index 0000000..3d84120
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
@@ -0,0 +1,77 @@
+#include "ShaderConstantParser.h"
+
+#include "WallpaperEngine/Data/Model/Project.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Model;
+
+ShaderConstantMap ShaderConstantParser::parse (const JSON& it, const ProjectWeakPtr& project) {
+    if (!it.is_object ()) {
+        return {};
+    }
+
+    std::map <std::string, ShaderConstantUniquePtr> result = {};
+
+    for (const auto& cur : it.items ()) {
+        result.emplace (cur.key(), parseConstant (cur.value(), project));
+    }
+
+    return result;
+}
+
+ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, const ProjectWeakPtr& project) {
+    ShaderConstant* constant = nullptr;
+    auto valueIt = it;
+
+    if (it.is_object ()) {
+        auto user = it.find ("user");
+        auto value = it.find ("value");
+
+        if (user == it.end () && value == it.end ()) {
+            sLog.error (R"(Found object for shader constant without "value" and "user" setting)");
+            return ShaderConstantUniquePtr (constant);
+        }
+
+        if (user != it.end () && user->is_string ()) {
+            const auto& properties = project.lock ()->properties;
+            const auto& propertyIt = properties.find (*user);
+
+            if (propertyIt != properties.end ()) {
+                constant = new ShaderConstantProperty (propertyIt->second);
+            } else {
+                sLog.error ("Shader constant pointing to non-existant project property: ", user->get <std::string> ());
+            }
+        } else {
+            valueIt = *value;
+        }
+    }
+
+    // TODO: REFACTOR THIS, SAME OLD THING WE HAD BEFORE, THESE SHADERCONSTANT CLASSES HAVE TO GO AND WE SHOULD HAVE JUST ONE
+    if (constant == nullptr) {
+        if (valueIt.is_number_float ()) {
+            constant = new ShaderConstantFloat (valueIt);
+        } else if (valueIt.is_number_integer ()) {
+            constant = new ShaderConstantInteger (valueIt);
+        } else if (valueIt.is_string ()) {
+            // TODO: USE VECTOR PARSER HERE? MAKE USE OF CDYNAMICVALUE FOR SHADERCONSTANTS TOO
+
+            // count the number of spaces to determine which type of vector we have
+            std::string value = valueIt;
+
+            size_t spaces =
+                std::count_if (value.begin (), value.end (), [&] (const auto& item) { return item == ' '; });
+
+            if (spaces == 1) {
+                constant = new ShaderConstantVector2 (valueIt);
+            } else if (spaces == 2) {
+                constant = new ShaderConstantVector3 (valueIt);
+            } else if (spaces == 3) {
+                constant = new ShaderConstantVector4 (valueIt);
+            } else {
+                sLog.exception ("unknown shader constant type ", value);
+            }
+        }
+    }
+
+    return ShaderConstantUniquePtr (constant);
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
new file mode 100644
index 0000000..8d5cde0
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Types.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class ShaderConstantParser {
+  public:
+    static ShaderConstantMap parse (const JSON& it, const ProjectWeakPtr& project);
+    static ShaderConstantUniquePtr parseConstant (const JSON& it, const ProjectWeakPtr& project);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp b/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
new file mode 100644
index 0000000..3ea6acd
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
@@ -0,0 +1,69 @@
+#include "UserSettingParser.h"
+
+#include "WallpaperEngine/Data/Model/UserSetting.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Builders;
+
+UserSettingSharedPtr UserSettingParser::parse (const json& data, const Properties& properties) {
+    DynamicValueUniquePtr value = std::make_unique <DynamicValue> ();
+    PropertyWeakPtr property;
+    std::optional<ConditionInfo> condition;
+    auto valueIt = data;
+
+    if (data.is_object ()) {
+        const auto user = data.optional ("user");
+        valueIt = data.require ("value", "User setting must have a value");
+
+        if (user.has_value ()) {
+            std::string source;
+            const auto& it = user.value ();
+
+            if (it.is_string ()) {
+                source = it;
+            } else {
+                condition = ConditionInfo {
+                    .name = it.require <std::string> ("name", "Name for conditional setting must be present"),
+                    .condition = it.require <std::string> ("condition", "Condition for conditional setting must be present"),
+                };
+
+                source = condition.value ().name;
+            }
+
+            const auto propertyIt = properties.find (source);
+
+            if (propertyIt != properties.end ()) {
+                property = propertyIt->second;
+            }
+        }
+    }
+
+    // actual value parsing
+    if (valueIt.is_string ()) {
+        std::string str = valueIt;
+        int size = VectorBuilder::preparseSize (str);
+
+        //TODO: VALIDATE THIS IS RIGHT?
+        if (size == 2) {
+            value->update ((glm::vec2) valueIt);
+        } else if (size == 3) {
+            value->update ((glm::vec3) valueIt);
+        } else {
+            value->update ((glm::vec4) valueIt);
+        }
+    } else if (valueIt.is_number_integer ()) {
+        value->update (valueIt.get <int> ());
+    } else if (valueIt.is_number_float ()) {
+        value->update (valueIt.get <float> ());
+    } else if (valueIt.is_boolean ()) {
+        value->update (valueIt.get <bool> ());
+    } else {
+        sLog.exception ("Unsupported user setting type ", valueIt.type_name ());
+    }
+
+    return std::make_shared <UserSetting> (UserSetting {
+        .value = std::move (value),
+        .property = property,
+        .condition = condition,
+    });
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/UserSettingParser.h b/src/WallpaperEngine/Data/Parsers/UserSettingParser.h
new file mode 100644
index 0000000..94508c8
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/UserSettingParser.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Types.h"
+#include "WallpaperEngine/Data/Model/UserSetting.h"
+#include "WallpaperEngine/Logging/CLog.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using json = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class UserSettingParser {
+  public:
+    static UserSettingSharedPtr parse (const json& data, const Properties& properties);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp b/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
new file mode 100644
index 0000000..c162a4d
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
@@ -0,0 +1,106 @@
+#include "WallpaperParser.h"
+
+#include "ObjectParser.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Logging/CLog.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+
+WallpaperSharedPtr WallpaperParser::parse (const JSON& file, const ProjectWeakPtr& project) {
+    switch (project.lock ()->type) {
+        case Project::Type_Scene:
+            return std::dynamic_pointer_cast <Wallpaper> (parseScene (file, project));
+        case Project::Type_Video:
+            return std::dynamic_pointer_cast <Wallpaper> (parseVideo (file, project));
+        case Project::Type_Web:
+            return std::dynamic_pointer_cast <Wallpaper> (parseWeb (file, project));
+        default:
+            sLog.exception ("Unexpected project type value found... This is likely a bug");
+    }
+}
+
+SceneSharedPtr WallpaperParser::parseScene (const JSON& file, const ProjectWeakPtr& project) {
+    const auto scene = JSON::parse (project.lock ()->container.lock ()->readFileAsString (file));
+    const auto camera = scene.require ("camera", "Scenes must have a camera section");
+    const auto general = scene.require ("general", "Scenes must have a general section");
+    const auto projection = general.require ("orthogonalprojection", "General section must have orthogonal projection info");
+    const auto objects = scene.require ("objects", "Scenes must have an objects section");
+    const auto& properties = project.lock ()->properties;
+
+    // TODO: FIND IF THESE DEFAULTS ARE SENSIBLE OR NOT AND PERFORM PROPER VALIDATION WHEN CAMERA PREVIEW AND CAMERA
+    // PARALLAX ARE PRESENT
+
+    return std::make_shared <Scene> (
+        WallpaperData {
+            .filename = "",
+            .project = project
+        }, SceneData {
+            .colors = {
+                .ambient  = general.optional ("ambientcolor", glm::vec3 (0.0f)),
+                .skylight = general.optional ("skylightcolor", glm::vec3 (0.0f)),
+                .clear = general.user ("clearcolor", properties, glm::vec3 (1.0f)),
+            },
+            .camera = {
+                .fade = general.optional ("camerafade", false),
+                .preview = general.optional ("camerapreview", false),
+                .bloom = {
+                    .enabled = general.user ("bloom", properties, false),
+                    .strength = general.user ("bloomstrength", properties, 0.0f),
+                    .threshold = general.user ("bloomthreshold", properties, 0.0f),
+                },
+                .parallax = {
+                    .enabled = general.optional ("cameraparallax", false),
+                    .amount = general.optional ("cameraparallaxamount", 1.0f),
+                    .delay = general.optional ("cameraparallaxdelay", 0.0f),
+                    .mouseInfluence = general.optional ("cameraparallaxmouseinfluence", 1.0f),
+                },
+                .shake = {
+                    .enabled = general.optional ("camerashake", false),
+                    .amplitude = general.optional ("camerashakeamplitude", 0.0f),
+                    .roughness = general.optional ("camerashakeroughness", 0.0f),
+                    .speed = general.optional ("camerashakespeed", 0.0f),
+                },
+                .configuration = {
+                    .center = camera.require <glm::vec3> ("center", "Camera must have a center position"),
+                    .eye = camera.require <glm::vec3> ("eye", "Camera must have an eye position"),
+                    .up = camera.require <glm::vec3> ("up", "Camera must have an up position"),
+                },
+                .projection = {
+                    .width = projection.require <int> ("width", "Projection must have a width"),
+                    .height = projection.require <int> ("height", "Projection must have a height"),
+                    .isAuto = projection.optional ("auto", false)
+                }
+            },
+            .objects = parseObjects (objects, project)
+        }
+    );
+}
+
+VideoSharedPtr WallpaperParser::parseVideo (const JSON& file, const ProjectWeakPtr& project) {
+    return std::make_unique <Video> (WallpaperData {
+        .filename = file,
+        .project = project
+    });
+}
+
+WebSharedPtr  WallpaperParser::parseWeb (const JSON& file, const ProjectWeakPtr& project) {
+    return std::make_unique <Web> (WallpaperData {
+        .filename = file,
+        .project = project,
+    });
+}
+
+ObjectMap WallpaperParser::parseObjects (const JSON& objects, const ProjectWeakPtr& project) {
+    ObjectMap result = {};
+
+    for (const auto& cur : objects) {
+        auto object = ObjectParser::parse (cur, project);
+
+        //TODO: DO WE REALLY WANT TO DIRECTLY CONSTRUCT UNIQUE AND SHARED PTRS EVERYWHERE?
+        // SHOULDN'T THAT BE HANDLED BY CALLING CODE (LIKE THIS) INSTEAD?
+        result.emplace (object->id, std::move (object));
+    }
+
+    return result;
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/WallpaperParser.h b/src/WallpaperEngine/Data/Parsers/WallpaperParser.h
new file mode 100644
index 0000000..783cca2
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/WallpaperParser.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "WallpaperEngine/Data/JSON.h"
+#include "WallpaperEngine/Data/Model/Types.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class WallpaperParser {
+  public:
+    static WallpaperSharedPtr parse (const JSON& file, const ProjectWeakPtr& project);
+
+  private:
+    static SceneSharedPtr parseScene (const JSON& file, const ProjectWeakPtr& project);
+    static VideoSharedPtr parseVideo (const JSON& file, const ProjectWeakPtr& project);
+    static WebSharedPtr parseWeb (const JSON& file, const ProjectWeakPtr& project);
+    static ObjectMap parseObjects (const JSON& objects, const ProjectWeakPtr& project);
+};
+} // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Utils/TypeCaster.cpp b/src/WallpaperEngine/Data/Utils/TypeCaster.cpp
new file mode 100644
index 0000000..e6f6f1c
--- /dev/null
+++ b/src/WallpaperEngine/Data/Utils/TypeCaster.cpp
@@ -0,0 +1 @@
+#include "TypeCaster.h"
diff --git a/src/WallpaperEngine/Data/Utils/TypeCaster.h b/src/WallpaperEngine/Data/Utils/TypeCaster.h
new file mode 100644
index 0000000..3cadf41
--- /dev/null
+++ b/src/WallpaperEngine/Data/Utils/TypeCaster.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <stdexcept>
+
+namespace WallpaperEngine::Data::Utils {
+/**
+ * A simple implementation of type and sub-types casting to be as explicit
+ * as possible while being performant
+ *
+ * Uses typeid from C++17, so base types must have a virtual, default destructor
+ */
+class TypeCaster {
+  public:
+    virtual ~TypeCaster() = default;
+
+    template <class T> [[nodiscard]] const T* as () const {
+        if (is<T> ()) {
+            return static_cast <const T*> (this);
+        }
+
+        throw std::bad_cast ();
+    }
+
+    template <class T> [[nodiscard]] T* as () {
+        if (is<T> ()) {
+            return static_cast <T*> (this);
+        }
+
+        throw std::bad_cast ();
+    }
+
+    template <class T> [[nodiscard]] bool is () const {
+        return typeid(*this) == typeid(T);
+    }
+};
+} // namespace WallpaperEngine::Data::Utils

From 25699606815a9c8a9274c0fa84b3ad11e85b6e9f Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Wed, 13 Aug 2025 08:50:34 +0200
Subject: [PATCH 02/23] refactor: update render to use new data model

---
 CMakeLists.txt                                | 104 ++---
 .../Application/CApplicationContext.h         |   2 +
 .../Application/CWallpaperApplication.cpp     |  60 +--
 .../Application/CWallpaperApplication.h       |  15 +-
 src/WallpaperEngine/Core/CObject.cpp          | 116 -----
 src/WallpaperEngine/Core/CObject.h            |  86 ----
 src/WallpaperEngine/Core/CProject.cpp         | 118 -----
 src/WallpaperEngine/Core/CProject.h           |  53 ---
 src/WallpaperEngine/Core/CWallpaper.cpp       |  12 -
 src/WallpaperEngine/Core/CWallpaper.h         |  44 --
 src/WallpaperEngine/Core/Core.cpp             |  39 --
 src/WallpaperEngine/Core/Core.h               |   5 -
 src/WallpaperEngine/Core/Objects/CEffect.cpp  | 319 --------------
 src/WallpaperEngine/Core/Objects/CEffect.h    | 102 -----
 src/WallpaperEngine/Core/Objects/CImage.cpp   | 142 ------
 src/WallpaperEngine/Core/Objects/CImage.h     | 122 ------
 src/WallpaperEngine/Core/Objects/CSound.cpp   |  53 ---
 src/WallpaperEngine/Core/Objects/CSound.h     |  48 ---
 .../Core/Objects/Effects/CBind.cpp            |  24 --
 .../Core/Objects/Effects/CBind.h              |  43 --
 .../Core/Objects/Effects/CFBO.cpp             |  31 --
 .../Core/Objects/Effects/CFBO.h               |  44 --
 .../Core/Objects/Images/CMaterial.cpp         | 120 ------
 .../Core/Objects/Images/CMaterial.h           |  89 ----
 .../Core/Objects/Images/Materials/CPass.cpp   | 105 -----
 .../Core/Objects/Images/Materials/CPass.h     |  84 ----
 src/WallpaperEngine/Core/Scenes/CCamera.cpp   |  28 --
 src/WallpaperEngine/Core/Scenes/CCamera.h     |  24 --
 .../Core/Scenes/CProjection.cpp               |  46 --
 src/WallpaperEngine/Core/Scenes/CProjection.h |  29 --
 .../Core/UserSettings/CUserSettingBoolean.cpp |   1 -
 .../Core/UserSettings/CUserSettingBoolean.h   |   1 -
 .../Core/UserSettings/CUserSettingFloat.cpp   |   1 -
 .../Core/UserSettings/CUserSettingFloat.h     |   1 -
 .../Core/UserSettings/CUserSettingVector3.h   |   1 -
 .../Core/Wallpapers/CScene.cpp                | 172 --------
 src/WallpaperEngine/Core/Wallpapers/CScene.h  |  88 ----
 .../Core/Wallpapers/CVideo.cpp                |  14 -
 src/WallpaperEngine/Core/Wallpapers/CVideo.h  |  25 --
 src/WallpaperEngine/Core/Wallpapers/CWeb.cpp  |  14 -
 src/WallpaperEngine/Core/Wallpapers/CWeb.h    |  31 --
 .../Data/Dumpers/StringPrinter.cpp            |   2 +-
 src/WallpaperEngine/Data/Model/Effect.h       |   2 +-
 src/WallpaperEngine/Data/Model/Material.h     |   4 +-
 src/WallpaperEngine/Data/Model/Object.h       |   1 +
 src/WallpaperEngine/Data/Model/Project.h      |   5 +-
 src/WallpaperEngine/Data/Model/Types.h        |  17 +-
 src/WallpaperEngine/Data/Model/Wallpaper.h    |   8 +-
 .../Data/Parsers/EffectParser.cpp             |   8 +-
 .../Data/Parsers/EffectParser.h               |   6 +-
 .../Data/Parsers/MaterialParser.cpp           |  11 +-
 .../Data/Parsers/MaterialParser.h             |   8 +-
 .../Data/Parsers/ModelParser.cpp              |   6 +-
 .../Data/Parsers/ModelParser.h                |   4 +-
 .../Data/Parsers/ObjectParser.cpp             |  20 +-
 .../Data/Parsers/ObjectParser.h               |  14 +-
 .../Data/Parsers/ProjectParser.cpp            |  10 +-
 .../Data/Parsers/ProjectParser.h              |   2 +-
 .../Data/Parsers/ShaderConstantParser.cpp     |   6 +-
 .../Data/Parsers/ShaderConstantParser.h       |   4 +-
 .../Data/Parsers/WallpaperParser.cpp          |  30 +-
 .../Data/Parsers/WallpaperParser.h            |  10 +-
 .../PrettyPrinter/CPrettyPrinter.cpp          | 403 ------------------
 .../PrettyPrinter/CPrettyPrinter.h            | 108 -----
 src/WallpaperEngine/Render/CCamera.cpp        |  25 +-
 src/WallpaperEngine/Render/CCamera.h          |  16 +-
 src/WallpaperEngine/Render/CFBO.h             |   4 +-
 src/WallpaperEngine/Render/CFBOProvider.cpp   |  57 +++
 src/WallpaperEngine/Render/CFBOProvider.h     |  24 ++
 src/WallpaperEngine/Render/CObject.cpp        |  10 +-
 src/WallpaperEngine/Render/CObject.h          |  11 +-
 src/WallpaperEngine/Render/CRenderContext.cpp |   2 +
 src/WallpaperEngine/Render/CTextureCache.cpp  |   6 +-
 src/WallpaperEngine/Render/CWallpaper.cpp     |  73 ++--
 src/WallpaperEngine/Render/CWallpaper.h       |  56 +--
 .../Render/Objects/CEffect.cpp                |  60 ---
 src/WallpaperEngine/Render/Objects/CEffect.h  |  47 --
 src/WallpaperEngine/Render/Objects/CImage.cpp | 202 +++++----
 src/WallpaperEngine/Render/Objects/CImage.h   |  19 +-
 src/WallpaperEngine/Render/Objects/CSound.cpp |  12 +-
 src/WallpaperEngine/Render/Objects/CSound.h   |   8 +-
 .../Render/Objects/Effects/CMaterial.cpp      |  34 --
 .../Render/Objects/Effects/CMaterial.h        |  42 --
 .../Render/Objects/Effects/CPass.cpp          | 156 ++++---
 .../Render/Objects/Effects/CPass.h            |  34 +-
 .../Render/Shaders/CShader.cpp                |   9 +-
 src/WallpaperEngine/Render/Shaders/CShader.h  |  13 +-
 .../Render/Shaders/CShaderUnit.cpp            |  18 +-
 .../Render/Shaders/CShaderUnit.h              |  28 +-
 .../Render/Wallpapers/CScene.cpp              | 137 +++---
 .../Render/Wallpapers/CScene.h                |  21 +-
 .../Render/Wallpapers/CVideo.cpp              |  11 +-
 .../Render/Wallpapers/CVideo.h                |   6 +-
 .../Render/Wallpapers/CWeb.cpp                |   9 +-
 src/WallpaperEngine/Render/Wallpapers/CWeb.h  |   9 +-
 .../WebBrowser/CEF/CSubprocessApp.cpp         |   3 +-
 .../WebBrowser/CEF/CWPSchemeHandler.cpp       |  10 +-
 .../WebBrowser/CEF/CWPSchemeHandler.h         |  14 +-
 .../CEF/CWPSchemeHandlerFactory.cpp           |   2 +-
 .../WebBrowser/CEF/CWPSchemeHandlerFactory.h  |  11 +-
 src/main.cpp                                  |   6 +-
 101 files changed, 757 insertions(+), 3593 deletions(-)
 delete mode 100644 src/WallpaperEngine/Core/CObject.cpp
 delete mode 100644 src/WallpaperEngine/Core/CObject.h
 delete mode 100644 src/WallpaperEngine/Core/CProject.cpp
 delete mode 100644 src/WallpaperEngine/Core/CProject.h
 delete mode 100644 src/WallpaperEngine/Core/CWallpaper.cpp
 delete mode 100644 src/WallpaperEngine/Core/CWallpaper.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/CEffect.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/CEffect.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/CImage.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/CImage.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/CSound.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/CSound.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/CBind.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/CBind.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/CFBO.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Images/CMaterial.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
 delete mode 100644 src/WallpaperEngine/Core/Scenes/CCamera.cpp
 delete mode 100644 src/WallpaperEngine/Core/Scenes/CCamera.h
 delete mode 100644 src/WallpaperEngine/Core/Scenes/CProjection.cpp
 delete mode 100644 src/WallpaperEngine/Core/Scenes/CProjection.h
 delete mode 100644 src/WallpaperEngine/Core/Wallpapers/CScene.cpp
 delete mode 100644 src/WallpaperEngine/Core/Wallpapers/CScene.h
 delete mode 100644 src/WallpaperEngine/Core/Wallpapers/CVideo.cpp
 delete mode 100644 src/WallpaperEngine/Core/Wallpapers/CVideo.h
 delete mode 100644 src/WallpaperEngine/Core/Wallpapers/CWeb.cpp
 delete mode 100644 src/WallpaperEngine/Core/Wallpapers/CWeb.h
 delete mode 100644 src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.cpp
 delete mode 100644 src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.h
 create mode 100644 src/WallpaperEngine/Render/CFBOProvider.cpp
 create mode 100644 src/WallpaperEngine/Render/CFBOProvider.h
 delete mode 100644 src/WallpaperEngine/Render/Objects/CEffect.cpp
 delete mode 100644 src/WallpaperEngine/Render/Objects/CEffect.h
 delete mode 100644 src/WallpaperEngine/Render/Objects/Effects/CMaterial.cpp
 delete mode 100644 src/WallpaperEngine/Render/Objects/Effects/CMaterial.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 57bea0f..6f72994 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -261,9 +261,6 @@ add_executable(
     src/WallpaperEngine/Logging/CLog.cpp
     src/WallpaperEngine/Logging/CLog.h
 
-    src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.cpp
-    src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.h
-
     src/WallpaperEngine/Application/CApplicationContext.cpp
     src/WallpaperEngine/Application/CApplicationContext.h
     src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -361,6 +358,8 @@ add_executable(
     src/WallpaperEngine/Render/CRenderContext.cpp
     src/WallpaperEngine/Render/CTextureCache.h
     src/WallpaperEngine/Render/CTextureCache.cpp
+    src/WallpaperEngine/Render/CFBOProvider.cpp
+    src/WallpaperEngine/Render/CFBOProvider.h
 
     src/WallpaperEngine/Render/Helpers/CContextAware.cpp
     src/WallpaperEngine/Render/Helpers/CContextAware.h
@@ -384,15 +383,11 @@ add_executable(
     src/WallpaperEngine/Render/Objects/CImage.cpp
     src/WallpaperEngine/Render/Objects/CSound.h
     src/WallpaperEngine/Render/Objects/CSound.cpp
-    src/WallpaperEngine/Render/Objects/CEffect.h
-    src/WallpaperEngine/Render/Objects/CEffect.cpp
 
     src/WallpaperEngine/Render/CFBO.h
     src/WallpaperEngine/Render/CFBO.cpp
     src/WallpaperEngine/Render/Objects/Effects/CPass.h
     src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
-    src/WallpaperEngine/Render/Objects/Effects/CMaterial.h
-    src/WallpaperEngine/Render/Objects/Effects/CMaterial.cpp
 
     src/WallpaperEngine/WebBrowser/CEF/CRenderHandler.cpp
     src/WallpaperEngine/WebBrowser/CEF/CRenderHandler.h
@@ -421,19 +416,6 @@ add_executable(
     src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
     src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
 
-    src/WallpaperEngine/Core/CProject.cpp
-    src/WallpaperEngine/Core/CProject.h
-    src/WallpaperEngine/Core/CWallpaper.cpp
-    src/WallpaperEngine/Core/CWallpaper.h
-    src/WallpaperEngine/Core/Wallpapers/CScene.cpp
-    src/WallpaperEngine/Core/Wallpapers/CScene.h
-    src/WallpaperEngine/Core/Wallpapers/CVideo.cpp
-    src/WallpaperEngine/Core/Wallpapers/CVideo.h
-    src/WallpaperEngine/Core/Wallpapers/CWeb.cpp
-    src/WallpaperEngine/Core/Wallpapers/CWeb.h
-    src/WallpaperEngine/Core/CObject.cpp
-    src/WallpaperEngine/Core/CObject.h
-
     src/WallpaperEngine/Core/Projects/CProperty.h
     src/WallpaperEngine/Core/Projects/CProperty.cpp
     src/WallpaperEngine/Core/Projects/CPropertyColor.h
@@ -447,24 +429,8 @@ add_executable(
     src/WallpaperEngine/Core/Projects/CPropertyText.h
     src/WallpaperEngine/Core/Projects/CPropertyText.cpp
 
-    src/WallpaperEngine/Core/Scenes/CCamera.cpp
-    src/WallpaperEngine/Core/Scenes/CCamera.h
-    src/WallpaperEngine/Core/Scenes/CProjection.cpp
-    src/WallpaperEngine/Core/Scenes/CProjection.h
-
-    src/WallpaperEngine/Core/Objects/CImage.cpp
-    src/WallpaperEngine/Core/Objects/CImage.h
-    src/WallpaperEngine/Core/Objects/CSound.cpp
-    src/WallpaperEngine/Core/Objects/CSound.h
-    src/WallpaperEngine/Core/Objects/CEffect.cpp
-    src/WallpaperEngine/Core/Objects/CEffect.h
-    src/WallpaperEngine/Core/Objects/CParticle.cpp
-    src/WallpaperEngine/Core/Objects/CParticle.h
-
-    src/WallpaperEngine/Core/Objects/Effects/CFBO.h
-    src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp
-    src/WallpaperEngine/Core/Objects/Effects/CBind.h
-    src/WallpaperEngine/Core/Objects/Effects/CBind.cpp
+#    src/WallpaperEngine/Core/Objects/CParticle.cpp
+#    src/WallpaperEngine/Core/Objects/CParticle.h
 
     src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h
     src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp
@@ -481,35 +447,29 @@ add_executable(
     src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h
     src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp
 
-    src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
-    src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
-    src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
-    src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
-    src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
-    src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
-
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
-    src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
-
-    src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp
-    src/WallpaperEngine/Core/Objects/Images/CMaterial.h
-
-    src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
-    src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
+#    src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
+#    src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
+#    src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
+#
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
+#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
 
     src/WallpaperEngine/Data/Model/Types.h
     src/WallpaperEngine/Data/Model/Project.h
@@ -541,11 +501,11 @@ add_executable(
     ${WAYLAND_SOURCES}
     ${X11_SOURCES}
     ${DEMOMODE_SOURCES}
-        src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
-        src/WallpaperEngine/Data/Dumpers/StringPrinter.h
-        src/WallpaperEngine/Data/JSON.cpp
-        src/WallpaperEngine/Data/Parsers/EffectParser.cpp
-        src/WallpaperEngine/Data/Parsers/EffectParser.h)
+    src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
+    src/WallpaperEngine/Data/Dumpers/StringPrinter.h
+    src/WallpaperEngine/Data/JSON.cpp
+    src/WallpaperEngine/Data/Parsers/EffectParser.cpp
+    src/WallpaperEngine/Data/Parsers/EffectParser.h)
 
 target_link_libraries (linux-wallpaperengine PUBLIC
     ${OPENGL_LIBRARIES}
diff --git a/src/WallpaperEngine/Application/CApplicationContext.h b/src/WallpaperEngine/Application/CApplicationContext.h
index 95a3772..20eb075 100644
--- a/src/WallpaperEngine/Application/CApplicationContext.h
+++ b/src/WallpaperEngine/Application/CApplicationContext.h
@@ -12,6 +12,8 @@
 #include "WallpaperEngine/Assets/ITexture.h"
 #include "WallpaperEngine/Render/CWallpaperState.h"
 
+#include "WallpaperEngine/Data/Model/Project.h"
+
 namespace WallpaperEngine::Application {
 /**
  * Application information as parsed off the command line arguments
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index a83baf3..e6a71f5 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -8,13 +8,13 @@
 #include "WallpaperEngine/Audio/Drivers/Detectors/CPulseAudioPlayingDetector.h"
 #include "WallpaperEngine/Logging/CLog.h"
 #include "WallpaperEngine/Render/CRenderContext.h"
-#include "WallpaperEngine/PrettyPrinter/CPrettyPrinter.h"
-#include "WallpaperEngine/Core/Wallpapers/CWeb.h"
 #include "WallpaperEngine/Render/Drivers/CVideoFactories.h"
 
 #include "WallpaperEngine/Data/Parsers/ProjectParser.h"
 #include "WallpaperEngine/Data/Dumpers/StringPrinter.h"
 
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+
 #if DEMOMODE
 #include "recording.h"
 #endif /* DEMOMODE */
@@ -29,7 +29,9 @@ float g_Time;
 float g_TimeLast;
 float g_Daytime;
 
-namespace WallpaperEngine::Application {
+using namespace WallpaperEngine::Application;
+using namespace WallpaperEngine::Data::Model;
+
 CWallpaperApplication::CWallpaperApplication (CApplicationContext& context) :
     m_context (context) {
     this->loadBackgrounds ();
@@ -37,7 +39,8 @@ CWallpaperApplication::CWallpaperApplication (CApplicationContext& context) :
     this->setupBrowser();
 }
 
-void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedContainer>& container, const std::string& bg) const {
+ContainerUniquePtr CWallpaperApplication::setupContainer (const std::string& bg) const {
+    auto container = std::make_unique <CCombinedContainer> ();
     const std::filesystem::path basepath = bg;
 
     container->add (std::make_unique<CDirectory> (basepath));
@@ -185,6 +188,8 @@ void CWallpaperApplication::setupContainer (const std::shared_ptr<CCombinedConta
     );
 
     container->add (std::move(virtualContainer));
+
+    return container;
 }
 
 void CWallpaperApplication::loadBackgrounds () {
@@ -204,27 +209,16 @@ void CWallpaperApplication::loadBackgrounds () {
     }
 }
 
-std::shared_ptr<Core::CProject> CWallpaperApplication::loadBackground (const std::string& bg) {
-    const auto container = std::make_shared <CCombinedContainer> ();
-
-    this->setupContainer (container, bg);
-
-    // do the parsing with the new parser first
+ProjectUniquePtr CWallpaperApplication::loadBackground (const std::string& bg) {
+    auto container = this->setupContainer (bg);
     auto json = WallpaperEngine::Data::JSON::JSON::parse (container->readFileAsString ("project.json"));
-    const auto project = WallpaperEngine::Data::Parsers::ProjectParser::parse (json, container);
 
-    auto dumper = WallpaperEngine::Data::Dumpers::StringPrinter ();
-
-    dumper.printWallpaper (*project->wallpaper);
-
-    std::cout << dumper.str () << std::endl;
-
-    return Core::CProject::fromFile ("project.json", container);
+    return WallpaperEngine::Data::Parsers::ProjectParser::parse (json, std::move(container));
 }
 
-void CWallpaperApplication::setupPropertiesForProject (const std::shared_ptr<const Core::CProject>& project) {
+void CWallpaperApplication::setupPropertiesForProject (const Project& project) {
     // show properties if required
-    for (const auto& [key, cur] : project->getProperties ()) {
+    for (const auto& [key, cur] : project.properties) {
         // update the value of the property
         auto override = this->m_context.settings.general.properties.find (key);
 
@@ -241,15 +235,16 @@ void CWallpaperApplication::setupPropertiesForProject (const std::shared_ptr<con
 
 void CWallpaperApplication::setupProperties () {
     for (const auto& [background, info] : this->m_backgrounds)
-        this->setupPropertiesForProject (info);
+        this->setupPropertiesForProject (*info);
 }
 
 void CWallpaperApplication::setupBrowser () {
     bool anyWebProject = std::any_of (
         this->m_backgrounds.begin (), this->m_backgrounds.end (),
-        [](const std::pair<const std::string, std::shared_ptr<const Core::CProject>>& pair) -> bool {
-        return pair.second->getWallpaper()->is<Core::Wallpapers::CWeb> ();
-    });
+        [](const std::pair<const std::string, ProjectUniquePtr>& pair) -> bool {
+            return pair.second->wallpaper->is<Web> ();
+        }
+    );
 
     // do not perform any initialization if no web background is present
     if (!anyWebProject) {
@@ -350,9 +345,12 @@ void CWallpaperApplication::setupOutput () {
 
 void CWallpaperApplication::setupAudio () {
     // ensure audioprocessing is required by any background, and we have it enabled
-    bool audioProcessingRequired = std::any_of (this->m_backgrounds.begin (), this->m_backgrounds.end (), [](const auto& pair) -> bool {
-        return pair.second->supportsAudioProcessing ();
-    });
+    bool audioProcessingRequired = std::any_of (
+        this->m_backgrounds.begin (), this->m_backgrounds.end (),
+        [](const std::pair<const std::string, ProjectUniquePtr>& pair) -> bool {
+            return pair.second->supportsAudioProcessing;
+        }
+    );
 
     if (audioProcessingRequired && this->m_context.settings.audio.audioprocessing) {
         this->m_audioRecorder = std::make_unique <WallpaperEngine::Audio::Drivers::Recorders::CPulseAudioPlaybackRecorder> ();
@@ -382,7 +380,7 @@ void CWallpaperApplication::prepareOutputs () {
         m_renderContext->setWallpaper (
             background,
             WallpaperEngine::Render::CWallpaper::fromWallpaper (
-                info->getWallpaper (), *m_renderContext, *m_audioContext, m_browserContext.get (),
+                *info->wallpaper, *m_renderContext, *m_audioContext, m_browserContext.get (),
                 this->m_context.settings.general.screenScalings [background],
                 this->m_context.settings.general.screenClamps [background]
             )
@@ -399,6 +397,8 @@ void CWallpaperApplication::show () {
     static struct tm* timeinfo;
 
     if (this->m_context.settings.general.dumpStructure) {
+        // TODO: REWRITE TO USE THE NEW DUMPER
+        /*
         auto prettyPrinter = PrettyPrinter::CPrettyPrinter ();
 
         for (const auto& [background, info] : this->m_renderContext->getWallpapers ()) {
@@ -406,6 +406,7 @@ void CWallpaperApplication::show () {
         }
 
         std::cout << prettyPrinter.str () << std::endl;
+        */
     }
 
 #if DEMOMODE
@@ -506,7 +507,7 @@ void CWallpaperApplication::signal (int signal) {
     this->m_context.state.general.keepRunning = false;
 }
 
-const std::map<std::string, std::shared_ptr<Core::CProject>>& CWallpaperApplication::getBackgrounds () const {
+const std::map<std::string, ProjectUniquePtr>& CWallpaperApplication::getBackgrounds () const {
     return this->m_backgrounds;
 }
 
@@ -517,4 +518,3 @@ CApplicationContext& CWallpaperApplication::getContext () const {
 const WallpaperEngine::Render::Drivers::Output::COutput& CWallpaperApplication::getOutput () const {
     return this->m_renderContext->getOutput ();
 }
-} // namespace WallpaperEngine::Application
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.h b/src/WallpaperEngine/Application/CWallpaperApplication.h
index 2aa8465..5ef96f0 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.h
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.h
@@ -4,8 +4,6 @@
 
 #include "WallpaperEngine/Assets/CCombinedContainer.h"
 
-#include "WallpaperEngine/Core/CProject.h"
-
 #include "WallpaperEngine/Render/CRenderContext.h"
 #include "WallpaperEngine/Render/CWallpaper.h"
 #include "WallpaperEngine/Render/Drivers/CGLFWOpenGLDriver.h"
@@ -17,7 +15,10 @@
 #include "WallpaperEngine/Input/CInputContext.h"
 #include "WallpaperEngine/WebBrowser/CWebBrowserContext.h"
 
+#include "WallpaperEngine/Data/Model/Types.h"
+
 namespace WallpaperEngine::Application {
+using namespace WallpaperEngine::Data::Model;
 /**
  * Small wrapper class over the actual wallpaper's main application skeleton
  *
@@ -40,7 +41,7 @@ class CWallpaperApplication {
     /**
      * @return Maps screens to loaded backgrounds
      */
-    [[nodiscard]] const std::map<std::string, std::shared_ptr<Core::CProject>>& getBackgrounds () const;
+    [[nodiscard]] const std::map<std::string, ProjectUniquePtr>& getBackgrounds () const;
     /**
      * @return The current application context
      */
@@ -61,7 +62,7 @@ class CWallpaperApplication {
      * @param container
      * @param bg
      */
-    void setupContainer (const std::shared_ptr<CCombinedContainer>& container, const std::string& bg) const;
+    ContainerUniquePtr setupContainer (const std::string& bg) const;
     /**
      * Loads projects based off the settings
      */
@@ -72,7 +73,7 @@ class CWallpaperApplication {
      * @param bg
      * @return
      */
-    [[nodiscard]] std::shared_ptr<Core::CProject> loadBackground (const std::string& bg);
+    [[nodiscard]] ProjectUniquePtr loadBackground (const std::string& bg);
     /**
      * Prepares all background's values and updates their properties if required
      */
@@ -82,7 +83,7 @@ class CWallpaperApplication {
      *
      * @param project
      */
-    void setupPropertiesForProject (const std::shared_ptr<const Core::CProject>& project);
+    void setupPropertiesForProject (const Project& project);
     /**
      * Prepares CEF browser to be used
      */
@@ -109,7 +110,7 @@ class CWallpaperApplication {
     /** The application context that contains the current app settings */
     CApplicationContext& m_context;
     /** Maps screens to backgrounds */
-    std::map<std::string, std::shared_ptr <Core::CProject>> m_backgrounds {};
+    std::map<std::string, ProjectUniquePtr> m_backgrounds {};
 
     std::unique_ptr <WallpaperEngine::Audio::Drivers::Detectors::CAudioPlayingDetector> m_audioDetector = nullptr;
     std::unique_ptr <WallpaperEngine::Audio::CAudioContext> m_audioContext = nullptr;
diff --git a/src/WallpaperEngine/Core/CObject.cpp b/src/WallpaperEngine/Core/CObject.cpp
deleted file mode 100644
index 83efacd..0000000
--- a/src/WallpaperEngine/Core/CObject.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-#include "CObject.h"
-
-#include <utility>
-
-#include "WallpaperEngine/Core/CProject.h"
-#include "WallpaperEngine/Core/Objects/CImage.h"
-#include "WallpaperEngine/Core/Objects/CParticle.h"
-#include "WallpaperEngine/Core/Objects/CSound.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Core/Wallpapers/CScene.h"
-
-#include "WallpaperEngine/Assets/CContainer.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Assets;
-using namespace WallpaperEngine::Core::UserSettings;
-
-CObject::CObject (
-    std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible, int id, std::string name,
-    const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-    std::vector<int> dependencies
-) :
-    m_visible (visible),
-    m_id (id),
-    m_name (std::move(name)),
-    m_origin (origin),
-    m_scale (scale),
-    m_angles (angles),
-    m_project (project),
-    m_dependencies (std::move(dependencies)) {}
-
-const CObject* CObject::fromJSON (
-    const json& data, std::shared_ptr <const Core::CProject> project, const std::shared_ptr<const CContainer>& container
-) {
-    const auto id = jsonFindRequired <int> (data, "id", "Objects must have id");
-    const auto visible = jsonFindUserConfig<CUserSettingBoolean> (data, *project, "visible", true);
-    const auto origin = jsonFindUserConfig<CUserSettingVector3> (data, *project, "origin", {0, 0, 0});
-    const auto scale = jsonFindUserConfig<CUserSettingVector3> (data, *project, "scale", {1, 1, 1});
-    const auto angles_val = jsonFindUserConfig<CUserSettingVector3> (data, *project, "angles", glm::vec3 (0, 0, 0));
-    const auto name = jsonFindRequired <std::string> (data, "name", "Objects must have name");
-    const auto effects_it = data.find ("effects");
-    const auto dependencies_it = data.find ("dependencies");
-
-    const auto image_it = data.find ("image");
-    const auto sound_it = data.find ("sound");
-    const auto particle_it = data.find ("particle");
-    const auto text_it = data.find ("text");
-    const auto light_it = data.find ("light");
-
-    std::vector<int> dependencies;
-    std::vector<const Objects::CEffect*> effects;
-
-    const CObject* object;
-
-    if (dependencies_it != data.end () && dependencies_it->is_array ())
-        for (const auto& cur : *dependencies_it)
-            dependencies.push_back (cur);
-
-    if (image_it != data.end () && !image_it->is_null ()) {
-        object = Objects::CImage::fromJSON (
-            project, data, container, visible, id, name, origin, scale, angles_val, effects_it, dependencies);
-    } else if (sound_it != data.end () && !sound_it->is_null ()) {
-        object = Objects::CSound::fromJSON (project, data, visible, id, name, origin, scale, angles_val, dependencies);
-    } else if (particle_it != data.end () && !particle_it->is_null ()) {
-        /// TODO: XXXHACK -- TO REMOVE WHEN PARTICLE SUPPORT IS PROPERLY IMPLEMENTED
-        try {
-            object = Objects::CParticle::fromFile (
-                project, particle_it->get<std::string> (), container, visible, id, name, origin, angles_val, scale, dependencies);
-        } catch (std::runtime_error&) {
-            return nullptr;
-        }
-    } else if (text_it != data.end () && !text_it->is_null ()) {
-        /// TODO: XXXHACK -- TO REMOVE WHEN TEXT SUPPORT IS IMPLEMENTED
-        return nullptr;
-    } else if (light_it != data.end () && !light_it->is_null ()) {
-        /// TODO: XXXHACK -- TO REMOVE WHEN LIGHT SUPPORT IS IMPLEMENTED
-        return nullptr;
-    } else {
-        sLog.exception ("Unknown object type detected: ", name);
-    }
-
-    return object;
-}
-
-const glm::vec3& CObject::getOrigin () const {
-    return this->m_origin->getVec3 ();
-}
-
-const glm::vec3& CObject::getScale () const {
-    return this->m_scale->getVec3 ();
-}
-
-const glm::vec3& CObject::getAngles () const {
-    return this->m_angles->getVec3 ();
-}
-
-const std::string& CObject::getName () const {
-    return this->m_name;
-}
-
-const std::vector<int>& CObject::getDependencies () const {
-    return this->m_dependencies;
-}
-
-bool CObject::isVisible () const {
-    return this->m_visible->getBool ();
-}
-
-std::shared_ptr <const CProject> CObject::getProject () const {
-    return this->m_project;
-}
-
-int CObject::getId () const {
-    return this->m_id;
-}
diff --git a/src/WallpaperEngine/Core/CObject.h b/src/WallpaperEngine/Core/CObject.h
deleted file mode 100644
index c0102ef..0000000
--- a/src/WallpaperEngine/Core/CObject.h
+++ /dev/null
@@ -1,86 +0,0 @@
-#pragma once
-
-#include "Core.h"
-
-#include "WallpaperEngine/Assets/CContainer.h"
-#include "WallpaperEngine/Core/Objects/CEffect.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
-
-namespace WallpaperEngine::Core::Wallpapers {
-class CScene;
-}
-
-namespace WallpaperEngine::Core::Objects {
-class CEffect;
-}
-
-namespace WallpaperEngine::Core::UserSettings {
-class CUserSettingBoolean;
-}
-
-namespace WallpaperEngine::Core {
-using json = nlohmann::json;
-using namespace WallpaperEngine::Assets;
-using namespace WallpaperEngine::Core::UserSettings;
-
-class CObject {
-    friend class Wallpapers::CScene;
-
-  public:
-    static const CObject* fromJSON ( const json& data, std::shared_ptr <const Core::CProject> project,
-        const std::shared_ptr<const CContainer>& container);
-
-    template <class T> [[nodiscard]] const T* as () const {
-        if (is <T> ()) {
-            return static_cast <const T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] T* as () {
-        if (is <T> ()) {
-            return static_cast <T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] bool is () const {
-        return typeid (*this) == typeid(T);
-    }
-
-    [[nodiscard]] const std::vector<int>& getDependencies () const;
-    [[nodiscard]] int getId () const;
-
-    [[nodiscard]] const glm::vec3& getOrigin () const;
-    [[nodiscard]] const glm::vec3& getScale () const;
-    [[nodiscard]] const glm::vec3& getAngles () const;
-    [[nodiscard]] const std::string& getName () const;
-
-    [[nodiscard]] bool isVisible () const;
-    [[nodiscard]] std::shared_ptr <const Core::CProject> getProject () const;
-
-  protected:
-    CObject (
-        std::shared_ptr <const Core::CProject> scene, const CUserSettingBoolean* visible, int id, std::string name,
-        const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-        std::vector<int> dependencies);
-
-    virtual ~CObject () = default;
-
-  private:
-    const CUserSettingBoolean* m_visible;
-    int m_id = 0;
-    const std::string m_name;
-    const CUserSettingVector3* m_origin;
-    const CUserSettingVector3* m_scale;
-    const CUserSettingVector3* m_angles;
-
-    const std::vector<int> m_dependencies;
-
-    const std::shared_ptr <const Core::CProject> m_project;
-};
-} // namespace WallpaperEngine::Core
diff --git a/src/WallpaperEngine/Core/CProject.cpp b/src/WallpaperEngine/Core/CProject.cpp
deleted file mode 100644
index 3760f42..0000000
--- a/src/WallpaperEngine/Core/CProject.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-#include <WallpaperEngine/Assets/CContainer.h>
-
-#include <utility>
-
-#include "CProject.h"
-#include "WallpaperEngine/Core/Wallpapers/CScene.h"
-#include "WallpaperEngine/Core/Wallpapers/CVideo.h"
-#include "WallpaperEngine/Core/Wallpapers/CWeb.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Wallpapers;
-using namespace WallpaperEngine::Assets;
-
-static int backgroundId = -1;
-
-CProject::CProject (
-    std::string title, std::string type, std::string workshopid, std::shared_ptr<const CContainer> container,
-    bool supportsaudioprocessing, const std::map<std::string, std::shared_ptr<Projects::CProperty>>& properties
-) :
-    m_workshopid(std::move(workshopid)),
-    m_title (std::move(title)),
-    m_type (std::move(type)),
-    m_container (std::move(container)),
-    m_properties (properties),
-    m_supportsaudioprocessing (supportsaudioprocessing) {}
-
-std::shared_ptr<CProject> CProject::fromFile (const std::string& filename, std::shared_ptr<const CContainer> container) {
-    json content = json::parse (container->readFileAsString (filename));
-
-    const auto dependency = jsonFindDefault<std::string> (content, "dependency", "No dependency");
-
-    if (dependency != "No dependency") {
-        sLog.exception ("Project have dependency. They are not supported, quiting");
-    }
-
-    // workshopid is not required, but we have to use it for some identification stuff,
-    // so using a static, decreasing number should be enough
-    bool supportsaudioprocessing = false;
-    auto type = jsonFindRequired <std::string> (content, "type", "Project type missing");
-    const auto file = jsonFindRequired <std::string> (content, "file", "Project's main file missing");
-    auto general = content.find ("general");
-    std::shared_ptr <const CWallpaper> wallpaper = nullptr;
-    std::map<std::string, std::shared_ptr <Projects::CProperty>> properties;
-
-    std::transform (type.begin (), type.end (), type.begin (), tolower);
-
-    if (general != content.end ()) {
-        supportsaudioprocessing = jsonFindDefault (general, "supportsaudioprocessing", false);
-        const auto properties_it = general->find ("properties");
-
-        if (properties_it != general->end ()) {
-            for (const auto& cur : properties_it->items ()) {
-                auto property = Projects::CProperty::fromJSON (cur.value (), cur.key ());
-
-                if (property == nullptr) {
-                    continue;
-                }
-
-                properties.emplace (property->getName (), std::move (property));
-            }
-        }
-    }
-
-    std::shared_ptr<CProject> project = std::make_shared <CProject> (
-        jsonFindRequired <std::string> (content, "title", "Project title missing"),
-        type,
-        jsonFindDefault <std::string> (content, "workshopid", std::to_string (backgroundId--)),
-        container,
-        supportsaudioprocessing,
-        properties
-    );
-
-    if (type == "scene")
-        wallpaper = CScene::fromFile (file, project, container);
-    else if (type == "video")
-        wallpaper = std::make_shared<CVideo> (file, project);
-    else if (type == "web")
-        wallpaper = std::make_shared<CWeb> (file, project);
-    else
-        sLog.exception ("Unsupported wallpaper type: ", type);
-
-    project->setWallpaper (wallpaper);
-
-    return project;
-}
-
-void CProject::setWallpaper (std::shared_ptr <const CWallpaper> wallpaper) {
-    this->m_wallpaper = wallpaper;
-}
-
-const std::shared_ptr <const CWallpaper> CProject::getWallpaper () const {
-    return this->m_wallpaper;
-}
-
-const std::string& CProject::getTitle () const {
-    return this->m_title;
-}
-
-const std::string& CProject::getType () const {
-    return this->m_type;
-}
-
-const std::map<std::string, std::shared_ptr <Projects::CProperty>>& CProject::getProperties () const {
-    return this->m_properties;
-}
-
-const std::string& CProject::getWorkshopId () const {
-    return this->m_workshopid;
-}
-
-std::shared_ptr<const CContainer> CProject::getContainer () const {
-    return this->m_container;
-}
-
-bool CProject::supportsAudioProcessing () const {
-    return this->m_supportsaudioprocessing;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/CProject.h b/src/WallpaperEngine/Core/CProject.h
deleted file mode 100644
index 18c0a5f..0000000
--- a/src/WallpaperEngine/Core/CProject.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include <map>
-#include <nlohmann/json.hpp>
-
-#include "CWallpaper.h"
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-
-#include "WallpaperEngine/Assets/CContainer.h"
-
-namespace WallpaperEngine::Core::Projects {
-class CProperty;
-}
-
-namespace WallpaperEngine::Core {
-using json = nlohmann::json;
-using namespace WallpaperEngine::Assets;
-
-class CWallpaper;
-
-class CProject {
-  public:
-    CProject (
-        std::string title, std::string type, std::string workshopid, std::shared_ptr<const CContainer> container,
-        bool supportsaudioprocessing, const std::map<std::string, std::shared_ptr<Projects::CProperty>>& properties);
-
-    static std::shared_ptr<CProject> fromFile (const std::string& filename, std::shared_ptr<const CContainer> container);
-
-    [[nodiscard]] const std::shared_ptr <const CWallpaper> getWallpaper () const;
-    [[nodiscard]] const std::string& getTitle () const;
-    [[nodiscard]] const std::string& getType () const;
-    [[nodiscard]] const std::map<std::string, std::shared_ptr <Projects::CProperty>>& getProperties () const;
-    [[nodiscard]] const std::string& getWorkshopId () const;
-
-    [[nodiscard]] bool supportsAudioProcessing () const;
-
-    [[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
-
-  protected:
-    void setWallpaper (std::shared_ptr <const CWallpaper> wallpaper);
-
-  private:
-    std::map<std::string, std::shared_ptr<Projects::CProperty>> m_properties;
-
-    const std::string m_workshopid;
-    const std::string m_title;
-    const std::string m_type;
-    const bool m_supportsaudioprocessing;
-    std::shared_ptr <const CWallpaper> m_wallpaper = nullptr;
-    std::shared_ptr<const CContainer> m_container = nullptr;
-};
-} // namespace WallpaperEngine::Core
diff --git a/src/WallpaperEngine/Core/CWallpaper.cpp b/src/WallpaperEngine/Core/CWallpaper.cpp
deleted file mode 100644
index a403787..0000000
--- a/src/WallpaperEngine/Core/CWallpaper.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "CWallpaper.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core;
-
-CWallpaper::CWallpaper (std::shared_ptr <const CProject> project) :
-    m_project (project) {}
-
-std::shared_ptr <const CProject> CWallpaper::getProject () const {
-    return this->m_project;
-}
diff --git a/src/WallpaperEngine/Core/CWallpaper.h b/src/WallpaperEngine/Core/CWallpaper.h
deleted file mode 100644
index a2a78d2..0000000
--- a/src/WallpaperEngine/Core/CWallpaper.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <string>
-
-#include "CProject.h"
-
-namespace WallpaperEngine::Core {
-class CProject;
-
-class CWallpaper {
-  public:
-    template <class T> [[nodiscard]] const T* as () const {
-        if (is<T> ()) {
-            return static_cast <const T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] T* as () {
-        if (is<T> ()) {
-            return static_cast <T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] bool is () const {
-        return typeid(*this) == typeid(T);
-    }
-
-    std::shared_ptr <const CProject> getProject () const;
-
-  protected:
-    friend class CProject;
-
-    explicit CWallpaper (std::shared_ptr <const CProject> project);
-    virtual ~CWallpaper() = default;
-
-  private:
-    std::shared_ptr <const CProject> m_project;
-};
-} // namespace WallpaperEngine::Core
diff --git a/src/WallpaperEngine/Core/Core.cpp b/src/WallpaperEngine/Core/Core.cpp
index 93effef..0f33015 100644
--- a/src/WallpaperEngine/Core/Core.cpp
+++ b/src/WallpaperEngine/Core/Core.cpp
@@ -500,42 +500,3 @@ template const glm::vec4 Core::jsonFindDefault (const nlohmann::json& data, cons
 template const glm::ivec2 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec2 defaultValue);
 template const glm::ivec3 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec3 defaultValue);
 template const glm::ivec4 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec4 defaultValue);
-
-template <typename T> const T* Core::jsonFindUserConfig (
-    const nlohmann::json::const_iterator& data, const CProject& project, const char* key, typename T::data_type defaultValue
-) {
-    const auto it = data->find (key);
-
-    if (it == data->end () || it->type () == nlohmann::detail::value_t::null)
-        return T::fromScalar (defaultValue);
-
-    return T::fromJSON (*it, project.getProperties ());
-}
-
-template const CUserSettingBoolean* Core::jsonFindUserConfig (
-    const nlohmann::json::const_iterator& data, const CProject& project, const char* key,
-    CUserSettingBoolean::data_type defaultValue);
-template const CUserSettingVector3* Core::jsonFindUserConfig (
-    const nlohmann::json::const_iterator& data, const CProject& project, const char* key,
-    CUserSettingVector3::data_type defaultValue);
-template const CUserSettingFloat* Core::jsonFindUserConfig (
-    const nlohmann::json::const_iterator& data, const CProject& project, const char* key,
-    CUserSettingFloat::data_type defaultValue);
-
-template <typename T> const T* Core::jsonFindUserConfig (
-    const nlohmann::json& data, const CProject& project, const char* key, typename T::data_type defaultValue
-) {
-    const auto it = data.find (key);
-
-    if (it == data.end () || it->type () == nlohmann::detail::value_t::null)
-        return T::fromScalar (defaultValue);
-
-    return T::fromJSON (*it, project.getProperties ());
-}
-
-template const CUserSettingBoolean* Core::jsonFindUserConfig (
-    const nlohmann::json& data, const CProject& project, const char* key, CUserSettingBoolean::data_type defaultValue);
-template const CUserSettingVector3* Core::jsonFindUserConfig (
-    const nlohmann::json& data, const CProject& project, const char* key, CUserSettingVector3::data_type defaultValue);
-template const CUserSettingFloat* Core::jsonFindUserConfig (
-    const nlohmann::json& data, const CProject& project, const char* key, CUserSettingFloat::data_type defaultValue);
diff --git a/src/WallpaperEngine/Core/Core.h b/src/WallpaperEngine/Core/Core.h
index 0dc9bab..f3fb7fd 100644
--- a/src/WallpaperEngine/Core/Core.h
+++ b/src/WallpaperEngine/Core/Core.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "CProject.h"
 #include <glm/mat4x4.hpp>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
@@ -44,8 +43,4 @@ template <typename T> const T jsonFindDefault (
     const nlohmann::json::const_iterator& data, const char* key, const T defaultValue);
 template <typename T> const T jsonFindDefault (
     const nlohmann::json& data, const char* key, const T defaultValue);
-template <typename T> const T* jsonFindUserConfig (
-    const nlohmann::json::const_iterator& data, const CProject& project, const char* key, typename T::data_type defaultValue);
-template <typename T> const T* jsonFindUserConfig (
-    const nlohmann::json& data, const CProject& project, const char* key, typename T::data_type defaultValue);
 } // namespace WallpaperEngine::Core
diff --git a/src/WallpaperEngine/Core/Objects/CEffect.cpp b/src/WallpaperEngine/Core/Objects/CEffect.cpp
deleted file mode 100644
index 7d2c482..0000000
--- a/src/WallpaperEngine/Core/Objects/CEffect.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-#include "CEffect.h"
-
-#include <utility>
-
-#include "WallpaperEngine/Core/CProject.h"
-#include "WallpaperEngine/Core/Objects/CImage.h"
-#include "WallpaperEngine/Core/Objects/Images/Materials/CPass.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h"
-
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine;
-using namespace WallpaperEngine::Core::Objects;
-using namespace WallpaperEngine::Core::UserSettings;
-
-CEffect::CEffect (
-    std::string name, std::string description, std::string group, std::string preview,
-    std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible,
-    std::vector<std::string> dependencies, std::vector<const Effects::CFBO*> fbos,
-    std::vector<const Images::CMaterial*> materials
-) :
-    m_name (std::move(name)),
-    m_description (std::move(description)),
-    m_group (std::move(group)),
-    m_preview (std::move(preview)),
-    m_visible (visible),
-    m_dependencies (std::move(dependencies)),
-    m_fbos (std::move(fbos)),
-    m_project (project),
-    m_materials (std::move(materials)) {}
-
-const CEffect* CEffect::fromJSON (
-    const json& data, const CUserSettingBoolean* visible, std::shared_ptr <const Core::CProject> project,
-    const Images::CMaterial* material, const std::shared_ptr<const CContainer>& container
-) {
-    const auto file = jsonFindRequired <std::string> (data, "file", "Object effect must have a file");
-    const auto effectpasses_it = data.find ("passes");
-
-    json content = json::parse (container->readFileAsString(file));
-
-    const auto effectName = jsonFindRequired <std::string> (content, "name", "Effect must have a name");
-    const auto passes_it = jsonFindRequired (content, "passes", "Effect must have a pass list");
-    const auto fbos_it = content.find ("fbos");
-
-    // info to override in the pass information, used by material generation
-    std::map<int, Images::CMaterial::OverrideInfo> overrides;
-    std::vector<const Effects::CFBO*> fbos;
-
-    if (fbos_it != content.end ())
-        fbos = CEffect::fbosFromJSON (fbos_it);
-
-    if (effectpasses_it != data.end ()) {
-        overrides = overridesFromJSON (effectpasses_it, material, project);
-    }
-
-    return new CEffect (
-        effectName,
-        jsonFindDefault<std::string> (content, "description", ""),
-        jsonFindRequired <std::string> (content, "group", "Effect must have a group"),
-        jsonFindDefault<std::string> (content, "preview", ""),
-        project,
-        visible,
-        dependenciesFromJSON (jsonFindRequired (content, "dependencies", "")),
-        fbos,
-        materialsFromJSON (passes_it, effectName, container, overrides)
-    );
-}
-
-std::map<std::string, int> CEffect::combosFromJSON (const json::const_iterator& combos_it) {
-    std::map<std::string, int> combos;
-
-    for (const auto& cur : combos_it->items ()) {
-        auto uppercase = std::string (cur.key ());
-
-        std::transform (uppercase.begin (), uppercase.end (), uppercase.begin (), ::toupper);
-        combos.emplace (uppercase, cur.value ());
-    }
-
-    return combos;
-}
-
-std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> CEffect::constantsFromJSON (
-    const json::const_iterator& constants_it, std::shared_ptr <const Core::CProject> project
-) {
-    std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants;
-
-    for (auto& cur : constants_it->items ()) {
-        auto val = cur.value ();
-
-        Effects::Constants::CShaderConstant* constant = nullptr;
-
-        // if the constant is an object, that means the constant has some extra information
-        // for the UI, take the value, which is what we need
-
-        if (cur.value ().is_object ()) {
-            auto user = cur.value ().find ("user");
-            auto it = cur.value ().find ("value");
-
-            if (user == cur.value ().end () && it == cur.value ().end ()) {
-                sLog.error (R"(Found object for shader constant without "value" and "user" setting)");
-                continue;
-            }
-
-            if (user != cur.value ().end () && user->is_string ()) {
-                // look for a property with the correct name
-                const auto& properties = project->getProperties ();
-                const auto property = properties.find (*user);
-
-                if (property != properties.end ()) {
-                    constant = new Effects::Constants::CShaderConstantProperty (property->second);
-                } else {
-                    sLog.error ("Shader constant pointing to non-existant project property: ", user->get <std::string> ());
-                    val = it.value ();
-                }
-            } else {
-                val = it.value ();
-            }
-        }
-
-        // TODO: REFACTOR THIS SO IT'S NOT SO DEEP INTO THE FUNCTION
-        if (constant == nullptr) {
-            if (val.is_number_float ()) {
-                constant = new Effects::Constants::CShaderConstantFloat (val.get<float> ());
-            } else if (val.is_number_integer ()) {
-                constant = new Effects::Constants::CShaderConstantInteger (val.get<int> ());
-            } else if (val.is_string ()) {
-                // count the amount of spaces to determine which type of vector we have
-                std::string value = val;
-
-                size_t spaces =
-                    std::count_if (value.begin (), value.end (), [&] (const auto& item) { return item == ' '; });
-
-                if (spaces == 1) {
-                    constant =
-                        new Effects::Constants::CShaderConstantVector2 (WallpaperEngine::Core::aToVector2 (value));
-                } else if (spaces == 2) {
-                    constant =
-                        new Effects::Constants::CShaderConstantVector3 (WallpaperEngine::Core::aToVector3 (value));
-                } else if (spaces == 3) {
-                    constant =
-                        new Effects::Constants::CShaderConstantVector4 (WallpaperEngine::Core::aToVector4 (value));
-                } else {
-                    sLog.exception ("unknown shader constant type ", value);
-                }
-            } else {
-                sLog.exception ("unknown shader constant type ", val);
-            }
-        }
-
-        constants.emplace (cur.key (), constant);
-    }
-
-    return constants;
-}
-
-std::vector<const Effects::CFBO*> CEffect::fbosFromJSON (const json::const_iterator& fbos_it) {
-    std::vector<const Effects::CFBO*> fbos;
-
-    for (const auto& cur : (*fbos_it))
-        fbos.push_back (Effects::CFBO::fromJSON (cur));
-
-    return fbos;
-}
-
-std::vector<std::string> CEffect::dependenciesFromJSON (const json::const_iterator& dependencies_it) {
-    std::vector<std::string> dependencies;
-
-    for (const auto& cur : (*dependencies_it))
-        dependencies.push_back (cur);
-
-    return dependencies;
-}
-
-std::vector<const Images::CMaterial*> CEffect::materialsFromJSON (
-    const json::const_iterator& passes_it, const std::string& name, const std::shared_ptr<const CContainer>& container,
-    std::map<int, Images::CMaterial::OverrideInfo> overrides
-) {
-    std::vector<const Images::CMaterial*> materials;
-
-    int materialNumber = -1;
-    for (const auto& cur : (*passes_it)) {
-        ++materialNumber;
-        const auto materialfile = cur.find ("material");
-        const auto target_it = cur.find ("target");
-        const auto bind_it = cur.find ("bind");
-        const auto command_it = cur.find ("command");
-        const auto compose_it = cur.find ("compose");
-        const Images::CMaterial* material = nullptr;
-
-        if (compose_it != cur.end ()) {
-            sLog.error ("Composing materials is not supported yet...");
-        }
-
-        if (materialfile != cur.end ()) {
-            std::map<int, const Effects::CBind*> textureBindings;
-
-            if (bind_it != cur.end ()) {
-                for (const auto& bindCur : (*bind_it)) {
-                    const auto* bind = Effects::CBind::fromJSON (bindCur);
-                    textureBindings.emplace (bind->getIndex (), bind);
-                }
-            }
-
-            const Images::CMaterial::OverrideInfo* overrideInfo = nullptr;
-            const auto overrideIt = overrides.find (materialNumber);
-
-            if (overrideIt != overrides.end ()) {
-                overrideInfo = &overrideIt->second;
-            }
-
-            if (target_it == cur.end ()) {
-                material = Images::CMaterial::fromFile (
-                    materialfile->get<std::string> (), container, false, textureBindings, overrideInfo);
-            } else {
-                material = Images::CMaterial::fromFile (
-                    materialfile->get<std::string> (), *target_it, container, false, textureBindings, overrideInfo);
-            }
-        } else if (command_it != cur.end ()) {
-            material = Images::CMaterial::fromCommand (cur);
-        } else {
-            sLog.exception ("Material without command nor material file: ", name, " (", materialNumber,")");
-        }
-
-        materials.push_back (material);
-    }
-
-    return materials;
-}
-
-std::map<int, Images::CMaterial::OverrideInfo> CEffect::overridesFromJSON (
-    const json::const_iterator& passes_it, const Images::CMaterial* material,
-    std::shared_ptr <const Core::CProject> project
-) {
-    std::map<int, Images::CMaterial::OverrideInfo> result;
-
-    int materialNumber = -1;
-    for (const auto& cur : (*passes_it)) {
-        ++materialNumber;
-        auto constants_it = cur.find ("constantshadervalues");
-        auto combos_it = cur.find ("combos");
-        auto textures_it = cur.find ("textures");
-        Images::CMaterial::OverrideInfo override;
-        int textureNumber = -1;
-
-        if (combos_it != cur.end ()) {
-            override.combos = CEffect::combosFromJSON (combos_it);
-        }
-
-        if (constants_it != cur.end ()) {
-            override.constants = CEffect::constantsFromJSON (constants_it, project);
-        }
-
-        if (textures_it != cur.end ()) {
-            // TODO: MAYBE CHANGE THIS TO BE SOMEWHERE ELSE? THIS IS REALLY MODIFYING THE DATA
-            //  BUT IT'S USEFUL TO HAVE TO SIMPLIFY RENDERING CODE
-            for (const auto& texture : (*textures_it)) {
-                ++textureNumber;
-                std::string name;
-
-                if (texture.is_null () && textureNumber > 0) {
-                    continue;
-                }
-
-                if (textureNumber == 0) {
-                    auto passTextures = (*material->getPasses ().begin ())->getTextures ();
-
-                    if (passTextures.empty()) {
-                        continue;
-                    } else {
-                        name = passTextures.begin ()->second;
-                    }
-                } else {
-                    name = texture;
-                }
-
-                override.textures.emplace (textureNumber, name);
-            }
-        }
-
-        result.emplace (materialNumber, override);
-    }
-
-    return result;
-}
-
-const std::vector<std::string>& CEffect::getDependencies () const {
-    return this->m_dependencies;
-}
-
-const std::vector<const Images::CMaterial*>& CEffect::getMaterials () const {
-    return this->m_materials;
-}
-
-const std::vector<const Effects::CFBO*>& CEffect::getFbos () const {
-    return this->m_fbos;
-}
-
-const Core::CProject& CEffect::getProject () const {
-    return *this->m_project;
-}
-
-bool CEffect::isVisible () const {
-    return this->m_visible->getBool ();
-}
-
-const Effects::CFBO* CEffect::findFBO (const std::string& name) {
-    for (const auto& cur : this->m_fbos)
-        if (cur->getName () == name)
-            return cur;
-
-    sLog.exception ("cannot find fbo ", name);
-}
diff --git a/src/WallpaperEngine/Core/Objects/CEffect.h b/src/WallpaperEngine/Core/Objects/CEffect.h
deleted file mode 100644
index 602ec56..0000000
--- a/src/WallpaperEngine/Core/Objects/CEffect.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Assets/CContainer.h"
-#include "WallpaperEngine/Core/CObject.h"
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Effects/CFBO.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
-
-namespace WallpaperEngine::Core {
-class CObject;
-class CProject;
-}
-
-namespace WallpaperEngine::Core::UserSettings {
-class CUserSettingBoolean;
-}
-
-namespace WallpaperEngine::Core::Objects {
-using json = nlohmann::json;
-using namespace WallpaperEngine::Assets;
-using namespace WallpaperEngine::Core::UserSettings;
-
-/**
- * Represents an effect applied to background objects
- */
-class CEffect {
-  public:
-    CEffect (
-        std::string name, std::string description, std::string group, std::string preview,
-        std::shared_ptr <const Core::CProject>, const CUserSettingBoolean* visible,
-        std::vector<std::string> dependencies, std::vector<const Effects::CFBO*> fbos,
-        std::vector<const Images::CMaterial*> materials);
-
-    static const CEffect* fromJSON (
-        const json& data, const CUserSettingBoolean* visible, std::shared_ptr <const Core::CProject> project,
-        const Images::CMaterial* material, const std::shared_ptr<const CContainer>& container);
-
-    /**
-     * @return List of dependencies for the effect to work
-     */
-    [[nodiscard]] const std::vector<std::string>& getDependencies () const;
-    /**
-     * @return List of materials the effect applies
-     */
-    [[nodiscard]] const std::vector<const Images::CMaterial*>& getMaterials () const;
-    /**
-     * @return The list of FBOs to be used for this effect
-     */
-    [[nodiscard]] const std::vector<const Effects::CFBO*>& getFbos () const;
-    /**
-     * @return If the effect is visible or not
-     */
-    [[nodiscard]] bool isVisible () const;
-    /**
-     * @return The project this effect is part of
-     */
-    [[nodiscard]] const CProject& getProject () const;
-    /**
-     * Searches the FBOs list for the given FBO
-     *
-     * @param name The FBO to search for
-     *
-     * @return
-     */
-    const Effects::CFBO* findFBO (const std::string& name);
-
-  protected:
-    static std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constantsFromJSON (
-        const json::const_iterator& constants_it, std::shared_ptr <const Core::CProject> project);
-    static std::map<std::string, int> combosFromJSON (const json::const_iterator& combos_it);
-    static std::vector<const Effects::CFBO*> fbosFromJSON (const json::const_iterator& fbos_it);
-    static std::vector<std::string> dependenciesFromJSON (const json::const_iterator& dependencies_it);
-    static std::vector<const Images::CMaterial*> materialsFromJSON (
-        const json::const_iterator& passes_it, const std::string& name,
-        const std::shared_ptr<const CContainer>& container, std::map<int, Images::CMaterial::OverrideInfo>);
-    static std::map<int, Images::CMaterial::OverrideInfo> overridesFromJSON (
-        const json::const_iterator& passes_it, const Images::CMaterial* material,
-        std::shared_ptr <const Core::CProject> project);
-
-  private:
-    /** Effect's name */
-    const std::string m_name;
-    /** Effect's description used in the UI */
-    const std::string m_description;
-    /** Effect's group used in the UI */
-    const std::string m_group;
-    /** A project that previews the given effect, used in the UI */
-    const std::string m_preview;
-    /** If the effect is visible or not */
-    const UserSettings::CUserSettingBoolean* m_visible;
-    /** Project this effect is part of */
-    std::shared_ptr <const Core::CProject> m_project;
-
-    /** List of dependencies for the effect */
-    const std::vector<std::string> m_dependencies;
-    /** List of materials the effect applies */
-    const std::vector<const Images::CMaterial*> m_materials;
-    /** List of FBOs required for this effect */
-    const std::vector<const Effects::CFBO*> m_fbos;
-};
-} // namespace WallpaperEngine::Core::Objects
diff --git a/src/WallpaperEngine/Core/Objects/CImage.cpp b/src/WallpaperEngine/Core/Objects/CImage.cpp
deleted file mode 100644
index eb6c0b1..0000000
--- a/src/WallpaperEngine/Core/Objects/CImage.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#include "CImage.h"
-
-#include <utility>
-
-#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
-#include "WallpaperEngine/Core/Wallpapers/CScene.h"
-
-using namespace WallpaperEngine::Core::Objects;
-using namespace WallpaperEngine::Core::UserSettings;
-
-CImage::CImage (
-    std::shared_ptr <const Core::CProject> project, const Images::CMaterial* material,
-    const CUserSettingBoolean* visible, int id, std::string name, const CUserSettingVector3* origin,
-    const CUserSettingVector3* scale, const CUserSettingVector3* angles, glm::vec2 size, std::string alignment,
-    const CUserSettingVector3* color, const CUserSettingFloat* alpha, float brightness, uint32_t colorBlendMode,
-    glm::vec2 parallaxDepth, bool fullscreen, bool passthrough, bool autosize,
-    std::vector<const Objects::CEffect*> effects, std::vector<int> dependencies
-) :
-    CObject (project, visible, id, std::move(name), origin, scale, angles, std::move(dependencies)),
-    m_size (size),
-    m_parallaxDepth (parallaxDepth),
-    m_material (material),
-    m_alignment (std::move(alignment)),
-    m_alpha (alpha),
-    m_brightness (brightness),
-    m_color (color),
-    m_colorBlendMode (colorBlendMode),
-    m_fullscreen (fullscreen),
-    m_passthrough (passthrough),
-    m_autosize (autosize),
-    m_effects (std::move(effects)) {}
-
-const WallpaperEngine::Core::CObject* CImage::fromJSON (
-    std::shared_ptr <const Core::CProject> project, const json& data, const std::shared_ptr<const CContainer>& container,
-    const CUserSettingBoolean* visible, int id, std::string name, const CUserSettingVector3* origin,
-    const CUserSettingVector3* scale, const CUserSettingVector3* angles, const json::const_iterator& effects_it,
-    std::vector<int> dependencies
-) {
-    const auto image = jsonFindRequired <std::string>(data, "image", "Image must have an image");
-    std::vector<const Objects::CEffect*> effects;
-    json content = json::parse (container->readFileAsString (image));
-
-    const auto material = Images::CMaterial::fromFile (
-        jsonFindRequired<std::string> (content, "material", "Image must have a material"),
-        container,
-        jsonFindDefault (content, "solidlayer", false)
-    );
-
-    if (effects_it != data.end () && effects_it->is_array ()) {
-        for (auto& cur : *effects_it) {
-            const auto effectVisible = jsonFindUserConfig<CUserSettingBoolean> (cur, *project, "visible", true);
-
-            // TODO: USER CANNOT MODIFY VALUES ON THE FLY, BUT IT MIGHT BE INTERESTING TO SUPPORT THAT AT SOME POINT?
-            // TODO: AT LEAST THE ORIGINAL SOFTWARE ALLOWS YOU TO DO THAT IN THE PREVIEW WINDOW
-            // TODO: THAT MIGHT INCREASE COMPLEXITY THO...
-            // TODO: ESPECIALLY IF THAT CHANGES RENDERING OF PASSES/IMAGES
-            // TODO: DECISIONS, DECISIONS, DECISIONS...
-            if (!effectVisible->getBool ())
-                continue;
-
-            effects.push_back (
-                Objects::CEffect::fromJSON (
-                    cur, effectVisible, project, material, container
-                )
-            );
-        }
-    }
-
-    return new CImage (
-        project,
-        material,
-        visible,
-        id,
-        std::move(name),
-        origin,
-        scale,
-        angles,
-        jsonFindDefault<glm::vec2> (data, "size", glm::vec2 (0.0, 0.0)),
-        jsonFindDefault<std::string> (data, "alignment", "center"),
-        jsonFindUserConfig<CUserSettingVector3> (data, *project, "color", {1, 1, 1}),
-        jsonFindUserConfig<CUserSettingFloat> (data, *project, "alpha", 1.0),
-        jsonFindDefault<float> (data, "brightness", 1.0),
-        jsonFindDefault<uint32_t> (data, "colorBlendMode", 0),
-        jsonFindDefault<glm::vec2> (data, "parallaxDepth", glm::vec2 (0.0, 0.0)),
-        jsonFindDefault<bool> (content, "fullscreen", false),
-        jsonFindDefault<bool> (content, "passthrough", false),
-        jsonFindDefault<bool> (content, "autosize", false),
-        effects,
-        std::move(dependencies)
-    );
-}
-
-const Images::CMaterial* CImage::getMaterial () const {
-    return this->m_material;
-}
-
-const glm::vec2& CImage::getSize () const {
-    return this->m_size;
-}
-
-const std::string& CImage::getAlignment () const {
-    return this->m_alignment;
-}
-
-float CImage::getAlpha () const {
-    return this->m_alpha->getFloat ();
-}
-
-const glm::vec3& CImage::getColor () const {
-    return this->m_color->getVec3 ();
-}
-
-float CImage::getBrightness () const {
-    return this->m_brightness;
-}
-
-uint32_t CImage::getColorBlendMode () const {
-    return this->m_colorBlendMode;
-}
-
-const glm::vec2& CImage::getParallaxDepth () const {
-    return this->m_parallaxDepth;
-}
-
-bool CImage::isFullscreen () const {
-    return this->m_fullscreen;
-}
-
-bool CImage::isPassthrough () const {
-    return this->m_passthrough;
-}
-
-bool CImage::isAutosize () const {
-    return this->m_autosize;
-}
-
-const std::vector<const CEffect*>& CImage::getEffects () const {
-    return this->m_effects;
-}
diff --git a/src/WallpaperEngine/Core/Objects/CImage.h b/src/WallpaperEngine/Core/Objects/CImage.h
deleted file mode 100644
index f78cc4b..0000000
--- a/src/WallpaperEngine/Core/Objects/CImage.h
+++ /dev/null
@@ -1,122 +0,0 @@
-#pragma once
-
-#include <vector>
-
-#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
-
-#include "WallpaperEngine/Core/CObject.h"
-#include "WallpaperEngine/Core/Core.h"
-
-#include "WallpaperEngine/Assets/CContainer.h"
-
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
-
-namespace WallpaperEngine::Core::Wallpapers {
-class CScene;
-}
-
-namespace WallpaperEngine::Core::Objects {
-using json = nlohmann::json;
-using namespace WallpaperEngine::Assets;
-using namespace WallpaperEngine::Core::UserSettings;
-
-/**
- * Represents an image in a background
- */
-class CImage : public CObject {
-    friend class CObject;
-
-  public:
-    static const CObject* fromJSON (
-        std::shared_ptr <const Core::CProject> project, const json& data,
-        const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
-        std::string name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
-        const CUserSettingVector3* angles, const json::const_iterator& effects_it, std::vector<int> dependencies);
-
-    /**
-     * @return The base material to use for the image
-     */
-    [[nodiscard]] const Images::CMaterial* getMaterial () const;
-    /**
-     * @return The size of the image
-     */
-    [[nodiscard]] const glm::vec2& getSize () const;
-    /**
-     * @return The type of alignment to use for image positioning
-     */
-    [[nodiscard]] const std::string& getAlignment () const;
-    /**
-     * @return The alpha value for the image's rendering
-     */
-    [[nodiscard]] float getAlpha () const;
-    /**
-     * @return The color to use for the image
-     */
-    [[nodiscard]] const glm::vec3& getColor () const;
-    /**
-     * @return The brightness to use for the image
-     */
-    [[nodiscard]] float getBrightness () const;
-    /**
-     * @return The color blending mode to be used, special value for shaders
-     */
-    [[nodiscard]] uint32_t getColorBlendMode () const;
-    /**
-     * @return Parallax depth of the image
-     */
-    [[nodiscard]] const glm::vec2& getParallaxDepth () const;
-    /**
-     * @return If the image is fullscreen or not
-     */
-    [[nodiscard]] bool isFullscreen () const;
-    /**
-     * @return If the image is passthrough or not
-     */
-    [[nodiscard]] bool isPassthrough () const;
-    /**
-     * @return If the image is autosized or not
-     */
-    [[nodiscard]] bool isAutosize () const;
-    /**
-     * @return All of the effects applied to this image
-     */
-    [[nodiscard]] const std::vector<const Objects::CEffect*>& getEffects () const;
-
-  protected:
-    CImage (
-        std::shared_ptr <const Core::CProject> project, const Images::CMaterial* material,
-        const CUserSettingBoolean* visible, int id, std::string name, const CUserSettingVector3* origin,
-        const CUserSettingVector3* scale, const CUserSettingVector3* angles, glm::vec2 size, std::string alignment,
-        const CUserSettingVector3* color, const CUserSettingFloat* alpha, float brightness, uint32_t colorBlendMode,
-        glm::vec2 parallaxDepth, bool fullscreen, bool passthrough, bool autosize,
-        std::vector<const Objects::CEffect*> effects, std::vector<int> dependencies);
-
-  private:
-    /** The image's size */
-    const glm::vec2 m_size;
-    /** Parallax depth */
-    const glm::vec2 m_parallaxDepth;
-    /** Base material for the image */
-    const Images::CMaterial* m_material;
-    /** What type of alignment to use for the image's position */
-    const std::string m_alignment;
-    /** The alpha value for the image */
-    const CUserSettingFloat* m_alpha;
-    /** The brightness for the image */
-    float m_brightness;
-    /** The color to use for the image */
-    const CUserSettingVector3* m_color;
-    /** The color blending mode used for the image, special value for shaders */
-    const uint32_t m_colorBlendMode;
-    /** Override for effects */
-    const std::vector<const Objects::CEffect*> m_effects;
-    /** If the image is fullscreen or not */
-    bool m_fullscreen = false;
-    /** If the image is passthrough or not */
-    bool m_passthrough = false;
-    /** If the image's size should be automatically determined */
-    bool m_autosize = false;
-};
-} // namespace WallpaperEngine::Core::Objects
diff --git a/src/WallpaperEngine/Core/Objects/CSound.cpp b/src/WallpaperEngine/Core/Objects/CSound.cpp
deleted file mode 100644
index 3ca94e6..0000000
--- a/src/WallpaperEngine/Core/Objects/CSound.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "CSound.h"
-
-#include <utility>
-#include "WallpaperEngine/Core/CObject.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core::Objects;
-
-CSound::CSound (
-    std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible, int id, std::string name,
-    const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-    bool repeat, std::vector<std::string> sounds, std::vector<int> dependencies
-) :
-    CObject (project, visible, id, std::move(name), origin, scale, angles, std::move(dependencies)),
-    m_repeat (repeat),
-    m_sounds (std::move(sounds)) {}
-
-const WallpaperEngine::Core::CObject* CSound::fromJSON (
-    std::shared_ptr <const Core::CProject> project, const json& data, const CUserSettingBoolean* visible,
-    int id, const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
-    const CUserSettingVector3* angles, std::vector<int> dependencies
-) {
-    // TODO: PARSE AUDIO VOLUME
-    std::vector<std::string> sounds;
-    const auto sound_it = jsonFindRequired (data, "sound", "Sound information not present");
-
-    if (!sound_it->is_array ())
-        sLog.exception ("Expected sound list on element ", name);
-
-    for (const auto& cur : (*sound_it))
-        sounds.push_back (cur);
-
-    return new CSound (
-        project,
-        visible,
-        id,
-        name,
-        origin,
-        scale,
-        angles,
-        jsonFindDefault<std::string> (data, "playbackmode", "") == "loop",
-        sounds,
-        std::move(dependencies)
-    );
-}
-
-const std::vector<std::string>& CSound::getSounds () const {
-    return this->m_sounds;
-}
-
-bool CSound::isRepeat () const {
-    return this->m_repeat;
-}
diff --git a/src/WallpaperEngine/Core/Objects/CSound.h b/src/WallpaperEngine/Core/Objects/CSound.h
deleted file mode 100644
index 8784788..0000000
--- a/src/WallpaperEngine/Core/Objects/CSound.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/CObject.h"
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-
-namespace WallpaperEngine::Core::Wallpapers {
-class CScene;
-}
-
-namespace WallpaperEngine::Core::Objects {
-using json = nlohmann::json;
-using namespace WallpaperEngine::Core::UserSettings;
-
-/**
- * Represents a sound played while the background is working
- */
-class CSound : public CObject {
-    friend class CObject;
-
-  public:
-    static const CObject* fromJSON (
-        std::shared_ptr <const Core::CProject> project, const json& data, const CUserSettingBoolean* visible,
-        int id, const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* scale,
-        const CUserSettingVector3* angles, std::vector<int> dependencies);
-
-    /**
-     * @return The list of sounds to play
-     */
-    [[nodiscard]] const std::vector<std::string>& getSounds () const;
-    /**
-     * @return If the sound should repeat or not
-     */
-    [[nodiscard]] bool isRepeat () const;
-
-  protected:
-    CSound (
-        std::shared_ptr <const Core::CProject> project, const CUserSettingBoolean* visible, int id, std::string name,
-        const CUserSettingVector3* origin, const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-        bool repeat, std::vector<std::string> sounds, std::vector<int> dependencies);
-
-  private:
-    /** If the sounds should repeat or not */
-    bool m_repeat = false;
-    /** The list of sounds to play */
-    std::vector<std::string> m_sounds = {};
-};
-} // namespace WallpaperEngine::Core::Objects
diff --git a/src/WallpaperEngine/Core/Objects/Effects/CBind.cpp b/src/WallpaperEngine/Core/Objects/Effects/CBind.cpp
deleted file mode 100644
index 37ad6a9..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/CBind.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "CBind.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects::Effects;
-
-CBind::CBind (std::string name, uint32_t index) :
-    m_name (std::move(name)),
-    m_index (index) {}
-
-const CBind* CBind::fromJSON (const json& data) {
-    return new CBind (
-        jsonFindRequired <std::string> (data, "name", "bind must have texture name"),
-        jsonFindRequired <uint32_t> (data, "index", "bind must have index")
-    );
-}
-
-const std::string& CBind::getName () const {
-    return this->m_name;
-}
-
-const uint32_t& CBind::getIndex () const {
-    return this->m_index;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Effects/CBind.h b/src/WallpaperEngine/Core/Objects/Effects/CBind.h
deleted file mode 100644
index 6fd790c..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/CBind.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Effects {
-using json = nlohmann::json;
-
-/**
- * Material's bind information, describes for passes what textures to bind
- * in what positions for shaders. Used to override the textures specified inside
- * the object's passes
- */
-class CBind {
-  public:
-    /**
-     * Parses bind information off the given json data
-     *
-     * @param data
-     * @return
-     */
-    static const CBind* fromJSON (const json& data);
-
-    /**
-     * @return The texture name, previous to use the one already specified by the object's passes
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return The texture index to replace
-     */
-    [[nodiscard]] const uint32_t& getIndex () const;
-
-  protected:
-    CBind (std::string name, uint32_t index);
-
-  private:
-    /** The texture's name */
-    const std::string m_name;
-    /** The texture index to replace */
-    const uint32_t m_index;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects
diff --git a/src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp b/src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp
deleted file mode 100644
index ad1c459..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/CFBO.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "CFBO.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Objects::Effects;
-
-CFBO::CFBO (std::string name, float scale, std::string format) :
-    m_name (std::move(name)),
-    m_scale (scale),
-    m_format (std::move(format)) {}
-
-const CFBO* CFBO::fromJSON (const json& data) {
-    return new CFBO (
-        jsonFindRequired <std::string> (data, "name", "Name for an FBO is required"),
-        jsonFindDefault <float> (data, "scale", 1.0),
-        jsonFindDefault <std::string> (data, "format", "")
-    );
-}
-
-const std::string& CFBO::getName () const {
-    return this->m_name;
-}
-
-const float& CFBO::getScale () const {
-    return this->m_scale;
-}
-
-const std::string& CFBO::getFormat () const {
-    return this->m_format;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Effects/CFBO.h b/src/WallpaperEngine/Core/Objects/Effects/CFBO.h
deleted file mode 100644
index cc2e694..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/CFBO.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-#include <nlohmann/json.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects {
-using json = nlohmann::json;
-
-/**
- * FBO = Frame Buffer Object
- *
- * Represents a framebuffer object used in objects with multiple effects or render passes
- */
-class CFBO {
-  public:
-    static const CFBO* fromJSON (const json& data);
-
-    /**
-     * @return The FBO name used to identify it in the background's files
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return The scale factor of the FBO
-     */
-    [[nodiscard]] const float& getScale () const;
-    /**
-     * @return The FBO's format for the render
-     */
-    [[nodiscard]] const std::string& getFormat () const;
-
-  protected:
-    CFBO (std::string name, float scale, std::string format);
-
-  private:
-    /** The name of the FBO */
-    const std::string m_name;
-    /** The scale factor of the FBO */
-    const float m_scale;
-    /** The FBO's format for the render */
-    const std::string m_format;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp b/src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp
deleted file mode 100644
index bf2eaab..0000000
--- a/src/WallpaperEngine/Core/Objects/Images/CMaterial.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#include "CMaterial.h"
-
-#include "WallpaperEngine/Core/Objects/Images/Materials/CPass.h"
-#include "WallpaperEngine/Logging/CLog.h"
-#include <nlohmann/json.hpp>
-#include <utility>
-
-using namespace WallpaperEngine::Assets;
-
-using namespace WallpaperEngine::Core::Objects;
-using namespace WallpaperEngine::Core::Objects::Images;
-
-CMaterial::CMaterial (
-    std::string name, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
-    std::vector<const Materials::CPass*> passes
-) :
-    m_name (std::move(name)),
-    m_textureBindings (std::move(textureBindings)),
-    m_passes (std::move(passes)),
-    m_solidlayer (solidlayer) {}
-CMaterial::CMaterial (
-    std::string name, std::string target, bool solidlayer,
-    std::map<int, const Effects::CBind*> textureBindings, std::vector<const Materials::CPass*> passes
-) :
-    m_name (std::move(name)),
-    m_target (std::move(target)),
-    m_textureBindings (std::move(textureBindings)),
-    m_passes (std::move(passes)),
-    m_solidlayer (solidlayer)  {}
-
-const CMaterial* CMaterial::fromFile (
-    const std::filesystem::path& filename, const std::shared_ptr<const CContainer>& container, bool solidlayer,
-    std::map<int, const Effects::CBind*> textureBindings, const OverrideInfo* overrides
-) {
-    return fromJSON (filename, json::parse (container->readFileAsString (filename)), solidlayer, std::move(textureBindings), overrides);
-}
-
-const CMaterial* CMaterial::fromFile (
-    const std::filesystem::path& filename, const std::string& target, const std::shared_ptr<const CContainer>& container, bool solidlayer,
-    std::map<int, const Effects::CBind*> textureBindings, const OverrideInfo* overrides
-) {
-    return fromJSON (filename, json::parse (container->readFileAsString (filename)), target, solidlayer, std::move(textureBindings), overrides);
-}
-
-const CMaterial* CMaterial::fromJSON (
-    const std::string& name, const json& data, const std::string& target, bool solidlayer,
-    std::map<int, const Effects::CBind*> textureBindings, const OverrideInfo* overrides
-) {
-    const auto passes_it = jsonFindRequired (data, "passes", "Material must have at least one pass");
-    std::vector<const Materials::CPass*> passes;
-
-    for (const auto& cur : (*passes_it))
-        passes.push_back (Materials::CPass::fromJSON (cur, overrides));
-
-    return new CMaterial (name, target, solidlayer, std::move(textureBindings), passes);
-}
-
-const CMaterial* CMaterial::fromJSON (
-    const std::string& name, const json& data, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
-    const OverrideInfo* overrides
-) {
-    const auto passes_it = jsonFindRequired (data, "passes", "Material must have at least one pass");
-    std::vector<const Materials::CPass*> passes;
-
-    for (const auto& cur : (*passes_it))
-        passes.push_back (Materials::CPass::fromJSON (cur, overrides));
-
-    return new CMaterial (name, solidlayer, std::move(textureBindings), passes);
-}
-
-const CMaterial* CMaterial::fromCommand (const json& data) {
-    const std::string& command = jsonFindRequired <std::string> (data, "command", "Command material must have a command");
-    const std::string& target = jsonFindRequired <std::string> (data, "target", "Command material must have a target");
-    const std::string& source = jsonFindRequired <std::string> (data, "source", "Command material must have a source");
-    std::vector<const Materials::CPass*> passes;
-
-    if (command == "copy") {
-        passes.push_back (
-            Materials::CPass::fromJSON ({
-                {"blending", "normal"},
-                {"cullmode", "nocull"},
-                {"depthtest", "disabled"},
-                {"depthwrite", "disabled"},
-                {"shader", "commands/copy"},
-                {"textures", json::array ({source, target})}
-            }, nullptr)
-        );
-    } else if (command == "swap") {
-        // TODO: HOW TO IMPLEMENT THIS ONE?
-        sLog.exception ("Command material swap not implemented yet");
-    } else {
-        sLog.exception ("Unknown command: ", command);
-    }
-
-    return new CMaterial (command, false, {}, passes);
-}
-
-const std::vector<const Materials::CPass*>& CMaterial::getPasses () const {
-    return this->m_passes;
-}
-
-const std::map<int, const Effects::CBind*>& CMaterial::getTextureBinds () const {
-    return this->m_textureBindings;
-}
-
-const std::string& CMaterial::getTarget () const {
-    return this->m_target;
-}
-
-const std::string& CMaterial::getName () const {
-    return this->m_name;
-}
-
-bool CMaterial::hasTarget () const {
-    return !this->m_target.empty ();
-}
-
-bool CMaterial::isSolidLayer () const {
-    return this->m_solidlayer;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Images/CMaterial.h b/src/WallpaperEngine/Core/Objects/Images/CMaterial.h
deleted file mode 100644
index e1a3496..0000000
--- a/src/WallpaperEngine/Core/Objects/Images/CMaterial.h
+++ /dev/null
@@ -1,89 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Effects/CBind.h"
-
-#include "WallpaperEngine/Assets/CContainer.h"
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-
-namespace WallpaperEngine::Core::Objects::Images::Materials {
-class CPass;
-}
-
-namespace WallpaperEngine::Core::Objects::Images {
-using json = nlohmann::json;
-using namespace WallpaperEngine::Assets;
-
-/**
- * Represents a material in use in the background
- */
-class CMaterial {
-  public:
-    struct OverrideInfo {
-        std::map<std::string, int> combos;
-        std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants;
-        std::map<int, std::string> textures;
-    };
-
-    static const CMaterial* fromFile (
-        const std::filesystem::path& filename, const std::shared_ptr<const CContainer>& container, bool solidlayer = false,
-        std::map<int, const Effects::CBind*> textureBindings = {}, const OverrideInfo* overrides = nullptr);
-    static const CMaterial* fromFile (
-        const std::filesystem::path& filename, const std::string& target, const std::shared_ptr<const CContainer>& container,
-        bool solidlayer = false, std::map<int, const Effects::CBind*> textureBindings = {},
-        const OverrideInfo* overrides = nullptr);
-    static const CMaterial* fromJSON (
-        const std::string& name, const json& data, bool solidlayer = false,
-        std::map<int, const Effects::CBind*> textureBindings = {}, const OverrideInfo* overrides = nullptr);
-    static const CMaterial* fromJSON (
-        const std::string& name, const json& data, const std::string& target, bool solidlayer = false,
-        std::map<int, const Effects::CBind*> textureBindings = {}, const OverrideInfo* overrides = nullptr);
-    static const CMaterial* fromCommand (const json& data);
-
-    /**
-     * @return All the rendering passes that happen for this material
-     */
-    [[nodiscard]] const std::vector<const Materials::CPass*>& getPasses () const;
-    /**
-     * @return The textures that have to be bound while rendering the material.
-     * 		   These act as an override of the textures specified by the parent effect
-     */
-    [[nodiscard]] const std::map<int, const Effects::CBind*>& getTextureBinds () const;
-    /**
-     * @return The materials destination (fbo) if required
-     */
-    [[nodiscard]] const std::string& getTarget () const;
-    /**
-     * @return Indicates if this material has a specific destination (fbo) while rendering
-     */
-    [[nodiscard]] bool hasTarget () const;
-    /**
-     * @return The name of the material
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return If this material is a solidlayer or not
-     */
-    [[nodiscard]] bool isSolidLayer () const;
-
-  protected:
-    CMaterial (
-        std::string name, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
-        std::vector<const Materials::CPass*> passes);
-    CMaterial (
-        std::string name, std::string target, bool solidlayer, std::map<int, const Effects::CBind*> textureBindings,
-        std::vector<const Materials::CPass*> passes);
-
-  private:
-    /** All the shader passes required to render this material */
-    const std::vector<const Materials::CPass*> m_passes;
-    /** List of texture bind overrides to use for this material */
-    const std::map<int, const Effects::CBind*> m_textureBindings;
-    /** The FBO target to render to (if any) */
-    const std::string m_target;
-    /** The material's name */
-    const std::string m_name;
-    /** If this material is a solid layer or not */
-    const bool m_solidlayer;
-};
-} // namespace WallpaperEngine::Core::Objects::Images
diff --git a/src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp b/src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
deleted file mode 100644
index e07c9b4..0000000
--- a/src/WallpaperEngine/Core/Objects/Images/Materials/CPass.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#include "CPass.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-using namespace WallpaperEngine::Core::Objects::Images::Materials;
-
-CPass::CPass (std::string blending, std::string cullmode, std::string depthtest, std::string depthwrite,
-              std::string shader, std::map<int, std::string> textures, std::map<std::string, int> combos,
-              std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants) :
-    m_blending (std::move(blending)),
-    m_cullmode (std::move(cullmode)),
-    m_depthtest (std::move(depthtest)),
-    m_depthwrite (std::move(depthwrite)),
-    m_shader (std::move(shader)),
-    m_textures (std::move(textures)),
-    m_combos (std::move(combos)),
-    m_constants (std::move(constants)) {}
-
-const CPass* CPass::fromJSON (const json& data, const CMaterial::OverrideInfo* overrides) {
-    // TODO: FIGURE OUT DEFAULT BLENDING MODE
-    const auto textures_it = data.find ("textures");
-    const auto combos_it = data.find ("combos");
-
-    std::map<int, std::string> textures;
-    std::map<std::string, int> combos;
-    std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants;
-
-    if (textures_it != data.end ()) {
-        // TODO: FETCH THIS FROM CImage TO MAKE IT COMPATIBLE WITH OLDER WALLPAPERS
-        if (!textures_it->is_array ())
-            sLog.exception ("Material's textures must be a list");
-
-        int textureNumber = -1;
-        for (const auto& cur : (*textures_it))
-            textures.emplace (++textureNumber, cur.is_null () ? "" : cur);
-    }
-
-    if (combos_it != data.end ()) {
-        for (const auto& cur : combos_it->items ()) {
-            if (cur.value ().is_number_integer ()) {
-                std::string uppercase = std::string (cur.key ());
-
-                std::transform (uppercase.begin (), uppercase.end (), uppercase.begin (), ::toupper);
-                combos.emplace (uppercase, cur.value ());
-            } else {
-                sLog.exception ("unexpected non-integer combo on pass");
-            }
-        }
-    }
-
-    // apply overrides
-    if (overrides != nullptr) {
-        for (const auto& [name, value] : overrides->combos)
-            combos[name] = value;
-        for (const auto& [name, value] : overrides->constants)
-            constants[name] = value;
-        for (const auto& [id, value] : overrides->textures)
-            textures[id] = value;
-    }
-
-    return new CPass (
-        jsonFindDefault<std::string> (data, "blending", "normal"),
-        jsonFindDefault<std::string> (data, "cullmode", "nocull"),
-        jsonFindRequired <std::string> (data, "depthtest", "Material pass must have depthtest specified"),
-        jsonFindRequired <std::string> (data, "depthwrite", "Material pass must have depthwrite specified"),
-        jsonFindRequired <std::string> (data, "shader", "Material pass must have shader specified"),
-        textures,
-        combos,
-        constants
-    );
-}
-
-const std::map<int, std::string>& CPass::getTextures () const {
-    return this->m_textures;
-}
-
-const std::map<std::string, const CShaderConstant*>& CPass::getConstants () const {
-    return this->m_constants;
-}
-
-const std::map<std::string, int>& CPass::getCombos () const {
-    return this->m_combos;
-}
-
-const std::string& CPass::getShader () const {
-    return this->m_shader;
-}
-
-const std::string& CPass::getBlendingMode () const {
-    return this->m_blending;
-}
-
-const std::string& CPass::getCullingMode () const {
-    return this->m_cullmode;
-}
-
-const std::string& CPass::getDepthTest () const {
-    return this->m_depthtest;
-}
-
-const std::string& CPass::getDepthWrite () const {
-    return this->m_depthwrite;
-}
diff --git a/src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h b/src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
deleted file mode 100644
index e14889a..0000000
--- a/src/WallpaperEngine/Core/Objects/Images/Materials/CPass.h
+++ /dev/null
@@ -1,84 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-
-namespace WallpaperEngine::Core::Objects {
-class CEffect;
-}
-
-namespace WallpaperEngine::Core::Objects::Images {
-class CMaterial;
-}
-
-namespace WallpaperEngine::Core::Objects::Images::Materials {
-using json = nlohmann::json;
-
-/**
- * Represents a shader pass of an object
- */
-class CPass {
-    friend class WallpaperEngine::Core::Objects::CEffect;
-
-  public:
-    static const CPass* fromJSON (const json& data, const CMaterial::OverrideInfo* overrides);
-
-    /**
-     * @return The list of textures to bind while rendering
-     */
-    [[nodiscard]] const std::map<int, std::string>& getTextures () const;
-    /**
-     * @return Shader constants that alter how the shader should behave
-     */
-    [[nodiscard]] const std::map<std::string, const Effects::Constants::CShaderConstant*>& getConstants () const;
-    /**
-     * @return Shader combos that alter how the shader should behave
-     */
-    [[nodiscard]] const std::map<std::string, int>& getCombos () const;
-    /**
-     * @return Shader to be used while rendering the pass
-     */
-    [[nodiscard]] const std::string& getShader () const;
-    /**
-     * @return The blending mode to use while rendering
-     */
-    [[nodiscard]] const std::string& getBlendingMode () const;
-    /**
-     * @return The culling mode to use while rendering
-     */
-    [[nodiscard]] const std::string& getCullingMode () const;
-    /**
-     * @return If depth testing has to happen while rendering
-     */
-    [[nodiscard]] const std::string& getDepthTest () const;
-    /**
-     * @return If depth write has to happen while rendering
-     */
-    [[nodiscard]] const std::string& getDepthWrite () const;
-
-  protected:
-    CPass (std::string blending, std::string cullmode, std::string depthtest, std::string depthwrite,
-           std::string shader, std::map<int, std::string> textures, std::map<std::string, int> combos,
-           std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> constants);
-
-  private:
-    // TODO: CREATE ENUMERATIONS FOR THESE INSTEAD OF USING STRING VALUES!
-    /** The blending mode to use */
-    const std::string m_blending;
-    /** The culling mode to use */
-    const std::string m_cullmode;
-    /** If depthtesting has to happen while drawing */
-    const std::string m_depthtest;
-    /** If depthwrite has to happen while drawing */
-    const std::string m_depthwrite;
-    /** The shader to use */
-    const std::string m_shader;
-    /** The list of textures to use */
-    const std::map<int, std::string> m_textures;
-    /** Different combo settings for shader input */
-    const std::map<std::string, int> m_combos;
-    /** Shader constant values to use for  the shaders */
-    const std::map<std::string, const Core::Objects::Effects::Constants::CShaderConstant*> m_constants;
-};
-} // namespace WallpaperEngine::Core::Objects::Images::Materials
diff --git a/src/WallpaperEngine/Core/Scenes/CCamera.cpp b/src/WallpaperEngine/Core/Scenes/CCamera.cpp
deleted file mode 100644
index 05118bc..0000000
--- a/src/WallpaperEngine/Core/Scenes/CCamera.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "CCamera.h"
-
-using namespace WallpaperEngine::Core::Scenes;
-
-CCamera::CCamera (glm::vec3 center, glm::vec3 eye, glm::vec3 up) :
-    m_center (center),
-    m_eye (eye),
-    m_up (up) {}
-
-const glm::vec3& CCamera::getCenter () const {
-    return this->m_center;
-}
-
-const glm::vec3& CCamera::getEye () const {
-    return this->m_eye;
-}
-
-const glm::vec3& CCamera::getUp () const {
-    return this->m_up;
-}
-
-const CCamera* CCamera::fromJSON (const json::const_iterator& data) {
-    return new CCamera (
-        jsonFindRequired <glm::vec3> (data, "center", "Camera must have a center position"),
-        jsonFindRequired <glm::vec3> (data, "eye", "Camera must have an eye position"),
-        jsonFindRequired <glm::vec3> (data, "up", "Camera must have a up position")
-    );
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Scenes/CCamera.h b/src/WallpaperEngine/Core/Scenes/CCamera.h
deleted file mode 100644
index 5d2f17f..0000000
--- a/src/WallpaperEngine/Core/Scenes/CCamera.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Scenes {
-using json = nlohmann::json;
-
-class CCamera {
-  public:
-    static const CCamera* fromJSON (const json::const_iterator& data);
-
-    const glm::vec3& getCenter () const;
-    const glm::vec3& getEye () const;
-    const glm::vec3& getUp () const;
-
-  protected:
-    CCamera (glm::vec3 center, glm::vec3 eye, glm::vec3 up);
-
-  private:
-    const glm::vec3 m_center;
-    const glm::vec3 m_eye;
-    const glm::vec3 m_up;
-};
-} // namespace WallpaperEngine::Core::Scenes
diff --git a/src/WallpaperEngine/Core/Scenes/CProjection.cpp b/src/WallpaperEngine/Core/Scenes/CProjection.cpp
deleted file mode 100644
index d9ee5b0..0000000
--- a/src/WallpaperEngine/Core/Scenes/CProjection.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "CProjection.h"
-
-using namespace WallpaperEngine::Core::Scenes;
-
-CProjection::CProjection (int width, int height) :
-    m_width (width),
-    m_height (height),
-    m_isAuto (false) {}
-
-CProjection::CProjection (bool isAuto) :
-    m_width (0),
-    m_height (0),
-    m_isAuto (isAuto) {}
-
-const int& CProjection::getWidth () const {
-    return this->m_width;
-}
-
-const int& CProjection::getHeight () const {
-    return this->m_height;
-}
-
-bool CProjection::isAuto () const {
-    return this->m_isAuto;
-}
-
-void CProjection::setWidth (int width) const {
-    this->m_width = width;
-}
-
-void CProjection::setHeight (int height) const {
-    this->m_height = height;
-}
-
-const CProjection* CProjection::fromJSON (const json::const_iterator& data) {
-    const auto auto_it = jsonFindDefault<bool> (data, "auto", false);
-
-    const auto width_it = jsonFindRequired (data, "width", "Projection must have width");
-    const auto height_it = jsonFindRequired (data, "height", "Projection must have height");
-
-    // TODO: PROPERLY SUPPORT AUTO-DETECTING SIZE
-    if (auto_it)
-        return new CProjection (true);
-
-    return new CProjection (*width_it, *height_it);
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Scenes/CProjection.h b/src/WallpaperEngine/Core/Scenes/CProjection.h
deleted file mode 100644
index d3bfee4..0000000
--- a/src/WallpaperEngine/Core/Scenes/CProjection.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Scenes {
-using json = nlohmann::json;
-
-class CProjection {
-  public:
-    static const CProjection* fromJSON (const json::const_iterator& data);
-
-    [[nodiscard]] const int& getWidth () const;
-    [[nodiscard]] const int& getHeight () const;
-    [[nodiscard]] bool isAuto () const;
-
-    // TODO: CHANGE THIS SO THE RENDER IS THE ONE RESPONSIBLE FOR THIS?
-    void setWidth (int width) const;
-    void setHeight (int height) const;
-
-  protected:
-    CProjection (int width, int height);
-    explicit CProjection (bool isAuto);
-
-  private:
-    mutable int m_width;
-    mutable int m_height;
-    const bool m_isAuto;
-};
-} // namespace WallpaperEngine::Core::Scenes
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
index d2d8611..ba6601f 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
@@ -3,7 +3,6 @@
 #include <utility>
 #include "WallpaperEngine/Core/Core.h"
 
-#include "WallpaperEngine/Core/CProject.h"
 #include "WallpaperEngine/Core/Projects/CProperty.h"
 #include "WallpaperEngine/Core/Projects/CPropertyBoolean.h"
 #include "WallpaperEngine/Core/Projects/CPropertyCombo.h"
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
index ebfd4a0..8b6930e 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "CUserSettingValue.h"
-#include "WallpaperEngine/Core/CProject.h"
 
 namespace WallpaperEngine::Core::Projects {
 class CProperty;
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
index 36d58e9..7e99230 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
@@ -3,7 +3,6 @@
 #include <utility>
 #include "WallpaperEngine/Core/Core.h"
 
-#include "WallpaperEngine/Core/CProject.h"
 #include "WallpaperEngine/Core/Projects/CProperty.h"
 #include "WallpaperEngine/Core/Projects/CPropertySlider.h"
 #include "WallpaperEngine/Logging/CLog.h"
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
index 72c13ad..eea2fa1 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "CUserSettingValue.h"
-#include "WallpaperEngine/Core/CProject.h"
 
 namespace WallpaperEngine::Core::Projects {
 class CProperty;
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
index c9609bc..992c461 100644
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
+++ b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
@@ -3,7 +3,6 @@
 #include <glm/vec3.hpp>
 
 #include "CUserSettingValue.h"
-#include "WallpaperEngine/Core/CProject.h"
 
 namespace WallpaperEngine::Core::Projects {
 class CProperty;
diff --git a/src/WallpaperEngine/Core/Wallpapers/CScene.cpp b/src/WallpaperEngine/Core/Wallpapers/CScene.cpp
deleted file mode 100644
index 9e53446..0000000
--- a/src/WallpaperEngine/Core/Wallpapers/CScene.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-#include "CScene.h"
-
-#include <utility>
-#include "WallpaperEngine/Core/CProject.h"
-
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Wallpapers;
-
-CScene::CScene (
-    std::shared_ptr <const CProject> project, std::shared_ptr<const CContainer> container, const Scenes::CCamera* camera,
-    glm::vec3 ambientColor, const CUserSettingBoolean* bloom, const CUserSettingFloat* bloomStrength,
-    const CUserSettingFloat* bloomThreshold, bool cameraFade, bool cameraParallax, float cameraParallaxAmount,
-    float cameraParallaxDelay, float cameraParallaxMouseInfluence, bool cameraPreview, bool cameraShake,
-    float cameraShakeAmplitude, float cameraShakeRoughness, float cameraShakeSpeed,
-    const CUserSettingVector3* clearColor, const Scenes::CProjection* orthogonalProjection, glm::vec3 skylightColor
-) :
-    CWallpaper (project),
-    m_container (std::move(container)),
-    m_camera (camera),
-    m_ambientColor (ambientColor),
-    m_bloom (bloom),
-    m_bloomStrength (bloomStrength),
-    m_bloomThreshold (bloomThreshold),
-    m_cameraFade (cameraFade),
-    m_cameraParallax (cameraParallax),
-    m_cameraParallaxAmount (cameraParallaxAmount),
-    m_cameraParallaxDelay (cameraParallaxDelay),
-    m_cameraParallaxMouseInfluence (cameraParallaxMouseInfluence),
-    m_cameraPreview (cameraPreview),
-    m_cameraShake (cameraShake),
-    m_cameraShakeAmplitude (cameraShakeAmplitude),
-    m_cameraShakeRoughness (cameraShakeRoughness),
-    m_cameraShakeSpeed (cameraShakeSpeed),
-    m_clearColor (clearColor),
-    m_orthogonalProjection (orthogonalProjection),
-    m_skylightColor (skylightColor) {}
-
-std::shared_ptr <const CScene> CScene::fromFile (
-    const std::string& filename, std::shared_ptr <const Core::CProject> project,
-    const std::shared_ptr<const CContainer>& container
-) {
-    json content = json::parse (container->readFileAsString (filename));
-
-    const auto general_it = jsonFindRequired (content, "general", "Scenes must have a general section");
-    const auto objects_it = jsonFindRequired (content, "objects", "Scenes must have a list of objects to display");
-
-    // TODO: FIND IF THESE DEFAULTS ARE SENSIBLE OR NOT AND PERFORM PROPER VALIDATION WHEN CAMERA PREVIEW AND CAMERA
-    // PARALLAX ARE PRESENT
-
-    auto scene = std::make_shared <CScene> (
-        project, container,
-        Scenes::CCamera::fromJSON (jsonFindRequired (content, "camera", "Scenes must have a defined camera")),
-        jsonFindDefault<glm::vec3> (*general_it, "ambientcolor", glm::vec3 (0, 0, 0)),
-        jsonFindUserConfig<CUserSettingBoolean> (*general_it, *project, "bloom", false),
-        jsonFindUserConfig<CUserSettingFloat> (*general_it, *project, "bloomstrength", 0.0),
-        jsonFindUserConfig<CUserSettingFloat> (*general_it, *project, "bloomthreshold", 0.0),
-        jsonFindDefault<bool> (*general_it, "camerafade", false),
-        jsonFindDefault<bool> (*general_it, "cameraparallax", true),
-        jsonFindDefault<float> (*general_it, "cameraparallaxamount", 1.0f),
-        jsonFindDefault<float> (*general_it, "cameraparallaxdelay", 0.0f),
-        jsonFindDefault<float> (*general_it, "cameraparallaxmouseinfluence", 1.0f),
-        jsonFindDefault<bool> (*general_it, "camerapreview", false),
-        jsonFindDefault<bool> (*general_it, "camerashake", false),
-        jsonFindDefault<float> (*general_it, "camerashakeamplitude", 0.0f),
-        jsonFindDefault<float> (*general_it, "camerashakeroughness", 0.0f),
-        jsonFindDefault<float> (*general_it, "camerashakespeed", 0.0f),
-        jsonFindUserConfig<CUserSettingVector3> (*general_it, *project, "clearcolor", {1, 1, 1}),
-        Scenes::CProjection::fromJSON (jsonFindRequired (*general_it, "orthogonalprojection", "General section must have orthogonal projection info")),
-        jsonFindDefault<glm::vec3> (*general_it, "skylightcolor", glm::vec3 (0, 0, 0))
-    );
-
-    for (const auto& cur : *objects_it)
-        scene->insertObject (CObject::fromJSON (cur, project, container));
-
-    return scene;
-}
-
-const std::map<uint32_t, const CObject*>& CScene::getObjects () const {
-    return this->m_objects;
-}
-
-const std::vector<const CObject*>& CScene::getObjectsByRenderOrder () const {
-    return this->m_objectsByRenderOrder;
-}
-
-void CScene::insertObject (const CObject* object) {
-    /// TODO: XXXHACK -- TO REMOVE WHEN PARTICLE SUPPORT IS PROPERLY IMPLEMENTED
-    if (object != nullptr) {
-        this->m_objects.emplace (object->getId (), object);
-        this->m_objectsByRenderOrder.emplace_back (object);
-    }
-}
-
-std::shared_ptr<const CContainer> CScene::getContainer () const {
-    return this->m_container;
-}
-
-const Scenes::CCamera* CScene::getCamera () const {
-    return this->m_camera;
-}
-
-const glm::vec3& CScene::getAmbientColor () const {
-    return this->m_ambientColor;
-}
-
-bool CScene::isBloom () const {
-    return this->m_bloom->getBool ();
-}
-
-float CScene::getBloomStrength () const {
-    return this->m_bloomStrength->getFloat ();
-}
-
-float CScene::getBloomThreshold () const {
-    return this->m_bloomThreshold->getFloat ();
-}
-
-bool CScene::isCameraFade () const {
-    return this->m_cameraFade;
-}
-
-bool CScene::isCameraParallax () const {
-    return this->m_cameraParallax;
-}
-
-float CScene::getCameraParallaxAmount () const {
-    return this->m_cameraParallaxAmount;
-}
-
-float CScene::getCameraParallaxDelay () const {
-    return this->m_cameraParallaxDelay;
-}
-
-float CScene::getCameraParallaxMouseInfluence () const {
-    return this->m_cameraParallaxMouseInfluence;
-}
-
-bool CScene::isCameraPreview () const {
-    return this->m_cameraPreview;
-}
-
-bool CScene::isCameraShake () const {
-    return this->m_cameraShake;
-}
-
-float CScene::getCameraShakeAmplitude () const {
-    return this->m_cameraShakeAmplitude;
-}
-
-float CScene::getCameraShakeRoughness () const {
-    return this->m_cameraShakeRoughness;
-}
-
-float CScene::getCameraShakeSpeed () const {
-    return this->m_cameraShakeSpeed;
-}
-
-const glm::vec3& CScene::getClearColor () const {
-    return this->m_clearColor->getVec3 ();
-}
-
-const Scenes::CProjection* CScene::getOrthogonalProjection () const {
-    return this->m_orthogonalProjection;
-}
-
-const glm::vec3& CScene::getSkylightColor () const {
-    return this->m_skylightColor;
-}
diff --git a/src/WallpaperEngine/Core/Wallpapers/CScene.h b/src/WallpaperEngine/Core/Wallpapers/CScene.h
deleted file mode 100644
index dfdff47..0000000
--- a/src/WallpaperEngine/Core/Wallpapers/CScene.h
+++ /dev/null
@@ -1,88 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/CObject.h"
-#include "WallpaperEngine/Core/CWallpaper.h"
-
-#include "WallpaperEngine/Core/Core.h"
-
-#include "WallpaperEngine/Core/Scenes/CCamera.h"
-#include "WallpaperEngine/Core/Scenes/CProjection.h"
-
-namespace WallpaperEngine::Core {
-class CObject;
-}
-
-namespace WallpaperEngine::Core::Wallpapers {
-using json = nlohmann::json;
-
-class CScene : public CWallpaper {
-  public:
-    CScene (
-        std::shared_ptr <const Core::CProject> project, std::shared_ptr<const CContainer> container,
-        const Scenes::CCamera* camera, glm::vec3 ambientColor, const CUserSettingBoolean* bloom,
-        const CUserSettingFloat* bloomStrength, const CUserSettingFloat* bloomThreshold, bool cameraFade,
-        bool cameraParallax, float cameraParallaxAmount, float cameraParallaxDelay, float cameraParallaxMouseInfluence,
-        bool cameraPreview, bool cameraShake, float cameraShakeAmplitude, float cameraShakeRoughness,
-        float cameraShakeSpeed, const CUserSettingVector3* clearColor, const Scenes::CProjection* orthogonalProjection,
-        glm::vec3 skylightColor);
-
-    static std::shared_ptr <const CScene> fromFile (
-        const std::string& filename, std::shared_ptr <const Core::CProject> project,
-        const std::shared_ptr<const CContainer>& container);
-    [[nodiscard]] const std::map<uint32_t, const CObject*>& getObjects () const;
-
-    [[nodiscard]] const std::vector<const CObject*>& getObjectsByRenderOrder () const;
-    [[nodiscard]] const glm::vec3& getAmbientColor () const;
-    [[nodiscard]] bool isBloom () const;
-    [[nodiscard]] float getBloomStrength () const;
-    [[nodiscard]] float getBloomThreshold () const;
-    [[nodiscard]] bool isCameraFade () const;
-    [[nodiscard]] bool isCameraParallax () const;
-    [[nodiscard]] float getCameraParallaxAmount () const;
-    [[nodiscard]] float getCameraParallaxDelay () const;
-    [[nodiscard]] float getCameraParallaxMouseInfluence () const;
-    [[nodiscard]] bool isCameraPreview () const;
-    [[nodiscard]] bool isCameraShake () const;
-    [[nodiscard]] float getCameraShakeAmplitude () const;
-    [[nodiscard]] float getCameraShakeRoughness () const;
-    [[nodiscard]] float getCameraShakeSpeed () const;
-    [[nodiscard]] const glm::vec3& getClearColor () const;
-    [[nodiscard]] const Scenes::CProjection* getOrthogonalProjection () const;
-    [[nodiscard]] const glm::vec3& getSkylightColor () const;
-
-    [[nodiscard]] const Scenes::CCamera* getCamera () const;
-
-  protected:
-    friend class CWallpaper;
-
-    void insertObject (const CObject* object);
-
-    [[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
-
-  private:
-    const std::shared_ptr<const CContainer> m_container;
-    const Scenes::CCamera* m_camera;
-
-    // data from general section on the json
-    const glm::vec3 m_ambientColor;
-    const CUserSettingBoolean* m_bloom;
-    const CUserSettingFloat* m_bloomStrength;
-    const CUserSettingFloat* m_bloomThreshold;
-    const bool m_cameraFade;
-    const bool m_cameraParallax;
-    const float m_cameraParallaxAmount;
-    const float m_cameraParallaxDelay;
-    const float m_cameraParallaxMouseInfluence;
-    const bool m_cameraPreview;
-    const bool m_cameraShake;
-    const float m_cameraShakeAmplitude;
-    const float m_cameraShakeRoughness;
-    const float m_cameraShakeSpeed;
-    const CUserSettingVector3* m_clearColor;
-    const Scenes::CProjection* m_orthogonalProjection;
-    const glm::vec3 m_skylightColor;
-
-    std::map<uint32_t, const CObject*> m_objects = {};
-    std::vector<const CObject*> m_objectsByRenderOrder = {};
-};
-} // namespace WallpaperEngine::Core
diff --git a/src/WallpaperEngine/Core/Wallpapers/CVideo.cpp b/src/WallpaperEngine/Core/Wallpapers/CVideo.cpp
deleted file mode 100644
index 31f7865..0000000
--- a/src/WallpaperEngine/Core/Wallpapers/CVideo.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "CVideo.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Wallpapers;
-
-CVideo::CVideo (std::string filename, std::shared_ptr <const CProject> project) :
-    CWallpaper (project),
-    m_filename (std::move(filename)) {}
-
-const std::string& CVideo::getFilename () const {
-    return this->m_filename;
-}
diff --git a/src/WallpaperEngine/Core/Wallpapers/CVideo.h b/src/WallpaperEngine/Core/Wallpapers/CVideo.h
deleted file mode 100644
index 1391f04..0000000
--- a/src/WallpaperEngine/Core/Wallpapers/CVideo.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/CWallpaper.h"
-#include "WallpaperEngine/Core/Core.h"
-
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/imgutils.h>
-#include <libswscale/swscale.h>
-}
-
-namespace WallpaperEngine::Core::Wallpapers {
-class CVideo : public CWallpaper {
-  public:
-    CVideo (std::string filename, std::shared_ptr <const CProject> project);
-
-    const std::string& getFilename () const;
-
-  protected:
-    friend class CWallpaper;
-
-    const std::string m_filename;
-};
-} // namespace WallpaperEngine::Core
diff --git a/src/WallpaperEngine/Core/Wallpapers/CWeb.cpp b/src/WallpaperEngine/Core/Wallpapers/CWeb.cpp
deleted file mode 100644
index 755a86f..0000000
--- a/src/WallpaperEngine/Core/Wallpapers/CWeb.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "CWeb.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Wallpapers;
-
-const std::string& CWeb::getFilename () const {
-    return this->m_filename;
-}
-
-CWeb::CWeb (std::string filename, std::shared_ptr <const CProject> project) :
-    CWallpaper (project),
-    m_filename (std::move(filename)) {}
diff --git a/src/WallpaperEngine/Core/Wallpapers/CWeb.h b/src/WallpaperEngine/Core/Wallpapers/CWeb.h
deleted file mode 100644
index 3272a15..0000000
--- a/src/WallpaperEngine/Core/Wallpapers/CWeb.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/CWallpaper.h"
-#include "WallpaperEngine/Core/Core.h"
-
-// Chromium Embedded Framework
-#include "include/cef_render_handler.h"
-#include "include/cef_client.h"
-#include "include/cef_app.h"
-
-extern "C"
-{
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavutil/imgutils.h>
-#include <libswscale/swscale.h>
-}
-
-namespace WallpaperEngine::Core::Wallpapers {
-class CWeb : public CWallpaper {
-  public:
-    CWeb (std::string filename, std::shared_ptr <const CProject> project);
-
-    const std::string& getFilename () const;
-
-  protected:
-    friend class CWallpaper;
-
-    const std::string m_filename;
-};
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
index 1c72c1d..3e544a0 100644
--- a/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
+++ b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
@@ -39,7 +39,7 @@ void StringPrinter::printWallpaper (const Wallpaper& wallpaper) {
 
         for (const auto& object : scene->objects) {
             this->lineEnd ();
-            this->printObject (*object.second);
+            this->printObject (*object);
             this->lineEnd ();
         }
 
diff --git a/src/WallpaperEngine/Data/Model/Effect.h b/src/WallpaperEngine/Data/Model/Effect.h
index 95d5d36..54b76e8 100644
--- a/src/WallpaperEngine/Data/Model/Effect.h
+++ b/src/WallpaperEngine/Data/Model/Effect.h
@@ -29,7 +29,7 @@ struct EffectPass {
     /** The material to use for this effect's pass */
     MaterialUniquePtr material;
     /** Texture bindings for this effect's pass */
-    std::map <int, std::string> binds;
+    TextureMap binds;
     /** The command this material executes (if specified) */
     std::optional <PassCommand> command;
     /** The target this material renders to (if specified) */
diff --git a/src/WallpaperEngine/Data/Model/Material.h b/src/WallpaperEngine/Data/Model/Material.h
index 458dbf9..1b6f698 100644
--- a/src/WallpaperEngine/Data/Model/Material.h
+++ b/src/WallpaperEngine/Data/Model/Material.h
@@ -21,9 +21,9 @@ struct MaterialPass {
     /** Shader file to use for this pass */
     std::string shader;
     /** List of textures defined for this pass */
-    std::map <int, std::string> textures;
+    TextureMap textures;
     /** The combos and their values to pass onto the shader */
-    std::map <std::string, int> combos;
+    ComboMap combos;
 };
 
 struct Material {
diff --git a/src/WallpaperEngine/Data/Model/Object.h b/src/WallpaperEngine/Data/Model/Object.h
index dc7af0a..0dfdf8b 100644
--- a/src/WallpaperEngine/Data/Model/Object.h
+++ b/src/WallpaperEngine/Data/Model/Object.h
@@ -110,6 +110,7 @@ class Image : public Object, public ImageData {
 
 struct SoundData {
     /** Playback mode, loop, */
+    // TODO: WRITE AN ENUM FOR THIS
     std::optional <std::string> playbackmode;
     std::vector <std::string> sounds;
 };
diff --git a/src/WallpaperEngine/Data/Model/Project.h b/src/WallpaperEngine/Data/Model/Project.h
index 383ec2e..493904a 100644
--- a/src/WallpaperEngine/Data/Model/Project.h
+++ b/src/WallpaperEngine/Data/Model/Project.h
@@ -6,7 +6,6 @@
 #include "Types.h"
 
 namespace WallpaperEngine::Data::Model {
-using json = WallpaperEngine::Data::JSON::JSON;
 /**
  * Represents a wallpaper engine project
  */
@@ -31,8 +30,8 @@ struct Project {
     Properties properties;
 
     /** The wallpaper this project defines */
-    WallpaperSharedPtr wallpaper;
+    WallpaperUniquePtr wallpaper;
     /** VFS to access the project's files */
-    ContainerWeakPtr container;
+    ContainerUniquePtr container;
 };
 };
diff --git a/src/WallpaperEngine/Data/Model/Types.h b/src/WallpaperEngine/Data/Model/Types.h
index 1e4e860..20a7f43 100644
--- a/src/WallpaperEngine/Data/Model/Types.h
+++ b/src/WallpaperEngine/Data/Model/Types.h
@@ -58,15 +58,12 @@ using ShaderConstantUniquePtr = std::unique_ptr <ShaderConstant>;
 
 using ShaderConstantMap = std::map <std::string, ShaderConstantUniquePtr>;
 
-using ProjectSharedPtr = std::shared_ptr <Project>;
-using WallpaperSharedPtr = std::shared_ptr <Wallpaper>;
-using WallpaperWeakPtr = std::weak_ptr <Wallpaper>;
-using ProjectWeakPtr = std::weak_ptr <Project>;
-using ContainerSharedPtr = std::shared_ptr <Container>;
-using ContainerWeakPtr = std::weak_ptr <Container>;
-using SceneSharedPtr = std::shared_ptr <Scene>;
-using WebSharedPtr = std::shared_ptr <Web>;
-using VideoSharedPtr = std::shared_ptr <Video>;
+using ProjectUniquePtr = std::unique_ptr <Project>;
+using WallpaperUniquePtr = std::unique_ptr <Wallpaper>;
+using ContainerUniquePtr = std::unique_ptr <Container>;
+using SceneUniquePtr = std::unique_ptr <Scene>;
+using WebUniquePtr = std::unique_ptr <Web>;
+using VideoUniquePtr = std::unique_ptr <Video>;
 using ObjectUniquePtr = std::unique_ptr <Object>;
 using SoundUniquePtr = std::unique_ptr <Sound>;
 using ImageUniquePtr = std::unique_ptr <Image>;
@@ -80,7 +77,7 @@ using EffectPassUniquePtr = std::unique_ptr <EffectPass>;
 using FBOUniquePtr = std::unique_ptr <FBO>;
 using ModelUniquePtr = std::unique_ptr <ModelStruct>;
 
-using ObjectMap = std::map<int, ObjectUniquePtr>;
+using ObjectList = std::vector<ObjectUniquePtr>;
 using ComboMap = std::map<std::string, int>;
 using TextureMap = std::map<int, std::string>;
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Wallpaper.h b/src/WallpaperEngine/Data/Model/Wallpaper.h
index 0045080..0717e56 100644
--- a/src/WallpaperEngine/Data/Model/Wallpaper.h
+++ b/src/WallpaperEngine/Data/Model/Wallpaper.h
@@ -16,7 +16,7 @@ using TypeCaster = WallpaperEngine::Data::Utils::TypeCaster;
 
 struct WallpaperData {
     std::string filename;
-    ProjectWeakPtr project;
+    Project& project;
 };
 
 class Wallpaper : public TypeCaster, public WallpaperData {
@@ -49,7 +49,7 @@ struct SceneData {
     /**
      * Camera configuration
      */
-    struct {
+    struct Camera {
         /** Enable fade effect */
         bool fade;
         /** Used by the software to allow the users to preview the background or not? */
@@ -104,8 +104,8 @@ struct SceneData {
             bool isAuto;
         } projection;
     } camera;
-    ObjectMap objects;
-    ProjectWeakPtr project;
+
+    ObjectList objects;
 };
 
 class Scene : public Wallpaper, public SceneData {
diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
index 8169340..93ddda5 100644
--- a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
@@ -8,13 +8,13 @@
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Model;
 
-EffectUniquePtr EffectParser::load (const ProjectWeakPtr& project, const std::string& filename) {
-    const auto effectJson = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
+EffectUniquePtr EffectParser::load (Project& project, const std::string& filename) {
+    const auto effectJson = JSON::parse (project.container->readFileAsString (filename));
 
     return parse (effectJson, project);
 }
 
-EffectUniquePtr EffectParser::parse (const JSON& it, const ProjectWeakPtr& project) {
+EffectUniquePtr EffectParser::parse (const JSON& it, Project& project) {
     const auto dependencies = it.optional ("dependencies");
 
     return std::make_unique <Effect> (Effect {
@@ -41,7 +41,7 @@ std::vector <std::string> EffectParser::parseDependencies (const JSON& it) {
     return result;
 }
 
-std::vector <EffectPassUniquePtr> EffectParser::parseEffectPasses (const JSON& it, const ProjectWeakPtr& project) {
+std::vector <EffectPassUniquePtr> EffectParser::parseEffectPasses (const JSON& it, Project& project) {
     std::vector <EffectPassUniquePtr> result = {};
 
     if (!it.is_array ()) {
diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.h b/src/WallpaperEngine/Data/Parsers/EffectParser.h
index b0d0171..5897aca 100644
--- a/src/WallpaperEngine/Data/Parsers/EffectParser.h
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.h
@@ -9,12 +9,12 @@ using namespace WallpaperEngine::Data::Model;
 
 class EffectParser {
   public:
-    static EffectUniquePtr load (const ProjectWeakPtr& project, const std::string& filename);
+    static EffectUniquePtr load (Project& project, const std::string& filename);
 
   private:
-    static EffectUniquePtr parse (const JSON& it, const ProjectWeakPtr& project);
+    static EffectUniquePtr parse (const JSON& it, Project& project);
     static std::vector <std::string> parseDependencies (const JSON& it);
-    static std::vector <EffectPassUniquePtr> parseEffectPasses (const JSON& it, const ProjectWeakPtr& project);
+    static std::vector <EffectPassUniquePtr> parseEffectPasses (const JSON& it, Project& project);
     static std::map <int, std::string> parseBinds (const JSON& it);
 };
 } // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
index df4b71f..4804bdb 100644
--- a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
@@ -6,21 +6,20 @@
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Model;
 
-MaterialUniquePtr MaterialParser::load (const ProjectWeakPtr& project, const std::string& filename) {
-    const auto materialJson = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
+MaterialUniquePtr MaterialParser::load (Project& project, const std::string& filename) {
+    const auto materialJson = JSON::parse (project.container->readFileAsString (filename));
 
     return parse (materialJson, project, filename);
 }
 
-MaterialUniquePtr MaterialParser::parse (const JSON& it, const ProjectWeakPtr& project, const std::string& filename) {
+MaterialUniquePtr MaterialParser::parse (const JSON& it, Project& project, const std::string& filename) {
     return std::make_unique <Material> (Material {
         .filename = filename,
-        //TODO: PARSE PASSES
         .passes = parsePasses (it.require ("passes", "Material must have passes to render"), project),
     });
 }
 
-std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it, const ProjectWeakPtr& project) {
+std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it, Project& project) {
     std::vector <MaterialPassUniquePtr> result = {};
 
     if (!it.is_array ()) {
@@ -34,7 +33,7 @@ std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it,
     return result;
 }
 
-MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, const ProjectWeakPtr& project) {
+MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, Project& project) {
     const auto textures = it.optional ("textures");
     const auto combos = it.optional ("combos");
     const auto constants = it.optional ("constants");
diff --git a/src/WallpaperEngine/Data/Parsers/MaterialParser.h b/src/WallpaperEngine/Data/Parsers/MaterialParser.h
index 9d390a9..f145fa3 100644
--- a/src/WallpaperEngine/Data/Parsers/MaterialParser.h
+++ b/src/WallpaperEngine/Data/Parsers/MaterialParser.h
@@ -9,10 +9,10 @@ using namespace WallpaperEngine::Data::Model;
 
 class MaterialParser {
   public:
-    static MaterialUniquePtr load (const ProjectWeakPtr& project, const std::string& filename);
-    static MaterialUniquePtr parse (const JSON& it, const ProjectWeakPtr& project, const std::string& filename);
-    static std::vector <MaterialPassUniquePtr> parsePasses (const JSON& it, const ProjectWeakPtr& project);
-    static MaterialPassUniquePtr parsePass (const JSON& it, const ProjectWeakPtr& project);
+    static MaterialUniquePtr load (Project& project, const std::string& filename);
+    static MaterialUniquePtr parse (const JSON& it, Project& project, const std::string& filename);
+    static std::vector <MaterialPassUniquePtr> parsePasses (const JSON& it, Project& project);
+    static MaterialPassUniquePtr parsePass (const JSON& it, Project& project);
     static std::map <int, std::string> parseTextures (const JSON& it);
     static std::map <std::string, int> parseCombos (const JSON& it);
 };
diff --git a/src/WallpaperEngine/Data/Parsers/ModelParser.cpp b/src/WallpaperEngine/Data/Parsers/ModelParser.cpp
index f42b569..98d3d0b 100644
--- a/src/WallpaperEngine/Data/Parsers/ModelParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ModelParser.cpp
@@ -8,13 +8,13 @@
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Model;
 
-ModelUniquePtr ModelParser::load (const ProjectWeakPtr& project, const std::string& filename) {
-    const auto model = JSON::parse (project.lock ()->container.lock ()->readFileAsString (filename));
+ModelUniquePtr ModelParser::load (Project& project, const std::string& filename) {
+    const auto model = JSON::parse (project.container->readFileAsString (filename));
 
     return parse (model, project, filename);
 }
 
-ModelUniquePtr ModelParser::parse (const JSON& file, const ProjectWeakPtr& project, const std::string& filename) {
+ModelUniquePtr ModelParser::parse (const JSON& file, Project& project, const std::string& filename) {
     const auto material = file.require <std::string> ("material", "Model must have a material");
 
     return std::make_unique <ModelStruct> (ModelStruct {
diff --git a/src/WallpaperEngine/Data/Parsers/ModelParser.h b/src/WallpaperEngine/Data/Parsers/ModelParser.h
index b05eaa6..afceffe 100644
--- a/src/WallpaperEngine/Data/Parsers/ModelParser.h
+++ b/src/WallpaperEngine/Data/Parsers/ModelParser.h
@@ -9,7 +9,7 @@ using namespace WallpaperEngine::Data::Model;
 
 class ModelParser {
   public:
-    static ModelUniquePtr load (const ProjectWeakPtr& project, const std::string& filename);
-    static ModelUniquePtr parse (const JSON& file, const ProjectWeakPtr& project, const std::string& filename);
+    static ModelUniquePtr load (Project& project, const std::string& filename);
+    static ModelUniquePtr parse (const JSON& file, Project& project, const std::string& filename);
 };
 } // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
index 6619a2f..c1b7a7f 100644
--- a/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
@@ -10,7 +10,7 @@
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Model;
 
-ObjectUniquePtr ObjectParser::parse (const JSON& it, const ProjectWeakPtr& project) {
+ObjectUniquePtr ObjectParser::parse (const JSON& it, Project& project) {
     const auto imageIt = it.find ("image");
     const auto soundIt = it.find ("sound");
     const auto particleIt = it.find ("particle");
@@ -56,7 +56,7 @@ std::vector<int> ObjectParser::parseDependencies (const JSON& it) {
     return result;
 }
 
-SoundUniquePtr ObjectParser::parseSound (const JSON& it, const ProjectWeakPtr& project, ObjectData base) {
+SoundUniquePtr ObjectParser::parseSound (const JSON& it, Project& project, ObjectData base) {
     const auto soundIt = it.require ("sound", "Object must have a sound");
     std::vector<std::string> sounds = {};
 
@@ -74,8 +74,8 @@ SoundUniquePtr ObjectParser::parseSound (const JSON& it, const ProjectWeakPtr& p
 }
 
 ImageUniquePtr ObjectParser::parseImage (
-    const JSON& it, const ProjectWeakPtr& project, ObjectData base, const std::string& image) {
-    const auto& properties = project.lock ()->properties;
+    const JSON& it, Project& project, ObjectData base, const std::string& image) {
+    const auto& properties = project.properties;
     const auto& effects = it.optional ("effects");
 
     return std::make_unique <Image> (
@@ -98,7 +98,7 @@ ImageUniquePtr ObjectParser::parseImage (
     );
 }
 
-std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, const ProjectWeakPtr& project) {
+std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, Project& project) {
     if (!it.is_array ()) {
         return {};
     }
@@ -112,18 +112,18 @@ std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, c
     return result;
 }
 
-ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, const ProjectWeakPtr& project) {
+ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, Project& project) {
     const auto& passsOverrides = it.optional ("passes");
     return std::make_unique <ImageEffect> (ImageEffect {
         .id = it.require <int> ("id", "Image effect must have an id"),
         .name = it.require <std::string> ("name", "Image effect must have a name"),
-        .visible = it.user ("visible", project.lock ()->properties, true),
+        .visible = it.user ("visible", project.properties, true),
         .passOverrides = passsOverrides.has_value () ? parseEffectPassOverrides (passsOverrides.value (), project) : std::vector <ImageEffectPassOverrideUniquePtr> {},
         .effect = EffectParser::load (project, it.require ("file", "Image effect must have an effect"))
     });
 }
 
-std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOverrides (const JSON& it, const ProjectWeakPtr& project) {
+std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOverrides (const JSON& it, Project& project) {
     if (!it.is_array ()) {
         return {};
     }
@@ -137,14 +137,14 @@ std::vector <ImageEffectPassOverrideUniquePtr> ObjectParser::parseEffectPassOver
     return result;
 }
 
-ImageEffectPassOverrideUniquePtr ObjectParser::parseEffectPass (const JSON& it, const ProjectWeakPtr& project) {
+ImageEffectPassOverrideUniquePtr ObjectParser::parseEffectPass (const JSON& it, Project& project) {
     const auto& combos = it.optional ("combos");
     const auto& textures = it.optional ("textures");
     const auto& constants = it.optional ("constantshadervalues");
 
     // TODO: PARSE CONSTANT SHADER VALUES AND FIND REFS?
     return std::make_unique <ImageEffectPassOverride> (ImageEffectPassOverride {
-        .id = it.require <int> ("id", "Image effect pass must have an id"),
+        .id = it.optional <int> ("id", -1),
         .combos = combos.has_value () ? parseComboMap (combos.value ()) : ComboMap {},
         .constants = constants.has_value () ? ShaderConstantParser::parse (constants.value (), project) : ShaderConstantMap {},
         .textures = textures.has_value () ? parseTextureMap (textures.value ()) : TextureMap {},
diff --git a/src/WallpaperEngine/Data/Parsers/ObjectParser.h b/src/WallpaperEngine/Data/Parsers/ObjectParser.h
index f4967e8..f7d8531 100644
--- a/src/WallpaperEngine/Data/Parsers/ObjectParser.h
+++ b/src/WallpaperEngine/Data/Parsers/ObjectParser.h
@@ -15,17 +15,17 @@ using namespace WallpaperEngine::Data::Model;
 
 class ObjectParser {
   public:
-    static ObjectUniquePtr parse (const JSON& it, const ProjectWeakPtr& project);
+    static ObjectUniquePtr parse (const JSON& it, Project& project);
 
   private:
     static std::vector<int> parseDependencies (const JSON& it);
-    static SoundUniquePtr parseSound (const JSON& it, const ProjectWeakPtr& project, ObjectData base);
+    static SoundUniquePtr parseSound (const JSON& it, Project& project, ObjectData base);
     static ImageUniquePtr parseImage (
-        const JSON& it, const ProjectWeakPtr& project, ObjectData base, const std::string& image);
-    static std::vector <ImageEffectUniquePtr> parseEffects (const JSON& it, const ProjectWeakPtr& project);
-    static ImageEffectUniquePtr parseEffect (const JSON& it, const ProjectWeakPtr& project);
-    static std::vector <ImageEffectPassOverrideUniquePtr> parseEffectPassOverrides (const JSON& it, const ProjectWeakPtr& project);
-    static ImageEffectPassOverrideUniquePtr parseEffectPass (const JSON& it, const ProjectWeakPtr& project);
+        const JSON& it, Project& project, ObjectData base, const std::string& image);
+    static std::vector <ImageEffectUniquePtr> parseEffects (const JSON& it, Project& project);
+    static ImageEffectUniquePtr parseEffect (const JSON& it, Project& project);
+    static std::vector <ImageEffectPassOverrideUniquePtr> parseEffectPassOverrides (const JSON& it, Project& project);
+    static ImageEffectPassOverrideUniquePtr parseEffectPass (const JSON& it, Project& project);
     static TextureMap parseTextureMap (const JSON& it);
     static ComboMap parseComboMap (const JSON& it);
 };
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
index df0a1d3..cc74d4a 100644
--- a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
@@ -5,27 +5,29 @@
 
 #include "WallpaperParser.h"
 
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+
 using namespace WallpaperEngine::Data::Parsers;
 
 static int backgroundId = 0;
 
-ProjectSharedPtr ProjectParser::parse (const JSON& data, const ContainerWeakPtr& container) {
+ProjectUniquePtr ProjectParser::parse (const JSON& data, ContainerUniquePtr container) {
     const auto general = data.optional ("general");
     auto type = data.require <std::string> ("type", "Project type missing");
 
     // lowercase for consistency
     std::transform (type.begin (), type.end (), type.begin (), tolower);
 
-    auto result = std::make_shared <Project> (Project {
+    auto result = std::make_unique <Project> (Project {
         .title = data.require <std::string> ("title", "Project title missing"),
         .type = parseType (type),
         .workshopId = data.optional ("workshopid", std::to_string (--backgroundId)),
         .supportsAudioProcessing = general.has_value () && general.value ().optional ("supportsAudioProcessing", false),
         .properties = parseProperties (general),
-        .container = container,
+        .container = std::move(container),
     });
 
-    result->wallpaper = WallpaperParser::parse (data.require ("file", "Project's main file missing"), result);
+    result->wallpaper = WallpaperParser::parse (data.require ("file", "Project's main file missing"), *result);
 
     return result;
 }
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.h b/src/WallpaperEngine/Data/Parsers/ProjectParser.h
index 9a6ed61..bb6508a 100644
--- a/src/WallpaperEngine/Data/Parsers/ProjectParser.h
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.h
@@ -15,7 +15,7 @@ using namespace WallpaperEngine::Data::Model;
  */
 class ProjectParser {
   public:
-    static ProjectSharedPtr parse (const JSON& data, const ContainerWeakPtr& container);
+    static ProjectUniquePtr parse (const JSON& data, ContainerUniquePtr container);
 
   private:
     static Project::Type parseType (const std::string& type);
diff --git a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
index 3d84120..5e2c01b 100644
--- a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
@@ -5,7 +5,7 @@
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Model;
 
-ShaderConstantMap ShaderConstantParser::parse (const JSON& it, const ProjectWeakPtr& project) {
+ShaderConstantMap ShaderConstantParser::parse (const JSON& it, Project& project) {
     if (!it.is_object ()) {
         return {};
     }
@@ -19,7 +19,7 @@ ShaderConstantMap ShaderConstantParser::parse (const JSON& it, const ProjectWeak
     return result;
 }
 
-ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, const ProjectWeakPtr& project) {
+ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, Project& project) {
     ShaderConstant* constant = nullptr;
     auto valueIt = it;
 
@@ -33,7 +33,7 @@ ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, con
         }
 
         if (user != it.end () && user->is_string ()) {
-            const auto& properties = project.lock ()->properties;
+            const auto& properties = project.properties;
             const auto& propertyIt = properties.find (*user);
 
             if (propertyIt != properties.end ()) {
diff --git a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
index 8d5cde0..2911131 100644
--- a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
+++ b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
@@ -9,7 +9,7 @@ using namespace WallpaperEngine::Data::Model;
 
 class ShaderConstantParser {
   public:
-    static ShaderConstantMap parse (const JSON& it, const ProjectWeakPtr& project);
-    static ShaderConstantUniquePtr parseConstant (const JSON& it, const ProjectWeakPtr& project);
+    static ShaderConstantMap parse (const JSON& it, Project& project);
+    static ShaderConstantUniquePtr parseConstant (const JSON& it, Project& project);
 };
 } // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp b/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
index c162a4d..e65b3aa 100644
--- a/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
@@ -7,31 +7,31 @@
 
 using namespace WallpaperEngine::Data::Parsers;
 
-WallpaperSharedPtr WallpaperParser::parse (const JSON& file, const ProjectWeakPtr& project) {
-    switch (project.lock ()->type) {
+WallpaperUniquePtr WallpaperParser::parse (const JSON& file, Project& project) {
+    switch (project.type) {
         case Project::Type_Scene:
-            return std::dynamic_pointer_cast <Wallpaper> (parseScene (file, project));
+            return parseScene (file, project);
         case Project::Type_Video:
-            return std::dynamic_pointer_cast <Wallpaper> (parseVideo (file, project));
+            return parseVideo (file, project);
         case Project::Type_Web:
-            return std::dynamic_pointer_cast <Wallpaper> (parseWeb (file, project));
+            return parseWeb (file, project);
         default:
             sLog.exception ("Unexpected project type value found... This is likely a bug");
     }
 }
 
-SceneSharedPtr WallpaperParser::parseScene (const JSON& file, const ProjectWeakPtr& project) {
-    const auto scene = JSON::parse (project.lock ()->container.lock ()->readFileAsString (file));
+SceneUniquePtr WallpaperParser::parseScene (const JSON& file, Project& project) {
+    const auto scene = JSON::parse (project.container->readFileAsString (file));
     const auto camera = scene.require ("camera", "Scenes must have a camera section");
     const auto general = scene.require ("general", "Scenes must have a general section");
     const auto projection = general.require ("orthogonalprojection", "General section must have orthogonal projection info");
     const auto objects = scene.require ("objects", "Scenes must have an objects section");
-    const auto& properties = project.lock ()->properties;
+    const auto& properties = project.properties;
 
     // TODO: FIND IF THESE DEFAULTS ARE SENSIBLE OR NOT AND PERFORM PROPER VALIDATION WHEN CAMERA PREVIEW AND CAMERA
     // PARALLAX ARE PRESENT
 
-    return std::make_shared <Scene> (
+    return std::make_unique <Scene> (
         WallpaperData {
             .filename = "",
             .project = project
@@ -72,34 +72,34 @@ SceneSharedPtr WallpaperParser::parseScene (const JSON& file, const ProjectWeakP
                     .isAuto = projection.optional ("auto", false)
                 }
             },
-            .objects = parseObjects (objects, project)
+            .objects = parseObjects (objects, project),
         }
     );
 }
 
-VideoSharedPtr WallpaperParser::parseVideo (const JSON& file, const ProjectWeakPtr& project) {
+VideoUniquePtr WallpaperParser::parseVideo (const JSON& file, Project& project) {
     return std::make_unique <Video> (WallpaperData {
         .filename = file,
         .project = project
     });
 }
 
-WebSharedPtr  WallpaperParser::parseWeb (const JSON& file, const ProjectWeakPtr& project) {
+WebUniquePtr  WallpaperParser::parseWeb (const JSON& file, Project& project) {
     return std::make_unique <Web> (WallpaperData {
         .filename = file,
         .project = project,
     });
 }
 
-ObjectMap WallpaperParser::parseObjects (const JSON& objects, const ProjectWeakPtr& project) {
-    ObjectMap result = {};
+ObjectList WallpaperParser::parseObjects (const JSON& objects, Project& project) {
+    ObjectList result = {};
 
     for (const auto& cur : objects) {
         auto object = ObjectParser::parse (cur, project);
 
         //TODO: DO WE REALLY WANT TO DIRECTLY CONSTRUCT UNIQUE AND SHARED PTRS EVERYWHERE?
         // SHOULDN'T THAT BE HANDLED BY CALLING CODE (LIKE THIS) INSTEAD?
-        result.emplace (object->id, std::move (object));
+        result.emplace_back (std::move (object));
     }
 
     return result;
diff --git a/src/WallpaperEngine/Data/Parsers/WallpaperParser.h b/src/WallpaperEngine/Data/Parsers/WallpaperParser.h
index 783cca2..a4453f9 100644
--- a/src/WallpaperEngine/Data/Parsers/WallpaperParser.h
+++ b/src/WallpaperEngine/Data/Parsers/WallpaperParser.h
@@ -9,12 +9,12 @@ using namespace WallpaperEngine::Data::Model;
 
 class WallpaperParser {
   public:
-    static WallpaperSharedPtr parse (const JSON& file, const ProjectWeakPtr& project);
+    static WallpaperUniquePtr parse (const JSON& file, Project& project);
 
   private:
-    static SceneSharedPtr parseScene (const JSON& file, const ProjectWeakPtr& project);
-    static VideoSharedPtr parseVideo (const JSON& file, const ProjectWeakPtr& project);
-    static WebSharedPtr parseWeb (const JSON& file, const ProjectWeakPtr& project);
-    static ObjectMap parseObjects (const JSON& objects, const ProjectWeakPtr& project);
+    static SceneUniquePtr parseScene (const JSON& file, Project& project);
+    static VideoUniquePtr parseVideo (const JSON& file, Project& project);
+    static WebUniquePtr parseWeb (const JSON& file, Project& project);
+    static ObjectList parseObjects (const JSON& objects, Project& project);
 };
 } // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.cpp b/src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.cpp
deleted file mode 100644
index a54dd15..0000000
--- a/src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.cpp
+++ /dev/null
@@ -1,403 +0,0 @@
-#include "CPrettyPrinter.h"
-
-#include "WallpaperEngine/Render/Wallpapers/CVideo.h"
-#include "WallpaperEngine/Render/Wallpapers/CWeb.h"
-#include "WallpaperEngine/Render/Objects/CEffect.h"
-
-using namespace WallpaperEngine::Render;
-using namespace WallpaperEngine::PrettyPrinter;
-using namespace WallpaperEngine::Render::Objects;
-
-CPrettyPrinter::CPrettyPrinter () :
-    m_out (&this->m_buffer) {}
-
-void CPrettyPrinter::printWallpaper (const CWallpaper& wallpaper) {
-    bool isScene = wallpaper.is <Wallpapers::CScene> ();
-    bool isVideo = wallpaper.is <Wallpapers::CVideo> ();
-    bool isWeb = wallpaper.is <Wallpapers::CWeb> ();
-
-    if (isScene) {
-        const auto scene = wallpaper.as <Wallpapers::CScene> ();
-
-        this->m_out << "Scene wallpaper: ";
-        this->increaseIndentation ();
-
-        const auto fbos = scene->getFBOs ();
-
-        this->m_out << "FBOs count: " << fbos.size ();
-
-        if (!fbos.empty()) {
-            this->increaseIndentation ();
-
-            for (const auto& fbo : fbos) {
-                this->printFBO (*fbo.second);
-            }
-
-            this->decreaseIndentation ();
-        } else {
-            this->lineEnd ();
-        }
-
-        const auto objects = scene->getObjectsByRenderOrder ();
-
-        if (!objects.empty()) {
-            this->m_out << "Objects count: " << objects.size ();
-            this->increaseIndentation ();
-
-            for (const auto object : objects) {
-                if (object->is <CImage> ()) {
-                    this->printImage (*object->as <CImage> ());
-                }
-            }
-
-            this->decreaseIndentation ();
-        }
-
-        this->decreaseIndentation ();
-    } else if (isVideo) {
-        const auto video = wallpaper.as <Wallpapers::CVideo> ();
-
-        this->m_out << "Video wallpaper: " << video->getVideo ()->getFilename ();
-        this->lineEnd ();
-    } else if (isWeb) {
-        const auto web = wallpaper.as <Wallpapers::CWeb> ();
-
-        this->m_out << "Web wallpaper";
-        this->lineEnd ();
-    }
-}
-
-void CPrettyPrinter::printImage (const CImage& image) {
-    auto base = image.getImage ();
-
-    this->m_out << "Image " << image.getId () << " " << base->getName () << ":";
-    this->increaseIndentation ();
-
-    const auto material = image.getMaterial ();
-
-    if (material != nullptr) {
-        this->printMaterial (*image.getMaterial ());
-    }
-
-    int effects = 0;
-
-    for (const auto effect : image.getEffects ()) {
-        this->printEffect (*effect, ++effects);
-    }
-
-    this->decreaseIndentation ();
-}
-
-void CPrettyPrinter::printEffect (const CEffect& effect, int effectId) {
-    if (effectId != 0) {
-        this->m_out << "Effect " << effectId << ":";
-    } else {
-        this->m_out << "Effect:";
-    }
-
-    this->increaseIndentation ();
-    this->m_out << "Visibility status: " << effect.isVisible ();
-    this->lineEnd ();
-
-    const auto& fbos = effect.getFBOs();
-
-    this->m_out << "FBOs count: " << fbos.size();
-
-    if (!fbos.empty()) {
-        this->increaseIndentation ();
-
-        for (const auto& [name, fbo] : fbos) {
-            this->printFBO (*fbo);
-        }
-
-        this->decreaseIndentation ();
-    } else {
-        this->lineEnd ();
-    }
-
-    const auto& materials = effect.getMaterials ();
-
-    for (const auto material : materials) {
-        this->printMaterial (*material);
-    }
-
-    this->decreaseIndentation ();
-}
-
-void CPrettyPrinter::printFBO (const CFBO& fbo) {
-    this->m_out << "FBO " << fbo.getName () << ":";
-    this->increaseIndentation ();
-
-    this->m_out << "Scale: " << fbo.getScale ();
-    this->lineEnd ();
-    this->printTextureInfo (fbo);
-
-    this->decreaseIndentation ();
-}
-
-void CPrettyPrinter::printMaterial (const CMaterial& material) {
-    const auto base = material.getMaterial ();
-
-    this->m_out << "Material " << base->getName () << ":";
-    this->increaseIndentation ();
-
-    if (base->hasTarget ()) {
-        this->m_out << "Target: " << base->getTarget ();
-        this->lineEnd ();
-    }
-
-    const auto& passes = material.getPasses ();
-
-    this->m_out << "Passes count: " << passes.size ();
-
-    if (!passes.empty()) {
-        this->increaseIndentation ();
-
-        int passId = 0;
-        for (const auto pass : passes) {
-            this->printPass (*pass, ++passId);
-        }
-        this->decreaseIndentation ();
-    } else {
-        this->lineEnd ();
-    }
-
-    const auto textureBinds = base->getTextureBinds ();
-
-    if (!textureBinds.empty()) {
-        this->m_out << "Texture binds count: " << textureBinds.size ();
-        this->increaseIndentation ();
-
-        for (const auto bind : textureBinds) {
-            this->m_out << "Bind " << bind.first << " = " << bind.second->getIndex () << "," << bind.second->getName ();
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    this->decreaseIndentation ();
-}
-
-void CPrettyPrinter::printPass (const CPass& pass, int passId) {
-    const auto base = pass.getPass ();
-
-    this->m_out << "Pass " << passId << ":";
-    this->increaseIndentation ();
-
-    if (pass.getBlendingMode () != base->getBlendingMode ()) {
-        this->m_out << "Render blending mode: " << pass.getBlendingMode ();
-        this->lineEnd ();
-        this->m_out << "Blending mode: " << base->getBlendingMode ();
-        this->lineEnd ();
-    } else {
-        this->m_out << "Blending mode: " << base->getBlendingMode ();
-        this->lineEnd ();
-    }
-
-    this->m_out << "Culling mode: " << base->getCullingMode();
-    this->lineEnd ();
-    this->m_out << "Depth test: " << base->getDepthTest();
-    this->lineEnd ();
-    this->m_out << "Depth write: " << base->getDepthWrite();
-    this->lineEnd ();
-    this->m_out << "Shader: " << base->getShader();
-    this->lineEnd ();
-    const auto textures = base->getTextures ();
-
-    if (!textures.empty()) {
-        this->m_out << "Textures " << textures.size () << ":";
-        this->increaseIndentation ();
-
-        for (const auto& texture : textures) {
-            this->m_out << texture.first << ": " << texture.second;
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    const auto& fragmentTextures = pass.getShader ()->getFragment ().getTextures ();
-
-    if (!fragmentTextures.empty()) {
-        this->m_out << "Fragment textures " << fragmentTextures.size () << ":";
-        this->increaseIndentation ();
-
-        for (const auto& texture : fragmentTextures) {
-            this->m_out << texture.first << ": " << texture.second;
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    const auto& vertexTextures = pass.getShader ()->getFragment ().getTextures ();
-
-    if (!vertexTextures.empty()) {
-        this->m_out << "Vertex textures " << textures.size () << ":";
-        this->increaseIndentation ();
-
-        for (const auto& texture : vertexTextures) {
-            this->m_out << texture.first << ": " << texture.second;
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    const auto& combos = base->getCombos();
-
-    if (!combos.empty()) {
-        this->m_out << "Combos " << combos.size () << ":";
-        this->increaseIndentation ();
-
-        for (const auto& combo : combos) {
-            this->m_out << combo.first << " = " << combo.second;
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    const auto& vertexCombos = pass.getShader ()->getVertex ().getDiscoveredCombos ();
-
-    if (!vertexCombos.empty()) {
-        this->m_out << "Vertex combos " << vertexCombos.size () << ":";
-        this->increaseIndentation ();
-
-        for (const auto& combo : vertexCombos) {
-            this->m_out << combo.first << " = " << combo.second;
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    const auto& fragmentCombos = pass.getShader ()->getFragment ().getDiscoveredCombos ();
-
-    if (!fragmentCombos.empty()) {
-        this->m_out << "Vertex combos " << fragmentCombos.size () << ":";
-        this->increaseIndentation ();
-
-        for (const auto& combo : fragmentCombos) {
-            this->m_out << combo.first << " = " << combo.second;
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    const auto& constants = base->getConstants ();
-
-    if (!constants.empty()) {
-        this->m_out << "Constants " << constants.size () << ":";
-        this->increaseIndentation ();
-
-        for (const auto& constant : constants) {
-            this->m_out << constant.first << " = " << constant.second->toString ();
-            this->lineEnd ();
-        }
-
-        this->decreaseIndentation ();
-    }
-
-    this->decreaseIndentation ();
-}
-
-void CPrettyPrinter::printTextureInfo (const ITexture& texture) {
-    this->m_out << "Texture Dimensions: " << texture.getTextureWidth(0) << "x" << texture.getTextureHeight (0);
-    this->lineEnd ();
-    this->m_out << "Part Dimensions: " << texture.getRealWidth  () << "x" << texture.getRealHeight ();
-    this->lineEnd ();
-    this->m_out << "Texture format: ";
-    this->printTextureFormat (texture.getFormat ());
-    this->lineEnd ();
-    this->m_out << "Texture flags: ";
-    this->printTextureFlags (texture.getFlags ());
-    this->lineEnd ();
-    this->m_out << "Is animated: " << texture.isAnimated ();
-    this->lineEnd ();
-
-    const auto& frames = texture.getFrames ();
-
-    if (frames.size () > 1) {
-        this->m_out << frames.size () << " frames: ";
-        this->increaseIndentation ();
-
-        for (const auto frame : frames) {
-            this->m_out << "Frame " << frame->frameNumber << ":";
-            this->increaseIndentation ();
-            this->m_out << "Frametime " << frame->frametime;
-            this->lineEnd ();
-            this->m_out << "Position in atlas: " << frame->x << "x" << frame->y;
-            this->lineEnd ();
-            this->m_out << "Size1: " << frame->width1 << "x" << frame->height1;
-            this->lineEnd ();
-            this->m_out << "Size2: " << frame->width2 << "x" << frame->height2;
-            this->decreaseIndentation ();
-        }
-
-        this->decreaseIndentation ();
-    }
-}
-
-void CPrettyPrinter::printTextureFormat (ITexture::TextureFormat format) {
-    switch (format) {
-        case ITexture::UNKNOWN: this->m_out << "UNKNOWN"; break;
-        case ITexture::ARGB8888: this->m_out << "ARGB8888"; break;
-        case ITexture::RGB888: this->m_out << "RGB888"; break;
-        case ITexture::RGB565: this->m_out << "RGB565"; break;
-        case ITexture::DXT5: this->m_out << "DXT5"; break;
-        case ITexture::DXT3: this->m_out << "DXT3"; break;
-        case ITexture::DXT1: this->m_out << "DXT1"; break;
-        case ITexture::RG88: this->m_out << "RG88"; break;
-        case ITexture::R8: this->m_out << "R8"; break;
-        case ITexture::RG1616f: this->m_out << "RG1616f"; break;
-        case ITexture::R16f: this->m_out << "R16f"; break;
-        case ITexture::BC7: this->m_out << "BC7"; break;
-        case ITexture::RGBa1010102: this->m_out << "RGBa1010102"; break;
-        case ITexture::RGBA16161616f: this->m_out << "RGBA16161616f"; break;
-        case ITexture::RGB161616f: this->m_out << "RGB161616f"; break;
-    }
-}
-
-void CPrettyPrinter::printTextureFlags (ITexture::TextureFlags flags) {
-    if (flags & ITexture::NoInterpolation) {
-        this->m_out << "No interpolation";
-    }
-    if (flags & ITexture::ClampUVs) {
-        this->m_out << "Clamp UVs ";
-    }
-    if (flags & ITexture::IsGif) {
-        this->m_out << "Is gif ";
-    }
-    if (flags & ITexture::ClampUVsBorder) {
-        this->m_out << "ClampUVs border ";
-    }
-    if (flags == ITexture::NoFlags) {
-        this->m_out << "No flags";
-    }
-}
-
-void CPrettyPrinter::indentation () {
-    this->m_out << std::string(this->m_level, '\t');
-}
-
-void CPrettyPrinter::lineEnd () {
-    this->m_out << '\n';
-    this->indentation ();
-}
-
-void CPrettyPrinter::increaseIndentation () {
-    this->m_level ++;
-    this->lineEnd ();
-}
-
-void CPrettyPrinter::decreaseIndentation () {
-    this->m_level --;
-    this->lineEnd ();
-}
-
-std::string CPrettyPrinter::str () {
-    return this->m_buffer.str ();
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.h b/src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.h
deleted file mode 100644
index 3ba89ef..0000000
--- a/src/WallpaperEngine/PrettyPrinter/CPrettyPrinter.h
+++ /dev/null
@@ -1,108 +0,0 @@
-#pragma once
-
-#include <sstream>
-
-#include "WallpaperEngine/Render/Objects/CImage.h"
-
-using namespace WallpaperEngine::Render;
-using namespace WallpaperEngine::Render::Objects;
-using namespace WallpaperEngine::Render::Objects::Effects;
-
-namespace WallpaperEngine::PrettyPrinter {
-/**
- * Provides insights on the actual data that is being used to render the wallpaper
- * to the screens
- */
-class CPrettyPrinter {
-  public:
-    CPrettyPrinter ();
-    ~CPrettyPrinter () = default;
-
-    /**
-     * Prints the information of the given wallpaper
-     *
-     * @param wallpaper
-     */
-    void printWallpaper (const CWallpaper& wallpaper);
-
-    /**
-     * Prints the information of the given image
-     * @param image
-     */
-    void printImage (const CImage& image);
-
-    /**
-     * Prints the information of the given effect
-     *
-     * @param effect
-     * @param effectId The effect ID to show on the output if required
-     */
-    void printEffect (const CEffect& effect, int effectId = 0);
-
-    /**
-     * Prints the information of the given FBO
-     *
-     * @param fbo
-     */
-    void printFBO (const CFBO& fbo);
-
-    /**
-     * Prints the information of the given material
-     *
-     * @param material
-     */
-    void printMaterial (const CMaterial& material);
-
-    /**
-     * Prints the information of the given material's pass
-     *
-     * @param pass
-     */
-    void printPass (const CPass& pass, int passId = 0);
-
-    /**
-     * @return The contents of the pretty printer buffer
-     */
-    std::string str ();
-
-  private:
-    /**
-     * Prints the current indentation level in tabs
-     */
-    void indentation ();
-    /**
-     * Prints an end of line and indentates the next line to the aproppiate level
-     */
-    void lineEnd ();
-    /**
-     * Increases the indentation level and prints a new line up to the specified level
-     */
-    void increaseIndentation ();
-    /**
-     * Decreases the indentation level and prints a new line up to the specified level
-     */
-    void decreaseIndentation ();
-    /**
-     * Prints a texture's format as string in-place
-     *
-     * @param format
-     */
-    void printTextureFormat (ITexture::TextureFormat format);
-    /**
-     * Prints a texture's flags as string in-place
-     *
-     * @param flags
-     */
-    void printTextureFlags (ITexture::TextureFlags flags);
-    /**
-     * Prints information about a given ITexture in-place
-     *
-     * @param texture
-     */
-    void printTextureInfo (const ITexture& texture);
-
-    int m_level = 0;
-    std::stringbuf m_buffer = {};
-    std::ostream m_out;
-};
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/CCamera.cpp b/src/WallpaperEngine/Render/CCamera.cpp
index 423b180..0a22e29 100644
--- a/src/WallpaperEngine/Render/CCamera.cpp
+++ b/src/WallpaperEngine/Render/CCamera.cpp
@@ -6,9 +6,11 @@
 using namespace WallpaperEngine;
 using namespace WallpaperEngine::Render;
 
-CCamera::CCamera (Wallpapers::CScene* scene, const Core::Scenes::CCamera* camera) :
+CCamera::CCamera (Wallpapers::CScene& scene, const SceneData::Camera& camera) :
     m_camera (camera),
-    m_scene (scene) {
+    m_scene (scene),
+    m_width (0),
+    m_height (0) {
     // get the lookat position
     // TODO: ENSURE THIS IS ONLY USED WHEN NOT DOING AN ORTOGRAPHIC CAMERA AS IT THROWS OFF POINTS
     this->m_lookat = glm::lookAt (this->getEye (), this->getCenter (), this->getUp ());
@@ -17,15 +19,15 @@ CCamera::CCamera (Wallpapers::CScene* scene, const Core::Scenes::CCamera* camera
 CCamera::~CCamera () = default;
 
 const glm::vec3& CCamera::getCenter () const {
-    return this->m_camera->getCenter ();
+    return this->m_camera.configuration.center;
 }
 
 const glm::vec3& CCamera::getEye () const {
-    return this->m_camera->getEye ();
+    return this->m_camera.configuration.eye;
 }
 
 const glm::vec3& CCamera::getUp () const {
-    return this->m_camera->getUp ();
+    return this->m_camera.configuration.up;
 }
 
 const glm::mat4& CCamera::getProjection () const {
@@ -40,11 +42,22 @@ bool CCamera::isOrthogonal () const {
     return this->m_isOrthogonal;
 }
 
-Wallpapers::CScene* CCamera::getScene () const {
+Wallpapers::CScene& CCamera::getScene () const {
     return this->m_scene;
 }
 
+float CCamera::getWidth () const {
+    return this->m_width;
+}
+
+float CCamera::getHeight () const {
+    return this->m_height;
+}
+
 void CCamera::setOrthogonalProjection (float width, float height) {
+    this->m_width = width;
+    this->m_height = height;
+
     // TODO: GET THE ZNEAR AND ZFAR FROM THE BACKGROUND (IF AVAILABLE)
     // get the orthogonal projection (the float is there to ensure the values are casted to float, so maths do work)
     this->m_projection = glm::ortho<float> (-width / 2.0, width / 2.0, -height / 2.0, height / 2.0, 0, 1000);
diff --git a/src/WallpaperEngine/Render/CCamera.h b/src/WallpaperEngine/Render/CCamera.h
index 0496c5f..da290ad 100644
--- a/src/WallpaperEngine/Render/CCamera.h
+++ b/src/WallpaperEngine/Render/CCamera.h
@@ -5,16 +5,18 @@
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 
-#include "WallpaperEngine/Core/Scenes/CCamera.h"
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
 
 namespace WallpaperEngine::Render::Wallpapers {
 class CScene;
 }
 
 namespace WallpaperEngine::Render {
+using namespace WallpaperEngine::Data::Model;
+
 class CCamera {
   public:
-    CCamera (Wallpapers::CScene* scene, const Core::Scenes::CCamera* camera);
+    CCamera (Wallpapers::CScene& scene, const SceneData::Camera& camera);
     ~CCamera ();
 
     void setOrthogonalProjection (float width, float height);
@@ -24,14 +26,18 @@ class CCamera {
     [[nodiscard]] const glm::vec3& getUp () const;
     [[nodiscard]] const glm::mat4& getProjection () const;
     [[nodiscard]] const glm::mat4& getLookAt () const;
-    [[nodiscard]] Wallpapers::CScene* getScene () const;
+    [[nodiscard]] Wallpapers::CScene& getScene () const;
     [[nodiscard]] bool isOrthogonal () const;
+    [[nodiscard]] float getWidth () const;
+    [[nodiscard]] float getHeight () const;
 
   private:
+    float m_width;
+    float m_height;
     bool m_isOrthogonal = false;
     glm::mat4 m_projection = {};
     glm::mat4 m_lookat = {};
-    const Core::Scenes::CCamera* m_camera;
-    Wallpapers::CScene* m_scene = nullptr;
+    const SceneData::Camera& m_camera;
+    Wallpapers::CScene& m_scene;
 };
 } // namespace WallpaperEngine::Render
diff --git a/src/WallpaperEngine/Render/CFBO.h b/src/WallpaperEngine/Render/CFBO.h
index b3b5700..9d62be0 100644
--- a/src/WallpaperEngine/Render/CFBO.h
+++ b/src/WallpaperEngine/Render/CFBO.h
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <string>
+
 #include "WallpaperEngine/Assets/ITexture.h"
-#include "WallpaperEngine/Core/Objects/CImage.h"
-#include "WallpaperEngine/Core/Objects/Effects/CFBO.h"
 
 using namespace WallpaperEngine::Assets;
 
diff --git a/src/WallpaperEngine/Render/CFBOProvider.cpp b/src/WallpaperEngine/Render/CFBOProvider.cpp
new file mode 100644
index 0000000..4b9c3bf
--- /dev/null
+++ b/src/WallpaperEngine/Render/CFBOProvider.cpp
@@ -0,0 +1,57 @@
+#include "CFBOProvider.h"
+#include <gmpxx.h>
+
+using namespace WallpaperEngine::Render;
+using namespace WallpaperEngine::Data::Model;
+
+
+CFBOProvider::CFBOProvider (const CFBOProvider* parent) :
+    m_parent (parent) {}
+
+
+std::shared_ptr<CFBO> CFBOProvider::create(const FBO& base, ITexture::TextureFlags flags, glm::vec2 size) {
+    return this->m_fbos[base.name] = std::make_shared <CFBO> (
+        base.name,
+        // TODO: PROPERLY DETERMINE FBO FORMAT BASED ON THE STRING
+        ITexture::TextureFormat::ARGB8888,
+        flags,
+        base.scale,
+        size.x / base.scale,
+        size.y / base.scale,
+        size.x / base.scale,
+        size.y / base.scale
+    );
+}
+
+std::shared_ptr<CFBO> CFBOProvider::create (
+    const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
+    glm::vec2 realSize, glm::vec2 textureSize
+) {
+    return this->m_fbos[name] = std::make_shared <CFBO> (
+        name,
+        ITexture::TextureFormat::ARGB8888,
+        flags,
+        scale,
+        realSize.x,
+        realSize.y,
+        textureSize.x,
+        textureSize.y
+    );
+}
+
+std::shared_ptr<CFBO> CFBOProvider::alias (const std::string& newName, const std::string& original) {
+    return this->m_fbos[newName] = this->m_fbos[original];
+}
+
+std::shared_ptr<CFBO> CFBOProvider::find (const std::string& name) const {
+    const auto it = this->m_fbos.find (name);
+
+    if (it != this->m_fbos.end ())
+        return it->second;
+
+    if (this->m_parent == nullptr) {
+        return nullptr;
+    }
+
+    return this->m_parent->find (name);
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/CFBOProvider.h b/src/WallpaperEngine/Render/CFBOProvider.h
new file mode 100644
index 0000000..2b3d174
--- /dev/null
+++ b/src/WallpaperEngine/Render/CFBOProvider.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "CFBO.h"
+#include "WallpaperEngine/Data/Model/Effect.h"
+
+namespace WallpaperEngine::Render {
+using namespace WallpaperEngine::Data::Model;
+
+class CFBOProvider {
+  public:
+    CFBOProvider (const CFBOProvider* parent);
+
+    std::shared_ptr<CFBO> create (const FBO& base, ITexture::TextureFlags flags, glm::vec2 size);
+    std::shared_ptr<CFBO> create (
+        const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
+        glm::vec2 realSize, glm::vec2 textureSize);
+    std::shared_ptr<CFBO> alias (const std::string& newName, const std::string& original);
+    [[nodiscard]] std::shared_ptr<CFBO> find (const std::string& name) const;
+
+  private:
+    const CFBOProvider* m_parent;
+    std::map <std::string, std::shared_ptr<CFBO>> m_fbos = {};
+};
+}
diff --git a/src/WallpaperEngine/Render/CObject.cpp b/src/WallpaperEngine/Render/CObject.cpp
index ea666df..9676e71 100644
--- a/src/WallpaperEngine/Render/CObject.cpp
+++ b/src/WallpaperEngine/Render/CObject.cpp
@@ -6,19 +6,19 @@ using namespace WallpaperEngine;
 using namespace WallpaperEngine::Render;
 using namespace WallpaperEngine::Render::Wallpapers;
 
-CObject::CObject (Wallpapers::CScene* scene, const Core::CObject* object) :
+CObject::CObject (Wallpapers::CScene& scene, const Object& object) :
     Helpers::CContextAware (scene),
     m_scene (scene),
     m_object (object) {}
 
-Wallpapers::CScene* CObject::getScene () const {
+Wallpapers::CScene& CObject::getScene () const {
     return this->m_scene;
 }
 
-std::shared_ptr<const CContainer> CObject::getContainer () const {
-    return this->getScene ()->getContainer ();
+const CContainer& CObject::getContainer () const {
+    return this->getScene ().getContainer ();
 }
 
 int CObject::getId () const {
-    return this->m_object->getId ();
+    return this->m_object.id;
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/CObject.h b/src/WallpaperEngine/Render/CObject.h
index ae0656b..cf775c8 100644
--- a/src/WallpaperEngine/Render/CObject.h
+++ b/src/WallpaperEngine/Render/CObject.h
@@ -2,7 +2,6 @@
 
 #include <string>
 
-#include "WallpaperEngine/Core/CObject.h"
 #include "WallpaperEngine/Render/Helpers/CContextAware.h"
 
 #include "WallpaperEngine/Render/Wallpapers/CScene.h"
@@ -36,16 +35,16 @@ class CObject : public Helpers::CContextAware {
 
     virtual void render () = 0;
 
-    [[nodiscard]] Wallpapers::CScene* getScene () const;
-    [[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
+    [[nodiscard]] Wallpapers::CScene& getScene () const;
+    [[nodiscard]] const CContainer& getContainer () const;
     [[nodiscard]] int getId () const;
 
   protected:
-    CObject (Wallpapers::CScene* scene, const Core::CObject* object);
+    CObject (Wallpapers::CScene& scene, const Object& object);
     virtual ~CObject () override = default;
 
   private:
-    Wallpapers::CScene* m_scene = nullptr;
-    const Core::CObject* m_object;
+    Wallpapers::CScene& m_scene;
+    const Object& m_object;
 };
 } // namespace WallpaperEngine::Render
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/CRenderContext.cpp b/src/WallpaperEngine/Render/CRenderContext.cpp
index c644016..d70059b 100644
--- a/src/WallpaperEngine/Render/CRenderContext.cpp
+++ b/src/WallpaperEngine/Render/CRenderContext.cpp
@@ -5,6 +5,8 @@
 #include "CRenderContext.h"
 #include "CWallpaper.h"
 
+#include "WallpaperEngine/Data/Model/Project.h"
+
 namespace WallpaperEngine::Render {
 CRenderContext::CRenderContext (Drivers::CVideoDriver& driver, CWallpaperApplication& app) :
     m_driver (driver),
diff --git a/src/WallpaperEngine/Render/CTextureCache.cpp b/src/WallpaperEngine/Render/CTextureCache.cpp
index b7e97e0..a2dc4c7 100644
--- a/src/WallpaperEngine/Render/CTextureCache.cpp
+++ b/src/WallpaperEngine/Render/CTextureCache.cpp
@@ -3,6 +3,8 @@
 #include "WallpaperEngine/Assets/CAssetLoadException.h"
 #include "WallpaperEngine/Render/Helpers/CContextAware.h"
 
+#include "WallpaperEngine/Data/Model/Project.h"
+
 using namespace WallpaperEngine::Render;
 using namespace WallpaperEngine::Assets;
 
@@ -15,9 +17,9 @@ std::shared_ptr<const ITexture> CTextureCache::resolve (const std::string& filen
         return found->second;
 
     // search for the texture in all the different containers just in case
-    for (const auto& it : this->getContext ().getApp ().getBackgrounds ()) {
+    for (const auto& [name, project] : this->getContext ().getApp ().getBackgrounds ()) {
         try {
-            std::shared_ptr<const ITexture> texture = it.second->getContainer ()->readTexture (filename);
+            std::shared_ptr<const ITexture> texture = project->container->readTexture (filename);
 
             this->store (filename, texture);
 
diff --git a/src/WallpaperEngine/Render/CWallpaper.cpp b/src/WallpaperEngine/Render/CWallpaper.cpp
index 3263eb8..b8da029 100644
--- a/src/WallpaperEngine/Render/CWallpaper.cpp
+++ b/src/WallpaperEngine/Render/CWallpaper.cpp
@@ -4,17 +4,21 @@
 #include "WallpaperEngine/Render/Wallpapers/CVideo.h"
 #include "WallpaperEngine/Render/Wallpapers/CWeb.h"
 
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+
 #include <glm/glm.hpp>
 #include <glm/gtc/type_ptr.hpp>
 
 using namespace WallpaperEngine::Render;
 
 CWallpaper::CWallpaper (
-    std::shared_ptr <const Core::CWallpaper> wallpaperData, CRenderContext& context,CAudioContext& audioContext,
+    const Wallpaper& wallpaperData, CRenderContext& context,CAudioContext& audioContext,
     const CWallpaperState::TextureUVsScaling& scalingMode,
     const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
 ) :
     CContextAware (context),
+    CFBOProvider (nullptr),
     m_wallpaperData (wallpaperData),
     m_audioContext (audioContext),
     m_state (scalingMode, clampMode) {
@@ -41,11 +45,11 @@ CWallpaper::CWallpaper (
 
 CWallpaper::~CWallpaper () = default;
 
-std::shared_ptr<const CContainer> CWallpaper::getContainer () const {
-    return this->m_wallpaperData->getProject ()->getContainer ();
+const CContainer& CWallpaper::getContainer () const {
+    return *this->m_wallpaperData.project.container;
 }
 
-std::shared_ptr <const WallpaperEngine::Core::CWallpaper> CWallpaper::getWallpaperData () const {
+const Wallpaper& CWallpaper::getWallpaperData () const {
     return this->m_wallpaperData;
 }
 
@@ -186,7 +190,14 @@ void CWallpaper::updateUVs (const glm::ivec4& viewport, const bool vflip) {
 }
 
 void CWallpaper::render (glm::ivec4 viewport, bool vflip) {
+#if !NDEBUG
+    glPushDebugGroup (GL_DEBUG_SOURCE_APPLICATION, 0, -1, "Rendering scene");
+#endif /* !NDEBUG */
     this->renderFrame (viewport);
+#if !NDEBUG
+    glPopDebugGroup ();
+    glPushDebugGroup (GL_DEBUG_SOURCE_APPLICATION, 0, -1, "Rendering scene to output");
+#endif /* !NDEBUG */
     // Update UVs coordinates according to scaling mode of this wallpaper
     updateUVs (viewport, vflip);
     auto [ustart, uend, vstart, vend] = this->m_state.getTextureUVs ();
@@ -203,6 +214,7 @@ void CWallpaper::render (glm::ivec4 viewport, bool vflip) {
 
     glDisable (GL_BLEND);
     glDisable (GL_DEPTH_TEST);
+    glDisable (GL_CULL_FACE);
     // do not use any shader
     glUseProgram (this->m_shader);
     // activate scene texture
@@ -222,6 +234,10 @@ void CWallpaper::render (glm::ivec4 viewport, bool vflip) {
     // write the framebuffer as is to the screen
     glBindBuffer (GL_ARRAY_BUFFER, this->m_texCoordBuffer);
     glDrawArrays (GL_TRIANGLES, 0, 6);
+
+#if !NDEBUG
+    glPopDebugGroup ();
+#endif /* !NDEBUG */
 }
 
 void CWallpaper::setPause (bool newState) {}
@@ -232,62 +248,43 @@ void CWallpaper::setupFramebuffers () {
     const ITexture::TextureFlags clamp = this->m_state.getClampingMode ();
 
     // create framebuffer for the scene
-    this->m_sceneFBO = this->createFBO (
-        "_rt_FullFrameBuffer", ITexture::TextureFormat::ARGB8888, clamp, 1.0, width,
-        height, width, height);
+    this->m_sceneFBO = this->create (
+        "_rt_FullFrameBuffer", ITexture::TextureFormat::ARGB8888, clamp, 1.0, {width,
+        height}, {width, height});
 
-    this->aliasFBO ("_rt_MipMappedFrameBuffer", this->m_sceneFBO);
+    this->alias ("_rt_MipMappedFrameBuffer", "_rt_FullFrameBuffer");
 }
 
 CAudioContext& CWallpaper::getAudioContext () {
     return this->m_audioContext;
 }
 
-std::shared_ptr<const CFBO> CWallpaper::createFBO (
-    const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
-    uint32_t realWidth, uint32_t realHeight, uint32_t textureWidth, uint32_t textureHeight
-) {
-    std::shared_ptr<const CFBO> fbo = std::make_shared <CFBO> (name, format, flags, scale, realWidth, realHeight, textureWidth, textureHeight);
-
-    this->m_fbos.emplace (name, fbo);
-
-    return fbo;
-}
-
-void CWallpaper::aliasFBO (const std::string& alias, const std::shared_ptr<const CFBO>& original) {
-    this->m_fbos.emplace (alias, original);
-}
-
-const std::map<std::string, std::shared_ptr<const CFBO>>& CWallpaper::getFBOs () const {
-    return this->m_fbos;
-}
-
 std::shared_ptr<const CFBO> CWallpaper::findFBO (const std::string& name) const {
-    const auto it = this->m_fbos.find (name);
+    const auto fbo = this->find (name);
 
-    if (it == this->m_fbos.end ())
+    if (fbo == nullptr)
         sLog.exception ("Cannot find FBO ", name);
 
-    return it->second;
+    return fbo;
 }
 
 std::shared_ptr<const CFBO> CWallpaper::getFBO () const {
     return this->m_sceneFBO;
 }
 
-std::shared_ptr<CWallpaper> CWallpaper::fromWallpaper (
-    std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
+std::unique_ptr<CWallpaper> CWallpaper::fromWallpaper (
+    const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
     WebBrowser::CWebBrowserContext* browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
     const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
 ) {
-    if (wallpaper->is<Core::Wallpapers::CScene> ()) {
-        return std::make_shared <WallpaperEngine::Render::Wallpapers::CScene> (
+    if (wallpaper.is<Scene> ()) {
+        return std::make_unique <WallpaperEngine::Render::Wallpapers::CScene> (
             wallpaper, context, audioContext, scalingMode, clampMode);
-    } else if (wallpaper->is<Core::Wallpapers::CVideo> ()) {
-        return std::make_shared<WallpaperEngine::Render::Wallpapers::CVideo> (
+    } else if (wallpaper.is<Video> ()) {
+        return std::make_unique<WallpaperEngine::Render::Wallpapers::CVideo> (
             wallpaper, context, audioContext, scalingMode, clampMode);
-    } else if (wallpaper->is<Core::Wallpapers::CWeb> ()) {
-        return std::make_shared<WallpaperEngine::Render::Wallpapers::CWeb> (
+    } else if (wallpaper.is<Web> ()) {
+        return std::make_unique<WallpaperEngine::Render::Wallpapers::CWeb> (
             wallpaper, context, audioContext, *browserContext, scalingMode, clampMode);
     } else
         sLog.exception ("Unsupported wallpaper type");
diff --git a/src/WallpaperEngine/Render/CWallpaper.h b/src/WallpaperEngine/Render/CWallpaper.h
index 3e668df..3ad8ce5 100644
--- a/src/WallpaperEngine/Render/CWallpaper.h
+++ b/src/WallpaperEngine/Render/CWallpaper.h
@@ -6,18 +6,14 @@
 #include "WallpaperEngine/Assets/CContainer.h"
 #include "WallpaperEngine/Audio/CAudioContext.h"
 
-#include "WallpaperEngine/Core/CWallpaper.h"
-#include "WallpaperEngine/Core/Wallpapers/CScene.h"
-#include "WallpaperEngine/Core/Wallpapers/CVideo.h"
-
 #include "WallpaperEngine/Render/CFBO.h"
 #include "WallpaperEngine/Render/CRenderContext.h"
 #include "WallpaperEngine/Render/Helpers/CContextAware.h"
 
-#include "CWallpaperState.h"
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
 
-using namespace WallpaperEngine::Assets;
-using namespace WallpaperEngine::Audio;
+#include "CFBOProvider.h"
+#include "CWallpaperState.h"
 
 namespace WallpaperEngine::WebBrowser {
 class CWebBrowserContext;
@@ -28,7 +24,11 @@ namespace Helpers {
 class CContextAware;
 }
 
-class CWallpaper : public Helpers::CContextAware {
+using namespace WallpaperEngine::Assets;
+using namespace WallpaperEngine::Audio;
+using namespace WallpaperEngine::Data::Model;
+
+class CWallpaper : public Helpers::CContextAware, public CFBOProvider {
   public:
     template <class T> [[nodiscard]] const T* as () const {
         if (is <T> ()) {
@@ -65,7 +65,7 @@ class CWallpaper : public Helpers::CContextAware {
     /**
      * @return The container to resolve files for this wallpaper
      */
-    [[nodiscard]] std::shared_ptr<const CContainer> getContainer () const;
+    [[nodiscard]] const CContainer& getContainer () const;
 
     /**
      * @return The current audio context for this wallpaper
@@ -80,34 +80,6 @@ class CWallpaper : public Helpers::CContextAware {
      * @return The scene's texture
      */
     [[nodiscard]] virtual GLuint getWallpaperTexture () const;
-    /**
-     * Creates a new FBO for this wallpaper
-     *
-     * @param name The name of the FBO
-     * @param format
-     * @param flags
-     * @param scale
-     * @param realWidth
-     * @param realHeight
-     * @param textureWidth
-     * @param textureHeight
-     * @return
-     */
-    std::shared_ptr<const CFBO> createFBO (
-        const std::string& name, ITexture::TextureFormat format, ITexture::TextureFlags flags, float scale,
-        uint32_t realWidth, uint32_t realHeight, uint32_t textureWidth, uint32_t textureHeight);
-
-    /**
-     * Creates an alias of an existing fbo
-     * @param alias
-     * @param original
-     */
-    void aliasFBO (const std::string& alias, const std::shared_ptr<const CFBO>& original);
-
-    /**
-     * @return The full FBO list to work with
-     */
-    [[nodiscard]] const std::map<std::string, std::shared_ptr<const CFBO>>& getFBOs () const;
     /**
      * Searches the FBO list for the given FBO
      *
@@ -153,14 +125,14 @@ class CWallpaper : public Helpers::CContextAware {
      *
      * @return
      */
-    static std::shared_ptr<CWallpaper> fromWallpaper (
-        std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
+    static std::unique_ptr<CWallpaper> fromWallpaper (
+        const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
         WebBrowser::CWebBrowserContext* browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
         const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
 
   protected:
     CWallpaper (
-        std::shared_ptr <const WallpaperEngine::Core::CWallpaper> wallpaperData, CRenderContext& context,
+        const Wallpaper& wallpaperData, CRenderContext& context,
         CAudioContext& audioContext, const CWallpaperState::TextureUVsScaling& scalingMode,
         const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
 
@@ -174,9 +146,9 @@ class CWallpaper : public Helpers::CContextAware {
      */
     void setupFramebuffers ();
 
-    std::shared_ptr <const WallpaperEngine::Core::CWallpaper> m_wallpaperData;
+    const Wallpaper& m_wallpaperData;
 
-    [[nodiscard]] std::shared_ptr <const WallpaperEngine::Core::CWallpaper> getWallpaperData () const;
+    [[nodiscard]] const Wallpaper& getWallpaperData () const;
 
     /** The FBO used for scene output */
     std::shared_ptr<const CFBO> m_sceneFBO = nullptr;
diff --git a/src/WallpaperEngine/Render/Objects/CEffect.cpp b/src/WallpaperEngine/Render/Objects/CEffect.cpp
deleted file mode 100644
index cc62945..0000000
--- a/src/WallpaperEngine/Render/Objects/CEffect.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include "CEffect.h"
-
-using namespace WallpaperEngine::Render;
-using namespace WallpaperEngine::Render::Objects;
-
-CEffect::CEffect (CImage* image, const Core::Objects::CEffect* effect) :
-    m_image (image),
-    m_effect (effect) {
-    this->generateFBOs ();
-    this->generatePasses ();
-}
-
-CImage* CEffect::getImage () const {
-    return this->m_image;
-}
-
-const std::vector<Effects::CMaterial*>& CEffect::getMaterials () const {
-    return this->m_materials;
-}
-
-std::shared_ptr<const CFBO> CEffect::findFBO (const std::string& name) const {
-    const auto fbo = this->m_fbos.find (name);
-
-    if (fbo == this->m_fbos.end ()) {
-        return nullptr;
-    }
-
-    return fbo->second;
-}
-
-void CEffect::generatePasses () {
-    for (const auto& cur : this->m_effect->getMaterials ())
-        this->m_materials.emplace_back (new Effects::CMaterial (this, cur));
-}
-
-void CEffect::generateFBOs () {
-    for (const auto& cur : this->m_effect->getFbos ()) {
-        // TODO: IS THAT DIVISION OKAY? SHOULDN'T IT BE A MULTIPLICATION? WTF?
-        this->m_fbos.emplace (
-            cur->getName(),
-            new CFBO (
-                // TODO: SET PROPER FLAGS AND FORMAT
-                cur->getName (), ITexture::TextureFormat::ARGB8888,
-                this->m_image->getTexture ()->getFlags (), cur->getScale (),
-                this->m_image->getSize ().x / cur->getScale (),
-                this->m_image->getSize ().y / cur->getScale (),
-                this->m_image->getSize ().x / cur->getScale (),
-                this->m_image->getSize ().y / cur->getScale ()
-            )
-        );
-    }
-}
-
-const std::map<std::string, std::shared_ptr<const CFBO>>& CEffect::getFBOs () const {
-    return this->m_fbos;
-}
-
-bool CEffect::isVisible () const {
-    return this->m_effect->isVisible ();
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Objects/CEffect.h b/src/WallpaperEngine/Render/Objects/CEffect.h
deleted file mode 100644
index d76fdb6..0000000
--- a/src/WallpaperEngine/Render/Objects/CEffect.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Render/CFBO.h"
-#include "WallpaperEngine/Render/Objects/CImage.h"
-#include "WallpaperEngine/Render/Objects/Effects/CMaterial.h"
-#include "WallpaperEngine/Render/Objects/Effects/CPass.h"
-
-#include "WallpaperEngine/PrettyPrinter/CPrettyPrinter.h"
-
-namespace WallpaperEngine::PrettyPrinter {
-class CPrettyPrinter;
-}
-
-namespace WallpaperEngine::Render::Objects::Effects {
-class CMaterial;
-}
-
-namespace WallpaperEngine::Render::Objects {
-class CImage;
-
-class CEffect {
-  public:
-    CEffect (CImage* image, const Core::Objects::CEffect* effect);
-
-    [[nodiscard]] CImage* getImage () const;
-
-    [[nodiscard]] const std::vector<Effects::CMaterial*>& getMaterials () const;
-
-    [[nodiscard]] std::shared_ptr<const CFBO> findFBO (const std::string& name) const;
-    [[nodiscard]] bool isVisible () const;
-
-  protected:
-    friend class WallpaperEngine::PrettyPrinter::CPrettyPrinter;
-
-    [[nodiscard]] const std::map<std::string, std::shared_ptr<const CFBO>>& getFBOs () const;
-
-  private:
-    void generatePasses ();
-    void generateFBOs ();
-
-    CImage* m_image = nullptr;
-    const Core::Objects::CEffect* m_effect;
-
-    std::map<std::string, std::shared_ptr<const CFBO>> m_fbos = {};
-    std::vector<Effects::CMaterial*> m_materials = {};
-};
-} // namespace WallpaperEngine::Render::Objects
diff --git a/src/WallpaperEngine/Render/Objects/CImage.cpp b/src/WallpaperEngine/Render/Objects/CImage.cpp
index 4438009..a4d36b2 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.cpp
+++ b/src/WallpaperEngine/Render/Objects/CImage.cpp
@@ -1,11 +1,21 @@
 #include "CImage.h"
 #include <sstream>
 
+#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
+#include "WallpaperEngine/Data/Parsers/MaterialParser.h"
+#include "WallpaperEngine/Data/Builders/UserSettingBuilder.h"
+#include "WallpaperEngine/Data/Model/Object.h"
+#include "WallpaperEngine/Data/Model/Material.h"
+
 using namespace WallpaperEngine;
 using namespace WallpaperEngine::Render::Objects;
+using namespace WallpaperEngine::Render::Objects::Effects;
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Builders;
 
-CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
+CImage::CImage (Wallpapers::CScene& scene, const Image& image) :
     Render::CObject (scene, image),
+    Render::CFBOProvider (&scene),
     m_texture (nullptr),
     m_sceneSpacePosition (GL_NONE),
     m_copySpacePosition (GL_NONE),
@@ -26,19 +36,19 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
     m_pos (),
     m_animationTime (0.0),
     m_initialized (false) {
-    auto projection = this->getScene ()->getScene ()->getOrthogonalProjection ();
 
     // get scene width and height to calculate positions
-    auto scene_width = static_cast<float> (projection->getWidth ());
-    auto scene_height = static_cast<float> (projection->getHeight ());
+    auto scene_width = static_cast<float> (scene.getWidth ());
+    auto scene_height = static_cast<float> (scene.getHeight ());
 
-    glm::vec3 origin = this->getImage ()->getOrigin ();
+    // TODO: MAKE USE OF THE USER PROPERTIES POINTER HERE TOO! SO EVERYTHING IS UPDATED ACCORDINGLY
+    glm::vec3 origin = this->getImage ().origin->value->getVec3 ();
     glm::vec2 size = this->getSize ();
-    glm::vec3 scale = this->getImage ()->getScale ();
+    glm::vec3 scale = this->getImage ().scale->value->getVec3 ();
 
     // fullscreen layers should use the whole projection's size
     // TODO: WHAT SHOULD AUTOSIZE DO?
-    if (this->getImage ()->isFullscreen ()) {
+    if (this->getImage ().model->fullscreen) {
         size = {scene_width, scene_height};
         origin = {scene_width / 2, scene_height / 2, 0};
 
@@ -53,18 +63,18 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
     this->m_pos.z = origin.x + (scaledSize.x / 2);
     this->m_pos.y = origin.y - (scaledSize.y / 2);
 
-    if (this->getImage ()->getAlignment ().find ("top") != std::string::npos) {
+    if (this->getImage ().alignment.find ("top") != std::string::npos) {
         this->m_pos.y -= scaledSize.y / 2;
         this->m_pos.w -= scaledSize.y / 2;
-    } else if (this->getImage ()->getAlignment ().find ("bottom") != std::string::npos) {
+    } else if (this->getImage ().alignment.find ("bottom") != std::string::npos) {
         this->m_pos.y += scaledSize.y / 2;
         this->m_pos.w += scaledSize.y / 2;
     }
 
-    if (this->getImage ()->getAlignment ().find ("left") != std::string::npos) {
+    if (this->getImage ().alignment.find ("left") != std::string::npos) {
         this->m_pos.x += scaledSize.x / 2;
         this->m_pos.z += scaledSize.x / 2;
-    } else if (this->getImage ()->getAlignment ().find ("right") != std::string::npos) {
+    } else if (this->getImage ().alignment.find ("right") != std::string::npos) {
         this->m_pos.x -= scaledSize.x / 2;
         this->m_pos.z -= scaledSize.x / 2;
     }
@@ -76,19 +86,19 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
     this->m_pos.w = scene_height / 2 - this->m_pos.w;
 
     // detect texture (if any)
-    auto textures = (*this->m_image->getMaterial ()->getPasses ().begin ())->getTextures ();
+    auto textures = (*this->m_image.model->material->passes.begin ())->textures;
 
     if (!textures.empty ()) {
         std::string textureName = textures.begin ()->second;
 
         if (textureName.find ("_rt_") == 0) {
-            this->m_texture = this->getScene ()->findFBO (textureName);
+            this->m_texture = this->getScene ().findFBO (textureName);
         } else {
             // get the first texture on the first pass (this one represents the image assigned to this object)
             this->m_texture = this->getContext ().resolveTexture (textureName);
         }
     } else {
-        if (this->m_image->getMaterial ()->isSolidLayer()) {
+        if (this->m_image.model->solidlayer) {
             size.x = scene_width;
             size.y = scene_height;
         }
@@ -105,15 +115,15 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
     std::ostringstream nameA, nameB;
 
     // TODO: determine when _rt_imageLayerComposite and _rt_imageLayerAlbedo is used
-    nameA << "_rt_imageLayerComposite_" << this->getImage ()->getId () << "_a";
-    nameB << "_rt_imageLayerComposite_" << this->getImage ()->getId () << "_b";
+    nameA << "_rt_imageLayerComposite_" << this->getImage ().id << "_a";
+    nameB << "_rt_imageLayerComposite_" << this->getImage ().id << "_b";
 
     this->m_currentMainFBO = this->m_mainFBO =
-        scene->createFBO (nameA.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
-                          size.x, size.y, size.x, size.y);
+        scene.create (nameA.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
+                      {size.x, size.y}, {size.x, size.y});
     this->m_currentSubFBO = this->m_subFBO =
-        scene->createFBO (nameB.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
-                          size.x, size.y, size.x, size.y);
+        scene.create (nameB.str (), ITexture::TextureFormat::ARGB8888, this->m_texture->getFlags (), 1,
+                      {size.x, size.y}, {size.x, size.y});
 
     // build a list of vertices, these might need some change later (or maybe invert the camera)
     GLfloat sceneSpacePosition [] = {this->m_pos.x, this->m_pos.y, 0.0f, this->m_pos.x, this->m_pos.w, 0.0f,
@@ -163,13 +173,13 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
     GLfloat realX = 0.0;
     GLfloat realY = 0.0;
 
-    if (this->getImage ()->isPassthrough ()) {
+    if (this->getImage ().model->passthrough) {
         x = -((this->m_pos.x + (scene_width / 2)) / size.x);
         y = -((this->m_pos.w + (scene_height / 2)) / size.y);
         height = (this->m_pos.y + (scene_height / 2)) / size.y;
         width = (this->m_pos.z + (scene_width / 2)) / size.x;
 
-        if (this->getImage ()->isFullscreen ()) {
+        if (this->getImage ().model->fullscreen) {
             realX = -1.0;
             realY = -1.0;
             realWidth = 1.0;
@@ -210,7 +220,7 @@ CImage::CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image) :
     glBufferData (GL_ARRAY_BUFFER, sizeof (texcoordPass), texcoordPass, GL_STATIC_DRAW);
 
     this->m_modelViewProjectionScreen =
-        this->getScene ()->getCamera ()->getProjection () * this->getScene ()->getCamera ()->getLookAt ();
+        this->getScene ().getCamera ().getProjection () * this->getScene ().getCamera ().getLookAt ();
 
     this->m_modelViewProjectionScreenInverse = glm::inverse (this->m_modelViewProjectionScreen);
 
@@ -226,62 +236,79 @@ void CImage::setup () {
         return;
 
     // TODO: SUPPORT PASSTHROUGH (IT'S A SHADER)
-
     // passthrough images without effects are bad, do not draw them
-    if (this->getImage ()->isPassthrough () && this->getImage ()->getEffects ().empty ())
+    if (this->m_image.model->passthrough && this->m_image.effects.empty ())
         return;
 
-    // generate the main material used to render the image
-    this->m_material = new Effects::CMaterial (
-        new CEffect (
-            this,
-            new Core::Objects::CEffect (
-                "", "", "", "", this->m_image->getProject (),
-                Core::UserSettings::CUserSettingBoolean::fromScalar (true),
-                {}, {}, {})),
-        this->m_image->getMaterial ()
-    );
-
     // add blendmode to the combos
-    for (const auto& cur : this->m_material->getPasses ())
-        this->m_passes.push_back (cur);
+    for (const auto& cur : this->getImage ().model->material->passes)
+        this->m_passes.push_back (
+            new CPass (*this, std::make_shared<CFBOProvider>(this), *cur, std::nullopt, std::nullopt, std::nullopt)
+        );
 
+    // TODO: MAYBE GET RID OF THE WHOLE EFFECT CLASS AND PROCESS THE EFFECTS DIRECTLY TO SIMPLIFY RENDERING CODE?
     // prepare the passes list
-    if (!this->getImage ()->getEffects ().empty ()) {
+    if (!this->getImage ().effects.empty ()) {
         // generate the effects used by this material
-        for (const auto& cur : this->getImage ()->getEffects ()) {
-            auto effect = new CEffect (this, cur);
+        for (const auto& cur : this->m_image.effects) {
+            auto fboProvider = std::make_shared<CFBOProvider> (this);
 
-            for (const auto& material : effect->getMaterials ())
-                for (const auto& pass : material->getPasses ())
-                    this->m_passes.push_back (pass);
+            // create all the fbos for this effect
+            for (const auto& fbo : cur->effect->fbos) {
+                fboProvider->create (*fbo, this->m_texture->getFlags (), this->getSize ());
+            }
 
-            this->m_effects.push_back (effect);
+            // TODO: MAKE USE OF ZIP OPERATOR IN BOOST? WAY OVERKILL JUST FOR THIS...
+
+            auto curEffect = cur->effect->passes.begin ();
+            auto endEffect = cur->effect->passes.end ();
+            auto curOverride = cur->passOverrides.begin ();
+            auto endOverride = cur->passOverrides.end ();
+
+            for (; curEffect != endEffect; curEffect++) {
+                auto curPass = (*curEffect)->material->passes.begin ();
+                auto endPass = (*curEffect)->material->passes.end ();
+
+                const auto override = curOverride != endOverride
+                    ? **curOverride
+                    : std::optional<std::reference_wrapper<const ImageEffectPassOverride>> (std::nullopt);
+                const auto target = (*curEffect)->target.has_value ()
+                    ? *(*curEffect)->target
+                    : std::optional<std::reference_wrapper<std::string>> (std::nullopt);
+
+                this->m_passes.push_back (
+                    new CPass (
+                        *this, fboProvider, **curPass, override, (*curEffect)->binds, target)
+                );
+
+                if (curOverride != endOverride) {
+                    curOverride ++;
+                }
+            }
         }
     }
 
-    if (this->m_image->getColorBlendMode () > 0) {
-        Core::Objects::Images::CMaterial::OverrideInfo overrides;
+    if (this->m_image.colorBlendMode > 0) {
+        this->m_materials.colorBlending.material = MaterialParser::load (this->getScene ().getScene ().project, "materials/util/effectpassthrough.json");
+        this->m_materials.colorBlending.override = std::make_unique<ImageEffectPassOverride> (ImageEffectPassOverride {
+            .id = -1,
+            .combos = {
+                {"BLENDMODE", this->m_image.colorBlendMode},
+            },
+            .constants = {},
+            .textures = {},
+        });
 
-        overrides.combos.emplace ("BLENDMODE", this->m_image->getColorBlendMode ());
-        const auto material =
-            Core::Objects::Images::CMaterial::fromFile ("materials/util/effectpassthrough.json", this->getContainer (), false, {}, &overrides);
-
-        // generate the main material used to render the image
-        this->m_colorBlendMaterial = new Effects::CMaterial (
-            new CEffect (
-                this,
-                new Core::Objects::CEffect (
-                    "", "", "", "", this->m_image->getProject (),
-                    Core::UserSettings::CUserSettingBoolean::fromScalar (true), {}, {}, {}
-                )
-            ),
-            material
+        this->m_passes.push_back (
+            new CPass (
+                *this,
+                std::make_shared <CFBOProvider>(this),
+                **this->m_materials.colorBlending.material->passes.begin (),
+                *this->m_materials.colorBlending.override,
+                std::nullopt,
+                std::nullopt
+            )
         );
-
-        // add blendmode to the combos
-        for (const auto& cur : this->m_colorBlendMaterial->getPasses ())
-            this->m_passes.push_back (cur);
     }
 
     // if there's more than one pass the blendmode has to be moved from the beginning to the end
@@ -327,22 +354,24 @@ void CImage::setupPasses () {
         pass->setViewProjectionMatrix (&this->m_viewProjectionMatrix);
 
         // set viewport and target texture if needed
-        if (pass->getMaterial ()->getMaterial ()->hasTarget ()) {
+        if (pass->getTarget ().has_value ()) {
             // setup target texture
-            std::string target = pass->getMaterial ()->getMaterial ()->getTarget ();
-            drawTo = pass->getMaterial ()->getEffect ()->findFBO (target);
+            std::string target = pass->getTarget ().value ();
+            drawTo = pass->getFBOProvider ()->find (target);
             // spacePosition = this->getPassSpacePosition ();
 
             // not a local fbo, try to find a scene fbo with the same name
-            if (drawTo == nullptr)
+            if (drawTo == nullptr) {
                 // this one throws if no fbo was found
-                drawTo = this->getScene ()->findFBO (target);
+                drawTo = this->getScene ().findFBO (target);
+            }
         }
         // determine if it's the last element in the list as this is a screen-copy-like process
-        else if (std::next (cur) == end && this->getImage ()->isVisible ()) {
+        // TODO: PROPERLY CHECK IF THIS IS ALL THAT'S NEEDED
+        else if (std::next (cur) == end && this->getImage ().visible->value->getBool ()) {
             // TODO: PROPERLY CHECK EFFECT'S VISIBILITY AND TAKE IT INTO ACCOUNT
             spacePosition = this->getSceneSpacePosition ();
-            drawTo = this->getScene ()->getFBO ();
+            drawTo = this->getScene ().getFBO ();
             projection = &this->m_modelViewProjectionScreen;
             inverseProjection = &this->m_modelViewProjectionScreenInverse;
         }
@@ -357,7 +386,7 @@ void CImage::setupPasses () {
         texcoord = this->getTexCoordPass ();
         drawTo = prevDrawTo;
 
-        if (!pass->getMaterial ()->getMaterial ()->hasTarget ())
+        if (!pass->getTarget ().has_value ())
             this->pinpongFramebuffer (&drawTo, &asInput);
     }
 }
@@ -387,17 +416,17 @@ void CImage::render () {
 
     // update the position if required
     // TODO: There's more images that are not affected by parallax, autosize or fullscreen are not affected
-    if (this->getScene ()->getScene ()->isCameraParallax () && !this->getImage ()->isFullscreen ())
+    if (this->getScene ().getScene ().camera.parallax.enabled && !this->getImage ().model->fullscreen)
         this->updateScreenSpacePosition ();
 
 #if !NDEBUG
     std::string str = "Rendering ";
 
-    if (this->getScene ()->getScene ()->isBloom () && this->getId () == -1)
+    if (this->getScene ().getScene ().camera.bloom.enabled->value->getBool () && this->getId () == -1)
         str += "bloom";
     else {
-        str += this->getImage ()->getName () + " (" + std::to_string (this->getId ()) + ", " +
-               this->getImage ()->getMaterial ()->getName () + ")";
+        str += this->getImage ().name + " (" + std::to_string (this->getId ()) + ", " +
+               this->getImage ().model->material->filename + ")";
     }
 
     glPushDebugGroup (GL_DEBUG_SOURCE_APPLICATION, 0, -1, str.c_str ());
@@ -421,20 +450,21 @@ void CImage::render () {
 
 void CImage::updateScreenSpacePosition () {
     // do not perform any changes to the image based on the parallax if it was explicitly disabled
-    if (this->getScene ()->getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
+    if (this->getScene ().getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
         return;
     }
 
-    const double parallaxAmount = this->getScene ()->getScene ()->getCameraParallaxAmount ();
-    const glm::vec2 depth = this->getImage ()->getParallaxDepth ();
-    const glm::vec2* displacement = this->getScene ()->getParallaxDisplacement ();
+    const double parallaxAmount = this->getScene ().getScene ().camera.parallax.amount;
+    const glm::vec2 depth = this->getImage ().parallaxDepth;
+    const glm::vec2* displacement = this->getScene ().getParallaxDisplacement ();
 
     float x = (depth.x + parallaxAmount) * displacement->x * this->getSize ().x;
     float y = (depth.y + parallaxAmount) * displacement->y * this->getSize ().x;
 
-    this->m_modelViewProjectionScreen = glm::translate (this->getScene ()->getCamera ()->getProjection () *
-                                                            this->getScene ()->getCamera ()->getLookAt (),
-                                                        {x, y, 0.0f});
+    this->m_modelViewProjectionScreen = glm::translate (
+        this->getScene ().getCamera ().getProjection () * this->getScene ().getCamera ().getLookAt (),
+        {x, y, 0.0f}
+    );
 }
 
 std::shared_ptr<const ITexture> CImage::getTexture () const {
@@ -445,7 +475,7 @@ double CImage::getAnimationTime () const {
     return this->m_animationTime;
 }
 
-const Core::Objects::CImage* CImage::getImage () const {
+const Image& CImage::getImage () const {
     return this->m_image;
 }
 
@@ -459,7 +489,7 @@ const Effects::CMaterial* CImage::getMaterial () const {
 
 glm::vec2 CImage::getSize () const {
     if (this->m_texture == nullptr)
-        return this->getImage ()->getSize ();
+        return this->getImage ().size;
 
     return {this->m_texture->getRealWidth (), this->m_texture->getRealHeight ()};
 }
diff --git a/src/WallpaperEngine/Render/Objects/CImage.h b/src/WallpaperEngine/Render/Objects/CImage.h
index 5003479..877a8bb 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.h
+++ b/src/WallpaperEngine/Render/Objects/CImage.h
@@ -1,10 +1,6 @@
 #pragma once
 
-#include "WallpaperEngine/Core/Objects/CImage.h"
-
 #include "WallpaperEngine/Render/CObject.h"
-#include "WallpaperEngine/Render/Objects/CEffect.h"
-#include "WallpaperEngine/Render/Objects/Effects/CMaterial.h"
 #include "WallpaperEngine/Render/Objects/Effects/CPass.h"
 #include "WallpaperEngine/Render/Wallpapers/CScene.h"
 
@@ -25,16 +21,16 @@ class CPass;
 namespace WallpaperEngine::Render::Objects {
 class CEffect;
 
-class CImage final : public CObject {
+class CImage final : public CObject, public CFBOProvider {
     friend CObject;
 
   public:
-    CImage (Wallpapers::CScene* scene, const Core::Objects::CImage* image);
+    CImage (Wallpapers::CScene& scene, const Image& image);
 
     void setup ();
     void render () override;
 
-    [[nodiscard]] const Core::Objects::CImage* getImage () const;
+    [[nodiscard]] const Image& getImage () const;
     [[nodiscard]] const std::vector<CEffect*>& getEffects () const;
     [[nodiscard]] const Effects::CMaterial* getMaterial () const;
     [[nodiscard]] glm::vec2 getSize () const;
@@ -83,7 +79,7 @@ class CImage final : public CObject {
     std::shared_ptr<const CFBO> m_currentMainFBO = nullptr;
     std::shared_ptr<const CFBO> m_currentSubFBO = nullptr;
 
-    const Core::Objects::CImage* m_image;
+    const Image& m_image;
 
     std::vector<CEffect*> m_effects = {};
     Effects::CMaterial* m_material = nullptr;
@@ -95,5 +91,12 @@ class CImage final : public CObject {
     double m_animationTime = 0.0;
 
     bool m_initialized = false;
+
+    struct {
+        struct {
+            MaterialUniquePtr material;
+            ImageEffectPassOverrideUniquePtr override;
+        } colorBlending;
+    } m_materials;
 };
 } // namespace WallpaperEngine::Render::Objects
diff --git a/src/WallpaperEngine/Render/Objects/CSound.cpp b/src/WallpaperEngine/Render/Objects/CSound.cpp
index 9e17301..0667717 100644
--- a/src/WallpaperEngine/Render/Objects/CSound.cpp
+++ b/src/WallpaperEngine/Render/Objects/CSound.cpp
@@ -4,7 +4,7 @@
 
 using namespace WallpaperEngine::Render::Objects;
 
-CSound::CSound (Wallpapers::CScene* scene, const Core::Objects::CSound* sound) :
+CSound::CSound (Wallpapers::CScene& scene, const Sound& sound) :
     CObject (scene, sound),
     m_sound (sound) {
     if (this->getContext ().getApp ().getContext ().settings.audio.enabled)
@@ -21,19 +21,19 @@ CSound::~CSound() {
 }
 
 void CSound::load () {
-    for (const auto& cur : this->m_sound->getSounds ()) {
+    for (const auto& cur : this->m_sound.sounds) {
         uint32_t filesize = 0;
-        std::shared_ptr<const uint8_t[]> filebuffer = this->getContainer ()->readFile (cur, &filesize);
+        std::shared_ptr<const uint8_t[]> filebuffer = this->getContainer ().readFile (cur, &filesize);
 
-        auto stream = new Audio::CAudioStream (this->getScene ()->getAudioContext (), filebuffer, filesize);
+        auto stream = new Audio::CAudioStream (this->getScene ().getAudioContext (), filebuffer, filesize);
 
-        stream->setRepeat (this->m_sound->isRepeat ());
+        stream->setRepeat (this->m_sound.playbackmode.has_value() && this->m_sound.playbackmode == "loop");
 
         this->m_audioStreams.push_back (stream);
         this->m_soundBuffer.push_back (filebuffer);
 
         // add the stream to the context so it can be played
-        this->getScene ()->getAudioContext ().addStream (stream);
+        this->getScene ().getAudioContext ().addStream (stream);
     }
 }
 
diff --git a/src/WallpaperEngine/Render/Objects/CSound.h b/src/WallpaperEngine/Render/Objects/CSound.h
index 35c0398..c8e3cce 100644
--- a/src/WallpaperEngine/Render/Objects/CSound.h
+++ b/src/WallpaperEngine/Render/Objects/CSound.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "WallpaperEngine/Core/Objects/CSound.h"
-
 #include "WallpaperEngine/Audio/CAudioStream.h"
 #include "WallpaperEngine/Render/CObject.h"
 
@@ -12,9 +10,11 @@ class CScene;
 }
 
 namespace WallpaperEngine::Render::Objects {
+using namespace WallpaperEngine::Data::Model;
+
 class CSound final : public CObject {
   public:
-    CSound (Wallpapers::CScene* scene, const Core::Objects::CSound* sound);
+    CSound (Wallpapers::CScene& scene, const Sound& sound);
     ~CSound () override;
 
     void render () override;
@@ -26,6 +26,6 @@ class CSound final : public CObject {
     std::vector<std::shared_ptr<const uint8_t[]>> m_soundBuffer = {};
     std::vector<Audio::CAudioStream*> m_audioStreams = {};
 
-    const Core::Objects::CSound* m_sound;
+    const Sound& m_sound;
 };
 } // namespace WallpaperEngine::Render::Objects
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CMaterial.cpp b/src/WallpaperEngine/Render/Objects/Effects/CMaterial.cpp
deleted file mode 100644
index 717aab1..0000000
--- a/src/WallpaperEngine/Render/Objects/Effects/CMaterial.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "CMaterial.h"
-
-using namespace WallpaperEngine::Render::Objects;
-
-using namespace WallpaperEngine::Render::Objects::Effects;
-
-CMaterial::CMaterial (const Render::Objects::CEffect* effect, const Core::Objects::Images::CMaterial* material) :
-    Helpers::CContextAware (effect->getImage ()),
-    m_effect (effect),
-    m_material (material) {
-    this->generatePasses ();
-}
-
-const std::vector<CPass*>& CMaterial::getPasses () const {
-    return this->m_passes;
-}
-
-CImage* CMaterial::getImage () const {
-    return this->m_effect->getImage ();
-}
-
-void CMaterial::generatePasses () {
-    // these are simple now, just create the entries and done
-    for (const auto& cur : this->m_material->getPasses ())
-        this->m_passes.emplace_back (new CPass (this, cur));
-}
-
-const Core::Objects::Images::CMaterial* CMaterial::getMaterial () const {
-    return this->m_material;
-}
-
-const CEffect* CMaterial::getEffect () const {
-    return this->m_effect;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CMaterial.h b/src/WallpaperEngine/Render/Objects/Effects/CMaterial.h
deleted file mode 100644
index 6fe5642..0000000
--- a/src/WallpaperEngine/Render/Objects/Effects/CMaterial.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/CEffect.h"
-#include "WallpaperEngine/Core/Objects/Images/CMaterial.h"
-
-#include "WallpaperEngine/Render/Objects/CEffect.h"
-#include "WallpaperEngine/Render/Objects/Effects/CPass.h"
-
-#include "WallpaperEngine/Render/Helpers/CContextAware.h"
-
-#include "CPass.h"
-
-using namespace WallpaperEngine;
-
-namespace WallpaperEngine::Render::Objects {
-class CEffect;
-class CImage;
-} // namespace WallpaperEngine::Render::Objects
-
-namespace WallpaperEngine::Render::Objects::Effects {
-class CPass;
-
-class CMaterial final : public Helpers::CContextAware {
-    friend class CPass;
-
-  public:
-    CMaterial (const Render::Objects::CEffect* effect, const Core::Objects::Images::CMaterial* material);
-
-    [[nodiscard]] const std::vector<CPass*>& getPasses () const;
-    [[nodiscard]] CImage* getImage () const;
-    [[nodiscard]] const Core::Objects::Images::CMaterial* getMaterial () const;
-    [[nodiscard]] const CEffect* getEffect () const;
-
-  private:
-    void generatePasses ();
-
-    const Render::Objects::CEffect* m_effect;
-    const Core::Objects::Images::CMaterial* m_material;
-
-    std::vector<CPass*> m_passes = {};
-};
-} // namespace WallpaperEngine::Render::Objects::Effects
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index dba9467..dc604b3 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -1,8 +1,15 @@
 #include "CPass.h"
-#include "WallpaperEngine/Render/CFBO.h"
 #include <sstream>
 #include <utility>
 
+#include "WallpaperEngine/Render/Helpers/CContextAware.h"
+
+#include "WallpaperEngine/Data/Model/Effect.h"
+#include "WallpaperEngine/Data/Model/Material.h"
+
+#include "WallpaperEngine/Render/Objects/CImage.h"
+#include "WallpaperEngine/Render/CFBO.h"
+
 #include "WallpaperEngine/Core/Projects/CProperty.h"
 #include "WallpaperEngine/Core/Projects/CPropertyColor.h"
 #include "WallpaperEngine/Core/Projects/CPropertyCombo.h"
@@ -25,19 +32,35 @@
 #include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h"
 #include "WallpaperEngine/Logging/CLog.h"
 
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-using namespace WallpaperEngine::Render::Shaders::Variables;
+using namespace WallpaperEngine;
+using namespace WallpaperEngine::Render;
+using namespace WallpaperEngine::Render::Objects;
 
+using namespace WallpaperEngine::Core::Objects::Effects::Constants;
+
+using namespace WallpaperEngine::Render::Shaders::Variables;
 using namespace WallpaperEngine::Render::Objects::Effects;
 
 extern float g_Time;
 extern float g_Daytime;
 
-CPass::CPass (CMaterial* material, const Core::Objects::Images::Materials::CPass* pass) :
-    Helpers::CContextAware (material),
-    m_material (material),
+const TextureMap DEFAULT_BINDS = {};
+const ImageEffectPassOverride DEFAULT_OVERRIDE = {};
+
+CPass::CPass (
+    CImage& image, std::shared_ptr<const CFBOProvider> fboProvider, const MaterialPass& pass,
+    std::optional<std::reference_wrapper<const ImageEffectPassOverride>> override,
+    std::optional<std::reference_wrapper<const TextureMap>> binds,
+    std::optional<std::reference_wrapper<std::string>> target
+) :
+    Helpers::CContextAware (image),
+    m_image (image),
     m_pass (pass),
-    m_blendingmode (pass->getBlendingMode ()) {
+    m_blendingmode (pass.blending),
+    m_binds (binds.has_value () ? binds.value ().get () : DEFAULT_BINDS),
+    m_override (override.has_value () ? override.value ().get () : DEFAULT_OVERRIDE),
+    m_fboProvider (fboProvider),
+    m_target (target) {
     this->setupShaders ();
     this->setupShaderVariables ();
 }
@@ -51,25 +74,21 @@ std::shared_ptr<const ITexture> CPass::resolveTexture (std::shared_ptr<const ITe
     }
 
     // first check in the binds and replace it if necessary
-    const auto it = this->m_material->getMaterial ()->getTextureBinds ().find (index);
+    const auto it = this->m_binds.find (index);
 
-    if (it == this->m_material->getMaterial ()->getTextureBinds ().end ())
+    if (it == this->m_binds.end ())
         return expected;
 
     // a bind named "previous" is just another way of telling it to use whatever texture there was already
-    if (it->second->getName () == "previous")
+    if (it->second == "previous")
         return previous ?: expected;
 
     // the bind actually has a name, search the FBO in the effect and return it
-    return this->resolveFBO (it->second->getName ());
+    return this->resolveFBO (it->second);
 }
 
 std::shared_ptr<const CFBO> CPass::resolveFBO (const std::string& name) const {
-    auto fbo = this->m_material->getEffect()->findFBO (name);
-
-    if (fbo == nullptr) {
-        fbo = this->m_material->getImage ()->getScene ()->findFBO (name);
-    }
+    auto fbo = this->m_fboProvider->find (name);
 
     if (fbo == nullptr) {
         sLog.exception ("Tried to resolve and FBO without any luck: ", name);
@@ -100,19 +119,19 @@ void CPass::setupRenderFramebuffer () {
     }
 
     // set depth testing
-    if (this->m_pass->getDepthTest () == "disabled") {
+    if (this->m_pass.depthtest == "disabled") {
         glDisable (GL_DEPTH_TEST);
     } else {
         glEnable (GL_DEPTH_TEST);
     }
 
-    if (this->m_pass->getCullingMode () == "nocull") {
+    if (this->m_pass.cullmode == "nocull") {
         glDisable (GL_CULL_FACE);
     } else {
         glEnable (GL_CULL_FACE);
     }
 
-    if (this->m_pass->getDepthWrite () == "disabled") {
+    if (this->m_pass.depthwrite == "disabled") {
         glDepthMask (false);
     } else {
         glDepthMask (true);
@@ -133,7 +152,7 @@ void CPass::setupRenderTexture () {
     if (texture->isAnimated ()) {
         // calculate current texture and frame
         double currentRenderTime = fmod (static_cast<double> (this->getContext ().getDriver ().getRenderTime ()),
-                                         this->m_material->getImage ()->getAnimationTime ());
+                                         this->m_image.getAnimationTime ());
 
         for (const auto& frameCur : texture->getFrames ()) {
             currentRenderTime -= frameCur->frametime;
@@ -246,8 +265,8 @@ void CPass::setupRenderAttributes () {
 
 #if !NDEBUG
         glObjectLabel (GL_BUFFER, *cur->value, -1,
-                       ("Image " + std::to_string (this->getMaterial ()->getImage ()->getId ()) + " Pass " +
-                        this->m_pass->getShader () + " " + cur->name)
+                       ("Image " + std::to_string (this->m_image.getId ()) + " Pass " +
+                        this->m_pass.shader + " " + cur->name)
                            .c_str ());
 #endif /* DEBUG */
     }
@@ -287,8 +306,12 @@ void CPass::render () {
     this->cleanupRenderSetup ();
 }
 
-const CMaterial* CPass::getMaterial () const {
-    return this->m_material;
+std::shared_ptr<const CFBOProvider> CPass::getFBOProvider () const {
+    return this->m_fboProvider;
+}
+
+const CImage& CPass::getImage () const {
+    return this->m_image;
 }
 
 void CPass::setDestination (std::shared_ptr<const CFBO> drawTo) {
@@ -331,10 +354,14 @@ void CPass::setPosition (GLuint position) {
     this->a_Position = position;
 }
 
-const Core::Objects::Images::Materials::CPass* CPass::getPass () const {
+const MaterialPass& CPass::getPass () const {
     return this->m_pass;
 }
 
+const std::optional<std::reference_wrapper<std::string>> CPass::getTarget () const {
+    return this->m_target;
+}
+
 Render::Shaders::CShader* CPass::getShader () const {
     return this->m_shader;
 }
@@ -379,10 +406,10 @@ GLuint CPass::compileShader (const char* shader, GLuint type) {
 
 void CPass::setupShaders () {
     // ensure the constants are defined
-    std::shared_ptr<const ITexture> texture0 = this->m_material->getImage ()->getTexture ();
+    std::shared_ptr<const ITexture> texture0 = this->m_image.getTexture ();
 
     // copy the combos from the pass
-    this->m_combos.insert (this->m_pass->getCombos ().begin (), this->m_pass->getCombos ().end ());
+    this->m_combos.insert (this->m_pass.combos.begin (), this->m_pass.combos.end ());
 
     // TODO: THE VALUES ARE THE SAME AS THE ENUMERATION, SO MAYBE IT HAS TO BE SPECIFIED FOR THE TEXTURE 0 OF ALL
     // ELEMENTS?
@@ -398,8 +425,8 @@ void CPass::setupShaders () {
     // TODO: USED TO BUILD THE TEXTURES LATER
     // use the combos copied from the pass so it includes the texture format
     this->m_shader = new Render::Shaders::CShader (
-        this->getMaterial ()->getImage ()->getContainer (), this->m_pass->getShader (), this->m_combos,
-        this->m_pass->getTextures (), this->m_pass->getConstants ()
+        this->m_image.getContainer (), this->m_pass.shader, this->m_combos,
+        this->m_pass.textures, this->m_override.constants
     );
 
     const auto shaders = Shaders::CGLSLContext::get ().toGlsl (
@@ -441,9 +468,9 @@ void CPass::setupShaders () {
     }
 
 #if !NDEBUG
-    glObjectLabel (GL_PROGRAM, this->m_programID, -1, this->m_pass->getShader ().c_str ());
-    glObjectLabel (GL_SHADER, vertexShaderID, -1, (this->m_pass->getShader () + ".vert").c_str ());
-    glObjectLabel (GL_SHADER, fragmentShaderID, -1, (this->m_pass->getShader () + ".frag").c_str ());
+    glObjectLabel (GL_PROGRAM, this->m_programID, -1, this->m_pass.shader.c_str ());
+    glObjectLabel (GL_SHADER, vertexShaderID, -1, (this->m_pass.shader + ".vert").c_str ());
+    glObjectLabel (GL_SHADER, fragmentShaderID, -1, (this->m_pass.shader + ".frag").c_str ());
 #endif /* DEBUG */
 
     // after being liked shaders can be dettached and deleted
@@ -507,7 +534,7 @@ void CPass::setupTextureUniforms () {
         }
     }
 
-    for (const auto& [index, textureName] : this->m_pass->getTextures ()) {
+    for (const auto& [index, textureName] : this->m_pass.textures) {
         // ignore first texture as that'll be the input of the previous pass (or the image if it's the first pass)
         if (index == 0) {
             continue;
@@ -516,23 +543,23 @@ void CPass::setupTextureUniforms () {
         if (textureName.find ("_rt_") == 0) {
             this->m_textures[index] = this->resolveFBO (textureName);
         } else if (!textureName.empty ()) {
-            this->m_textures[index] = this->m_material->getImage ()->getContext ().resolveTexture (textureName);
+            this->m_textures[index] = this->m_image.getContext ().resolveTexture (textureName);
         }
     }
 
     // binds are set last as they're the most important to be set
-    for (const auto& [index, bind] : this->m_material->getMaterial ()->getTextureBinds ()) {
-        if (bind->getName () == "previous") {
+    for (const auto& [index, bind] : this->m_binds) {
+        if (bind == "previous") {
             // use nullptr as indication for "previous" texture
             this->m_textures [index] = nullptr;
         } else {
             // a normal bind, search for the corresponding FBO and set it
-            this->m_textures [index] = this->resolveFBO (bind->getName ());
+            this->m_textures [index] = this->resolveFBO (bind);
         }
     }
 
     // resolve the main texture
-    std::shared_ptr<const ITexture> texture = this->resolveTexture (this->m_material->getImage ()->getTexture (), 0);
+    std::shared_ptr<const ITexture> texture = this->resolveTexture (this->m_image.getTexture (), 0);
     // register all the texture uniforms with correct values
     this->addUniform ("g_Texture0", 0);
     this->addUniform ("g_Texture1", 1);
@@ -557,21 +584,22 @@ void CPass::setupTextureUniforms () {
 void CPass::setupUniforms () {
     this->setupTextureUniforms ();
 
-    const auto projection = this->getMaterial ()->getImage ()->getScene ()->getScene ()->getOrthogonalProjection ();
+    const auto& image = this->m_image.getImage ();
+    const auto& scene = this->m_image.getScene ();
+    const auto& sceneData = this->m_image.getScene ().getScene ();
+    const auto& recorder = this->m_image.getScene ().getAudioContext ().getRecorder ();
 
     // lighting variables
-    this->addUniform ("g_LightAmbientColor",
-                      this->m_material->getImage ()->getScene ()->getScene ()->getAmbientColor ());
-    this->addUniform ("g_LightSkylightColor",
-                      this->m_material->getImage ()->getScene ()->getScene ()->getSkylightColor ());
+    this->addUniform ("g_LightAmbientColor", sceneData.colors.ambient);
+    this->addUniform ("g_LightSkylightColor", sceneData.colors.skylight);
     // register variables like brightness and alpha with some default value
-    this->addUniform ("g_Brightness", this->m_material->getImage ()->getImage ()->getBrightness ());
-    this->addUniform ("g_UserAlpha", this->m_material->getImage ()->getImage ()->getAlpha ());
-    this->addUniform ("g_Alpha", this->m_material->getImage ()->getImage ()->getAlpha ());
-    this->addUniform ("g_Color", this->m_material->getImage ()->getImage ()->getColor ());
-    this->addUniform ("g_Color4", glm::vec4 (this->m_material->getImage ()->getImage ()->getColor (), 1));
+    this->addUniform ("g_Brightness", image.brightness);
+    this->addUniform ("g_UserAlpha", image.alpha->value->getFloat ());
+    this->addUniform ("g_Alpha", image.alpha->value->getFloat ());
+    this->addUniform ("g_Color", image.color->value->getVec3 ());
+    this->addUniform ("g_Color4", image.color->value->getVec4());
     // TODO: VALIDATE THAT G_COMPOSITECOLOR REALLY COMES FROM THIS ONE
-    this->addUniform ("g_CompositeColor", this->m_material->getImage ()->getImage ()->getColor ());
+    this->addUniform ("g_CompositeColor", image.color->value->getVec3 ());
     // add some external variables
     this->addUniform ("g_Time", &g_Time);
     this->addUniform ("g_Daytime", &g_Daytime);
@@ -581,24 +609,18 @@ void CPass::setupUniforms () {
     this->addUniform ("g_ModelMatrix", &this->m_modelMatrix);
     this->addUniform ("g_NormalModelMatrix", glm::identity<glm::mat3> ());
     this->addUniform ("g_ViewProjectionMatrix", &this->m_viewProjectionMatrix);
-    this->addUniform ("g_PointerPosition", this->m_material->getImage ()->getScene ()->getMousePosition ());
-    this->addUniform ("g_PointerPositionLast", this->m_material->getImage ()->getScene ()->getMousePositionLast ());
+    this->addUniform ("g_PointerPosition", scene.getMousePosition ());
+    this->addUniform ("g_PointerPositionLast", scene.getMousePositionLast ());
     this->addUniform ("g_EffectTextureProjectionMatrix", glm::mat4 (1.0));
     this->addUniform ("g_EffectTextureProjectionMatrixInverse", glm::mat4 (1.0));
-    this->addUniform ("g_TexelSize", glm::vec2 (1.0 / projection->getWidth (), 1.0 / projection->getHeight ()));
-    this->addUniform ("g_TexelSizeHalf", glm::vec2 (0.5 / projection->getWidth (), 0.5 / projection->getHeight ()));
-    this->addUniform ("g_AudioSpectrum16Left",
-                      this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio16, 16);
-    this->addUniform ("g_AudioSpectrum16Right",
-                      this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio16, 16);
-    this->addUniform ("g_AudioSpectrum32Left",
-                      this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio32, 32);
-    this->addUniform ("g_AudioSpectrum32Right",
-                      this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio32, 32);
-    this->addUniform ("g_AudioSpectrum64Left",
-                      this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio64, 64);
-    this->addUniform ("g_AudioSpectrum64Right",
-                      this->getMaterial ()->getImage ()->getScene ()->getAudioContext ().getRecorder ().audio64, 64);
+    this->addUniform ("g_TexelSize", glm::vec2 (1.0 / scene.getWidth (), 1.0 / scene.getHeight ()));
+    this->addUniform ("g_TexelSizeHalf", glm::vec2 (0.5 / scene.getWidth (), 0.5 / scene.getHeight ()));
+    this->addUniform ("g_AudioSpectrum16Left", recorder.audio16, 16);
+    this->addUniform ("g_AudioSpectrum16Right", recorder.audio16, 16);
+    this->addUniform ("g_AudioSpectrum32Left", recorder.audio32, 32);
+    this->addUniform ("g_AudioSpectrum32Right", recorder.audio32, 32);
+    this->addUniform ("g_AudioSpectrum64Left", recorder.audio64, 64);
+    this->addUniform ("g_AudioSpectrum64Right", recorder.audio64, 64);
 }
 
 void CPass::addAttribute (const std::string& name, GLint type, GLint elements, const GLuint* value) {
@@ -680,7 +702,7 @@ void CPass::setupShaderVariables () {
             this->addUniform (cur);
 
     // find variables in the shaders and set the value with the constants if possible
-    for (const auto& [name, value] : this->m_pass->getConstants ()) {
+    for (const auto& [name, value] : this->m_override.constants) {
         const auto parameters = this->m_shader->findParameter (name);
 
         // variable not found, can be ignored
@@ -692,7 +714,7 @@ void CPass::setupShaderVariables () {
 
         // this takes care of all possible casts, even invalid ones, which will use whatever default behaviour
         // of the underlying CDynamicValue used for the value
-        this->addUniform (var, value);
+        this->addUniform (var, value.get ());
     }
 }
 
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.h b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
index e3dbe5a..e853b41 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.h
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
@@ -5,25 +5,31 @@
 
 #include "WallpaperEngine/Assets/ITexture.h"
 #include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-#include "WallpaperEngine/Core/Objects/Images/Materials/CPass.h"
+#include "WallpaperEngine/Core/UserSettings/CUserSettingValue.h"
 #include "WallpaperEngine/Render/CFBO.h"
-#include "WallpaperEngine/Render/Objects/Effects/CMaterial.h"
+#include "WallpaperEngine/Render/CFBOProvider.h"
+#include "WallpaperEngine/Render/Helpers/CContextAware.h"
 #include "WallpaperEngine/Render/Shaders/CShader.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingValue.h"
-#include "WallpaperEngine/Render/Helpers/CContextAware.h"
+
+namespace WallpaperEngine::Render::Objects {
+class CImage;
+}
 
 namespace WallpaperEngine::Render::Objects::Effects {
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Render::Shaders::Variables;
 using namespace WallpaperEngine::Core::Projects;
 using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-class CMaterial;
+using namespace WallpaperEngine::Data::Model;
 
 class CPass final : public Helpers::CContextAware {
   public:
-    CPass (CMaterial* material, const Core::Objects::Images::Materials::CPass* pass);
+    CPass (
+        CImage& image, std::shared_ptr<const CFBOProvider> fboProvider, const MaterialPass& pass,
+        std::optional<std::reference_wrapper<const ImageEffectPassOverride>> override,
+        std::optional<std::reference_wrapper<const TextureMap>> binds,
+        std::optional<std::reference_wrapper<std::string>> target);
 
     void render ();
 
@@ -39,8 +45,10 @@ class CPass final : public Helpers::CContextAware {
     [[nodiscard]] const std::string& getBlendingMode () const;
     [[nodiscard]] std::shared_ptr<const CFBO> resolveFBO (const std::string& name) const;
 
-    [[nodiscard]] const CMaterial* getMaterial () const;
-    [[nodiscard]] const Core::Objects::Images::Materials::CPass* getPass () const;
+    [[nodiscard]] std::shared_ptr<const CFBOProvider> getFBOProvider () const;
+    [[nodiscard]] const CImage& getImage () const;
+    [[nodiscard]] const MaterialPass& getPass () const;
+    [[nodiscard]] const std::optional<std::reference_wrapper<std::string>> getTarget () const;
     [[nodiscard]] Render::Shaders::CShader* getShader () const;
 
   private:
@@ -148,8 +156,12 @@ class CPass final : public Helpers::CContextAware {
 
     std::shared_ptr<const ITexture> resolveTexture (std::shared_ptr<const ITexture> expected, int index, std::shared_ptr<const ITexture> previous = nullptr);
 
-    CMaterial* m_material = nullptr;
-    const Core::Objects::Images::Materials::CPass* m_pass;
+    CImage& m_image;
+    std::shared_ptr<const CFBOProvider> m_fboProvider;
+    const MaterialPass& m_pass;
+    const TextureMap& m_binds;
+    const ImageEffectPassOverride& m_override;
+    std::optional<std::reference_wrapper<std::string>> m_target;
     std::map<int, std::shared_ptr<const CFBO>> m_fbos = {};
     std::map<std::string, int> m_combos = {};
     std::vector<AttribEntry*> m_attribs = {};
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.cpp b/src/WallpaperEngine/Render/Shaders/CShader.cpp
index 3df9888..44ad97d 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShader.cpp
@@ -18,17 +18,18 @@ using namespace WallpaperEngine::Assets;
 
 namespace WallpaperEngine::Render::Shaders {
 CShader::CShader (
-    std::shared_ptr<const CContainer> container, std::string filename, const std::map<std::string, int>& combos,
-    const std::map<int, std::string>& textures, const std::map<std::string, const CShaderConstant*>& constants
+    const CContainer& container, std::string filename,
+    const ComboMap& combos, const TextureMap& textures,
+    const ShaderConstantMap& constants
 ) :
     m_file (std::move (filename)),
     m_combos (combos),
     m_passTextures (textures),
     m_vertex (
-        CGLSLContext::UnitType_Vertex, filename, container->readVertexShader (filename),
+        CGLSLContext::UnitType_Vertex, filename, container.readVertexShader (filename),
         container, constants, textures, combos),
     m_fragment (
-        CGLSLContext::UnitType_Fragment, filename, container->readFragmentShader (filename),
+        CGLSLContext::UnitType_Fragment, filename, container.readFragmentShader (filename),
         container, constants, textures, combos) {
     // link shaders between them
     this->m_vertex.linkToUnit (&this->m_fragment);
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.h b/src/WallpaperEngine/Render/Shaders/CShader.h
index f332daa..4ca3445 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.h
+++ b/src/WallpaperEngine/Render/Shaders/CShader.h
@@ -13,10 +13,13 @@
 #include "CShaderUnit.h"
 #include "CGLSLContext.h"
 
+#include "WallpaperEngine/Data/Model/Types.h"
+
 namespace WallpaperEngine::Render::Shaders {
 using json = nlohmann::json;
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Core::Objects::Effects::Constants;
+using namespace WallpaperEngine::Data::Model;
 
 /**
  * A basic shader loader that adds basic function definitions to every loaded shader
@@ -42,9 +45,9 @@ class CShader {
      * @param recursive Whether the compiler should add base definitions or not
      */
     CShader (
-        std::shared_ptr<const CContainer> container, std::string filename,
-        const std::map<std::string, int>& combos, const std::map<int, std::string>& textures,
-        const std::map<std::string, const CShaderConstant*>& constants);
+        const CContainer& container, std::string filename,
+        const ComboMap& combos, const TextureMap& textures,
+        const ShaderConstantMap& constants);
     /**
      * @return The vertex's shader coude for OpenGL to use
      */
@@ -93,10 +96,10 @@ class CShader {
     /**
      * The combos the shader should be generated with
      */
-    const std::map<std::string, int>& m_combos;
+    const ComboMap& m_combos;
     /**
      * The list of textures the pass knows about
      */
-    const std::map<int, std::string> m_passTextures;
+    const TextureMap m_passTextures;
 };
 } // namespace WallpaperEngine::Render::Shaders
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index a4cc72b..8c49614 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -56,13 +56,12 @@ using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Render::Shaders;
 
 CShaderUnit::CShaderUnit (
-    CGLSLContext::UnitType type, std::string file, std::string content, std::shared_ptr<const CContainer> container,
-    const std::map<std::string, const CShaderConstant*>& constants, const std::map<int, std::string>& passTextures,
-    const std::map<std::string, int>& combos
+    CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
+    const ShaderConstantMap& constants, const TextureMap& passTextures, const ComboMap& combos
 ) :
     m_type (type),
     m_link (nullptr),
-    m_container (std::move(container)),
+    m_container (container),
     m_file (std::move (file)),
     m_constants (constants),
     m_content (std::move(content)),
@@ -155,7 +154,7 @@ void CShaderUnit::preprocessIncludes () {
             content += "// begin of include from file ";
             content += filename;
             content += "\n";
-            content += this->m_container->readIncludeShader (filename);
+            content += this->m_container.readIncludeShader (filename);
             content += "\n// end of included from file ";
             content += filename;
             content += "\n";
@@ -194,7 +193,7 @@ void CShaderUnit::preprocessIncludes () {
             content = "// begin of include from file ";
             content += filename;
             content += "\n";
-            content += this->m_container->readIncludeShader (filename);
+            content += this->m_container.readIncludeShader (filename);
             content += "\n// end of included from file ";
             content += filename;
             content += "\n";
@@ -382,6 +381,7 @@ void CShaderUnit::parseParameterConfiguration (
 
     // TODO: SUPPORT VALUES FOR ALL THESE TYPES
     // TODO: MAYBE EVEN CONNECT THESE TO THE CORRESPONDING PROPERTY SO THINGS ARE UPDATED AS THE ORIGIN VALUES CHANGE?
+    // TODO: MAKE USE OF PARSERS INSTEAD OF CORE
     if (type == "vec4") {
         parameter = new Variables::CShaderVariableVector4 (WallpaperEngine::Core::aToVector4 (*defvalue));
     } else if (type == "vec3") {
@@ -500,11 +500,11 @@ void CShaderUnit::parseParameterConfiguration (
     }
 }
 
-const std::map<std::string, int>& CShaderUnit::getCombos () const {
+const ComboMap& CShaderUnit::getCombos () const {
     return this->m_combos;
 }
 
-const std::map<std::string, int>& CShaderUnit::getDiscoveredCombos () const {
+const ComboMap& CShaderUnit::getDiscoveredCombos () const {
     return this->m_discoveredCombos;
 }
 
@@ -565,6 +565,6 @@ const std::string& CShaderUnit::compile () {
 const std::vector<Variables::CShaderVariable*>& CShaderUnit::getParameters () const {
     return this->m_parameters;
 }
-const std::map<int, std::string>& CShaderUnit::getTextures () const {
+const TextureMap& CShaderUnit::getTextures () const {
     return this->m_defaultTextures;
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
index 2c13e09..97f6713 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
@@ -11,19 +11,23 @@
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
 #include "nlohmann/json.hpp"
 
+#include "WallpaperEngine/Data/Model/Types.h"
+
 namespace WallpaperEngine::Render::Shaders {
 using json = nlohmann::json;
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Core::Objects::Effects::Constants;
+using namespace WallpaperEngine::Data::Model;
+
 /**
  * Represents a whole shader unit
  */
 class CShaderUnit {
   public:
     CShaderUnit (
-        CGLSLContext::UnitType type, std::string file, std::string content, std::shared_ptr<const CContainer> container,
-        const std::map<std::string, const CShaderConstant*>& constants, const std::map<int, std::string>& passTextures,
-        const std::map<std::string, int>& combos);
+        CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
+        const ShaderConstantMap& constants, const TextureMap& passTextures,
+        const ComboMap& combos);
     ~CShaderUnit () = default;
 
     /**
@@ -49,15 +53,15 @@ class CShaderUnit {
     /**
      * @return The textures this shader unit requires
      */
-    [[nodiscard]] const std::map<int, std::string>& getTextures () const;
+    [[nodiscard]] const TextureMap& getTextures () const;
     /**
      * @return The combos set for this shader unit by the configuration
      */
-    [[nodiscard]] const std::map<std::string, int>& getCombos () const;
+    [[nodiscard]] const ComboMap& getCombos () const;
     /**
      * @return Other combos detected by this shader unit during the preprocess
      */
-    [[nodiscard]] const std::map<std::string, int>& getDiscoveredCombos () const;
+    [[nodiscard]] const ComboMap& getDiscoveredCombos () const;
 
   protected:
     /**
@@ -127,11 +131,11 @@ class CShaderUnit {
     /**
      * Pre-defined values for the combos
      */
-    const std::map<std::string, int>& m_combos;
+    const ComboMap& m_combos;
     /**
      * The combos discovered in the pre-processing step that were not in the combos list
      */
-    std::map<std::string, int> m_discoveredCombos = {};
+    ComboMap m_discoveredCombos = {};
     /**
      * The combos used by this unit that should be added
      */
@@ -139,11 +143,11 @@ class CShaderUnit {
     /**
      * The constants defined for this unit
      */
-    const std::map<std::string, const CShaderConstant*>& m_constants;
+    const ShaderConstantMap& m_constants;
     /** The textures that are already applied to this shader */
-    const std::map<int, std::string> m_passTextures;
+    const TextureMap m_passTextures = {};
     /** The default textures to use when a texture is not applied in a given slot */
-    std::map<int, std::string> m_defaultTextures = {};
+    TextureMap m_defaultTextures = {};
     /**
      * The shader unit this unit is linked to
      */
@@ -151,6 +155,6 @@ class CShaderUnit {
     /**
      * The container to source files from
      */
-    const std::shared_ptr<const CContainer> m_container;
+    const CContainer& m_container;
 };
 }
diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
index d268012..6f1b58e 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
@@ -1,6 +1,3 @@
-#include "WallpaperEngine/Core/Objects/CImage.h"
-#include "WallpaperEngine/Core/Objects/CSound.h"
-
 #include "WallpaperEngine/Render/Objects/CImage.h"
 #include "WallpaperEngine/Render/Objects/CSound.h"
 
@@ -9,58 +6,59 @@
 #include "CScene.h"
 #include "WallpaperEngine/Logging/CLog.h"
 
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Data/Parsers/ObjectParser.h"
+
 extern float g_Time;
 extern float g_TimeLast;
 
 using namespace WallpaperEngine;
 using namespace WallpaperEngine::Render;
+using namespace WallpaperEngine::Data::Model;
+using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Render::Wallpapers;
 
 CScene::CScene (
-    std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
+    const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
     const CWallpaperState::TextureUVsScaling& scalingMode,
     const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
 ) :
     CWallpaper (wallpaper, context, audioContext, scalingMode, clampMode) {
     // caller should check this, if not a std::bad_cast is good to throw
-    const auto& scene = wallpaper->as <Core::Wallpapers::CScene> ();
+    auto scene = wallpaper.as <Scene> ();
+
     // setup the scene camera
-    this->m_camera = new CCamera (this, scene->getCamera ());
+    this->m_camera = std::make_unique<CCamera> (*this, scene->camera);
+
+    float width = scene->camera.projection.width;
+    float height = scene->camera.projection.height;
 
     // detect size if the orthogonal project is auto
-    if (scene->getOrthogonalProjection ()->isAuto ()) {
-        // calculate the size of the projection based on the size of everything
-        for (const auto& [id, sceneObject] : scene->getObjects ()) {
-            if (!sceneObject->is<Core::Objects::CImage> ())
-                continue;
-
-            const glm::vec2 size = sceneObject->as<Core::Objects::CImage> ()->getSize ();
-
-            scene->getOrthogonalProjection ()->setWidth (size.x);
-            scene->getOrthogonalProjection ()->setHeight (size.y);
-        }
+    if (scene->camera.projection.isAuto) {
+        // TODO: CALCULATE ORTHOGONAL PROJECTION BASED ON CONTENT'S SIZE HERE
     }
 
     this->m_parallaxDisplacement = {0, 0};
 
-    this->m_camera->setOrthogonalProjection (scene->getOrthogonalProjection ()->getWidth (),
-                                             scene->getOrthogonalProjection ()->getHeight ());
+    // TODO: CONVERSION
+    this->m_camera->setOrthogonalProjection (width, height);
 
     // setup framebuffers here as they're required for the scene setup
     this->setupFramebuffers ();
 
     // set clear color
-    const glm::vec3 clearColor = this->getScene ()->getClearColor ();
+    // TODO: MAKE USE OF THE REFERENCE POSSIBILITIES?!
+    const glm::vec3 clearColor = scene->colors.clear->value->getVec3 ();
 
     glClearColor (clearColor.r, clearColor.g, clearColor.b, 1.0f);
 
     // create all objects based off their dependencies
-    for (const auto& [id, sceneObject] : scene->getObjects ())
-        this->createObject (sceneObject);
+    for (const auto& object : scene->objects)
+        this->createObject (*object);
 
     // copy over objects by render order
-    for (const auto& cur : scene->getObjectsByRenderOrder ()) {
-        auto obj = this->m_objects.find (cur->getId ());
+    for (const auto& cur : scene->objects) {
+        auto obj = this->m_objects.find (cur->id);
 
         // ignores not created objects like particle systems
         if (obj == this->m_objects.end ())
@@ -69,18 +67,18 @@ CScene::CScene (
         this->m_objectsByRenderOrder.emplace_back (obj->second);
     }
 
-    const uint32_t sceneWidth = scene->getOrthogonalProjection ()->getWidth ();
-    const uint32_t sceneHeight = scene->getOrthogonalProjection ()->getHeight ();
+    const uint32_t sceneWidth = this->m_camera->getWidth ();
+    const uint32_t sceneHeight = this->m_camera->getHeight ();
 
     // create extra framebuffers for the bloom effect
     this->_rt_4FrameBuffer =
-        this->createFBO ("_rt_4FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
-                         sceneWidth / 4, sceneHeight / 4, sceneWidth / 4, sceneHeight / 4);
+        this->create ("_rt_4FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
+                      {sceneWidth / 4, sceneHeight / 4}, {sceneWidth / 4, sceneHeight / 4});
     this->_rt_8FrameBuffer =
-        this->createFBO ("_rt_8FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
-                         sceneWidth / 8, sceneHeight / 8, sceneWidth / 8, sceneHeight / 8);
-    this->_rt_Bloom = this->createFBO ("_rt_Bloom", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs,
-                                       1.0, sceneWidth / 8, sceneHeight / 8, sceneWidth / 8, sceneHeight / 8);
+        this->create ("_rt_8FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
+                      {sceneWidth / 8, sceneHeight / 8}, {sceneWidth / 8, sceneHeight / 8});
+    this->_rt_Bloom = this->create ("_rt_Bloom", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs,
+                                       1.0, {sceneWidth / 8, sceneHeight / 8}, {sceneWidth / 8, sceneHeight / 8});
 
     //
     // Had to get a little creative with the effects to achieve the same bloom effect without any custom code
@@ -89,6 +87,7 @@ CScene::CScene (
     // (it renders directly to the screen, whereas here we never do that from a scene)
     //
 
+    // TODO: TAKE THIS OUT OF HERE AND INTO THE GENERAL WALLPAPER APPLICATION?!
     const std::string imagejson = "{"
                                   "\t\"image\": \"models/wpenginelinux.json\","
                                   "\t\"name\": \"bloomimagewpenginelinux\","
@@ -112,30 +111,30 @@ CScene::CScene (
                                   "\t\t\t\t\t\"constantshadervalues\":"
                                   "\t\t\t\t\t{"
                                   "\t\t\t\t\t\t\"bloomstrength\": " +
-                                  std::to_string (this->getScene ()->getBloomStrength ()) +
+                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
                                   ","
                                   "\t\t\t\t\t\t\"bloomthreshold\": " +
-                                  std::to_string (this->getScene ()->getBloomThreshold ()) +
+                                  std::to_string (this->getScene ().camera.bloom.threshold->value->getFloat ()) +
                                   "\t\t\t\t\t}"
                                   "\t\t\t\t},"
                                   "\t\t\t\t{"
                                   "\t\t\t\t\t\"constantshadervalues\":"
                                   "\t\t\t\t\t{"
                                   "\t\t\t\t\t\t\"bloomstrength\": " +
-                                  std::to_string (this->getScene ()->getBloomStrength ()) +
+                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
                                   ","
                                   "\t\t\t\t\t\t\"bloomthreshold\": " +
-                                  std::to_string (this->getScene ()->getBloomThreshold ()) +
+                                  std::to_string (this->getScene ().camera.bloom.threshold->value->getFloat ()) +
                                   "\t\t\t\t\t}"
                                   "\t\t\t\t},"
                                   "\t\t\t\t{"
                                   "\t\t\t\t\t\"constantshadervalues\":"
                                   "\t\t\t\t\t{"
                                   "\t\t\t\t\t\t\"bloomstrength\": " +
-                                  std::to_string (this->getScene ()->getBloomStrength ()) +
+                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
                                   ","
                                   "\t\t\t\t\t\t\"bloomthreshold\": " +
-                                  std::to_string (this->getScene ()->getBloomThreshold ()) +
+                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
                                   "\t\t\t\t\t}"
                                   "\t\t\t\t}"
                                   "\t\t\t]"
@@ -148,48 +147,54 @@ CScene::CScene (
     const auto json = nlohmann::json::parse (imagejson);
 
     // create image for bloom passes
-    if (this->getScene ()->isBloom ()) {
-        this->m_bloomObject = this->createObject (
-            WallpaperEngine::Core::CObject::fromJSON (json, scene->getProject (), this->getContainer ()));
+    if (scene->camera.bloom.enabled->value->getBool ()) {
+        this->m_bloomObjectData = ObjectParser::parse (json, scene->project);
+        this->m_bloomObject = this->createObject (*this->m_bloomObjectData);
 
         this->m_objectsByRenderOrder.push_back (this->m_bloomObject);
     }
 }
 
-Render::CObject* CScene::createObject (const Core::CObject* object) {
+Render::CObject* CScene::createObject (const Object& object) {
     Render::CObject* renderObject = nullptr;
 
     // ensure the item is not loaded already
-    const auto current = this->m_objects.find (object->getId ());
+    const auto current = this->m_objects.find (object.id);
 
     if (current != this->m_objects.end ())
         return current->second;
 
     // check dependencies too!
-    for (const auto& cur : object->getDependencies ()) {
+    for (const auto& cur : object.dependencies) {
         // self-dependency is a possibility...
-        if (cur == object->getId ())
+        if (cur == object.id)
             continue;
 
-        auto dep = this->getScene ()->getObjects ().find (cur);
+        const auto dep = std::find_if (
+            this->getScene ().objects.begin (),
+            this->getScene ().objects.end (),
+            [&cur] (const auto& o) {
+                return o->id == cur;
+            }
+        );
 
-        if (dep != this->getScene ()->getObjects ().end ())
-            this->createObject (dep->second);
+        if (dep != this->getScene ().objects.end ())
+            this->createObject (**dep);
     }
 
-    if (object->is<Core::Objects::CImage> ()) {
-        auto* image = new Objects::CImage (this, object->as<Core::Objects::CImage> ());
+    if (object.is<Image> ()) {
+        auto* image = new Objects::CImage (*this, *object.as<Image> ());
 
         try {
             image->setup ();
         } catch (std::runtime_error&) {
             // this error message is already printed, so just show extra info about it
-            sLog.error ("Cannot setup image ", image->getImage ()->getName ());
+            sLog.error ("Cannot setup image ", image->getImage ().name);
         }
 
         renderObject = image;
-    } else if (object->is<Core::Objects::CSound> ()) {
-        renderObject = new Objects::CSound (this, object->as<Core::Objects::CSound> ());
+    } else if (object.is<Sound> ()) {
+        renderObject = new Objects::CSound (*this, *object.as<Sound> ());
     }
 
     if (renderObject != nullptr)
@@ -198,8 +203,8 @@ Render::CObject* CScene::createObject (const Core::CObject* object) {
     return renderObject;
 }
 
-CCamera* CScene::getCamera () const {
-    return this->m_camera;
+CCamera& CScene::getCamera () const {
+    return *this->m_camera;
 }
 
 void CScene::renderFrame (glm::ivec4 viewport) {
@@ -207,11 +212,11 @@ void CScene::renderFrame (glm::ivec4 viewport) {
     this->updateMouse (viewport);
 
     // update the parallax position if required
-    if (this->getScene ()->isCameraParallax () && !this->getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
-        const float influence = this->getScene ()->getCameraParallaxMouseInfluence ();
-        const float amount = this->getScene ()->getCameraParallaxAmount ();
+    if (this->getScene ().camera.parallax.enabled && !this->getContext ().getApp ().getContext ().settings.mouse.disableparallax) {
+        const float influence = this->getScene ().camera.parallax.mouseInfluence;
+        const float amount = this->getScene ().camera.parallax.amount;
         const float delay =
-            glm::min (static_cast<float> (this->getScene ()->getCameraParallaxDelay ()), g_Time - g_TimeLast);
+            glm::min (static_cast<float> (this->getScene ().camera.parallax.delay), g_Time - g_TimeLast);
 
         this->m_parallaxDisplacement =
             glm::mix (this->m_parallaxDisplacement, (this->m_mousePosition * amount) * influence, delay);
@@ -243,27 +248,27 @@ void CScene::updateMouse (glm::ivec4 viewport) {
     // screen-space positions have to be transposed to what the screen will actually show
 }
 
-const Core::Wallpapers::CScene* CScene::getScene () const {
-    return this->getWallpaperData ()->as<Core::Wallpapers::CScene> ();
+const Scene& CScene::getScene () const {
+    return *this->getWallpaperData ().as<Scene> ();
 }
 
 int CScene::getWidth () const {
-    return this->getScene ()->getOrthogonalProjection ()->getWidth ();
+    return this->m_camera->getWidth ();
 }
 
 int CScene::getHeight () const {
-    return this->getScene ()->getOrthogonalProjection ()->getHeight ();
+    return this->m_camera->getHeight ();
 }
 
-glm::vec2* CScene::getMousePosition () {
+const glm::vec2* CScene::getMousePosition () const {
     return &this->m_mousePosition;
 }
 
-glm::vec2* CScene::getMousePositionLast () {
+const glm::vec2* CScene::getMousePositionLast () const {
     return &this->m_mousePositionLast;
 }
 
-glm::vec2* CScene::getParallaxDisplacement () {
+const glm::vec2* CScene::getParallaxDisplacement () const {
     return &this->m_parallaxDisplacement;
 }
 
diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.h b/src/WallpaperEngine/Render/Wallpapers/CScene.h
index 4b3c6e1..c43be96 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.h
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.h
@@ -2,8 +2,6 @@
 
 #include "WallpaperEngine/Render/CCamera.h"
 
-#include "WallpaperEngine/Core/Wallpapers/CScene.h"
-
 #include "WallpaperEngine/Render/CWallpaper.h"
 
 namespace WallpaperEngine::Render {
@@ -12,23 +10,25 @@ class CObject;
 }
 
 namespace WallpaperEngine::Render::Wallpapers {
+using namespace WallpaperEngine::Data::Model;
+
 class CScene final : public CWallpaper {
   public:
     CScene (
-        std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
+        const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
         const CWallpaperState::TextureUVsScaling& scalingMode,
         const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
 
-    [[nodiscard]] CCamera* getCamera () const;
+    [[nodiscard]] CCamera& getCamera () const;
 
-    [[nodiscard]] const Core::Wallpapers::CScene* getScene () const;
+    [[nodiscard]] const Scene& getScene () const;
 
     [[nodiscard]] int getWidth () const override;
     [[nodiscard]] int getHeight () const override;
 
-    glm::vec2* getMousePosition ();
-    glm::vec2* getMousePositionLast ();
-    glm::vec2* getParallaxDisplacement ();
+    const glm::vec2* getMousePosition () const;
+    const glm::vec2* getMousePositionLast () const;
+    const glm::vec2* getParallaxDisplacement () const;
 
     [[nodiscard]] const std::vector<CObject*>& getObjectsByRenderOrder () const;
 
@@ -39,9 +39,10 @@ class CScene final : public CWallpaper {
     friend class CWallpaper;
 
   private:
-    Render::CObject* createObject (const Core::CObject* object);
+    Render::CObject* createObject (const Object& object);
 
-    CCamera* m_camera = nullptr;
+    std::unique_ptr<CCamera> m_camera;
+    ObjectUniquePtr m_bloomObjectData;
     CObject* m_bloomObject = nullptr;
     std::map<int, CObject*> m_objects = {};
     std::vector<CObject*> m_objectsByRenderOrder = {};
diff --git a/src/WallpaperEngine/Render/Wallpapers/CVideo.cpp b/src/WallpaperEngine/Render/Wallpapers/CVideo.cpp
index 56f88c3..a955501 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CVideo.cpp
+++ b/src/WallpaperEngine/Render/Wallpapers/CVideo.cpp
@@ -3,6 +3,9 @@
 
 #include <GL/glew.h>
 
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+
 using namespace WallpaperEngine;
 using namespace WallpaperEngine::Render;
 using namespace WallpaperEngine::Render::Wallpapers;
@@ -12,7 +15,7 @@ void* get_proc_address (void* ctx, const char* name) {
 }
 
 CVideo::CVideo (
-    std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
+    const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
     const CWallpaperState::TextureUVsScaling& scalingMode,
     const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
 ) :
@@ -54,7 +57,7 @@ CVideo::CVideo (
         sLog.exception ("Failed to initialize MPV's GL context");
 
     const std::filesystem::path videopath =
-        this->getVideo ()->getProject ()->getContainer ()->resolveRealFile (this->getVideo ()->getFilename ());
+        this->getVideo ().project.container->resolveRealFile (this->getVideo ().filename);
 
     // build the path to the video file
     const char* command [] = {"loadfile", videopath.c_str (), nullptr};
@@ -118,8 +121,8 @@ void CVideo::renderFrame (glm::ivec4 viewport) {
     mpv_render_context_render (this->m_mpvGl, params);
 }
 
-const Core::Wallpapers::CVideo* CVideo::getVideo () const {
-    return this->getWallpaperData ()->as<Core::Wallpapers::CVideo> ();
+const Video& CVideo::getVideo () const {
+    return *this->getWallpaperData ().as<Video>();
 }
 
 void CVideo::setPause (bool newState) {
diff --git a/src/WallpaperEngine/Render/Wallpapers/CVideo.h b/src/WallpaperEngine/Render/Wallpapers/CVideo.h
index 0438a8e..d96eb05 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CVideo.h
+++ b/src/WallpaperEngine/Render/Wallpapers/CVideo.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "WallpaperEngine/Core/Wallpapers/CVideo.h"
-
 #include "WallpaperEngine/Audio/CAudioStream.h"
 #include "WallpaperEngine/Render/CWallpaper.h"
 #include <mpv/client.h>
@@ -11,11 +9,11 @@ namespace WallpaperEngine::Render::Wallpapers {
 class CVideo final : public CWallpaper {
   public:
     CVideo (
-        std::shared_ptr<const Core::CWallpaper> video, CRenderContext& context, CAudioContext& audioContext,
+        const Wallpaper& video, CRenderContext& context, CAudioContext& audioContext,
         const CWallpaperState::TextureUVsScaling& scalingMode,
         const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
 
-    const Core::Wallpapers::CVideo* getVideo () const;
+    const Video& getVideo () const;
 
     [[nodiscard]] int getWidth () const override;
     [[nodiscard]] int getHeight () const override;
diff --git a/src/WallpaperEngine/Render/Wallpapers/CWeb.cpp b/src/WallpaperEngine/Render/Wallpapers/CWeb.cpp
index 9f69cea..a7b719e 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CWeb.cpp
+++ b/src/WallpaperEngine/Render/Wallpapers/CWeb.cpp
@@ -4,6 +4,9 @@
 #include "CWeb.h"
 #include "WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h"
 
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Data/Model/Project.h"
+
 using namespace WallpaperEngine::Render;
 using namespace WallpaperEngine::Render::Wallpapers;
 
@@ -11,7 +14,7 @@ using namespace WallpaperEngine::WebBrowser;
 using namespace WallpaperEngine::WebBrowser::CEF;
 
 CWeb::CWeb (
-    std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
+    const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
     CWebBrowserContext& browserContext, const CWallpaperState::TextureUVsScaling& scalingMode,
     const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode
 ) :
@@ -32,9 +35,9 @@ CWeb::CWeb (
     this->m_client = new WebBrowser::CEF::CBrowserClient (m_renderHandler);
     // use the custom scheme for the wallpaper's files
     const std::string htmlURL =
-        CWPSchemeHandlerFactory::generateSchemeName(this->getWeb ()->getProject ()->getWorkshopId ()) +
+        CWPSchemeHandlerFactory::generateSchemeName(this->getWeb ().project.workshopId) +
         "://root/" +
-        this->getWeb()->getFilename ();
+        this->getWeb().filename;
     this->m_browser =
         CefBrowserHost::CreateBrowserSync (window_info, this->m_client, htmlURL, browserSettings, nullptr, nullptr);
 }
diff --git a/src/WallpaperEngine/Render/Wallpapers/CWeb.h b/src/WallpaperEngine/Render/Wallpapers/CWeb.h
index 759f9e9..fb16443 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CWeb.h
+++ b/src/WallpaperEngine/Render/Wallpapers/CWeb.h
@@ -11,11 +11,12 @@
 #include <algorithm>
 
 #include "WallpaperEngine/Audio/CAudioStream.h"
-#include "WallpaperEngine/Core/Wallpapers/CWeb.h"
 #include "WallpaperEngine/Render/CWallpaper.h"
 #include "WallpaperEngine/WebBrowser/CEF/CBrowserClient.h"
 #include "WallpaperEngine/WebBrowser/CEF/CRenderHandler.h"
 
+#include "WallpaperEngine/Data/Model/Wallpaper.h"
+
 namespace WallpaperEngine::WebBrowser::CEF {
 class CRenderHandler;
 }
@@ -25,7 +26,7 @@ class CWeb : public CWallpaper
 {
     public:
         CWeb (
-          std::shared_ptr<const Core::CWallpaper> wallpaper, CRenderContext& context, CAudioContext& audioContext,
+          const Wallpaper& wallpaper, CRenderContext& context, CAudioContext& audioContext,
           WallpaperEngine::WebBrowser::CWebBrowserContext& browserContext,
           const CWallpaperState::TextureUVsScaling& scalingMode,
           const WallpaperEngine::Assets::ITexture::TextureFlags& clampMode);
@@ -39,8 +40,8 @@ class CWeb : public CWallpaper
     protected:
         void renderFrame (glm::ivec4 viewport) override;
         void updateMouse (glm::ivec4 viewport);
-        const Core::Wallpapers::CWeb* getWeb () const {
-            return this->getWallpaperData ()->as<Core::Wallpapers::CWeb> ();
+        const Web& getWeb () const {
+            return *this->getWallpaperData ().as<Web> ();
         }
 
         friend class CWallpaper;
diff --git a/src/WallpaperEngine/WebBrowser/CEF/CSubprocessApp.cpp b/src/WallpaperEngine/WebBrowser/CEF/CSubprocessApp.cpp
index 2864af8..b1e6b5f 100644
--- a/src/WallpaperEngine/WebBrowser/CEF/CSubprocessApp.cpp
+++ b/src/WallpaperEngine/WebBrowser/CEF/CSubprocessApp.cpp
@@ -1,12 +1,13 @@
 #include "CSubprocessApp.h"
 #include "CWPSchemeHandlerFactory.h"
+#include "WallpaperEngine/Data/Model/Project.h"
 
 using namespace WallpaperEngine::WebBrowser::CEF;
 
 CSubprocessApp::CSubprocessApp (WallpaperEngine::Application::CWallpaperApplication& application) :
     m_application (application) {
     for (const auto& [_, info] : this->m_application.getBackgrounds()) {
-        this->m_handlerFactories [info->getWorkshopId ()] = new CWPSchemeHandlerFactory (info);
+        this->m_handlerFactories [info->workshopId] = new CWPSchemeHandlerFactory (*info);
     }
 }
 
diff --git a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.cpp b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.cpp
index debd1cd..dee57b1 100644
--- a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.cpp
+++ b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.cpp
@@ -5,12 +5,14 @@
 #include "MimeTypes.h"
 #include "include/cef_parser.h"
 
+#include "WallpaperEngine/Data/Model/Project.h"
+
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::WebBrowser::CEF;
 
-CWPSchemeHandler::CWPSchemeHandler(std::shared_ptr<const Core::CProject> project) :
-    m_project (project) {
-    this->m_container = this->m_project->getWallpaper ()->getProject ()->getContainer ();
+CWPSchemeHandler::CWPSchemeHandler(const Project& project) :
+    m_project (project),
+    m_container (*this->m_project.container) {
 }
 
 bool CWPSchemeHandler::Open(CefRefPtr<CefRequest> request,
@@ -46,7 +48,7 @@ bool CWPSchemeHandler::Open(CefRefPtr<CefRequest> request,
             this->m_mimeType = mime;
         }
 
-        this->m_contents = this->m_container->readFile (file, &this->m_filesize);
+        this->m_contents = this->m_container.readFile (file, &this->m_filesize);
         callback->Continue ();
     } catch (CAssetLoadException&) {
 #if !NDEBUG
diff --git a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.h b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.h
index df94ba1..2e456e1 100644
--- a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.h
+++ b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandler.h
@@ -2,7 +2,6 @@
 
 #include <string>
 
-#include "WallpaperEngine/Core/CProject.h"
 #include "include/cef_resource_handler.h"
 #include "include/wrapper/cef_helpers.h"
 
@@ -10,13 +9,20 @@ namespace WallpaperEngine::Assets {
 class CContainer;
 }
 
+namespace WallpaperEngine::Data::Model {
+class Project;
+}
+
 namespace WallpaperEngine::WebBrowser::CEF {
+
+using namespace WallpaperEngine::Data::Model;
+
 /**
  * wp{id}:// actual handler called by cef to access files
  */
 class CWPSchemeHandler : public CefResourceHandler {
   public:
-    explicit CWPSchemeHandler(std::shared_ptr<const Core::CProject> project);
+    explicit CWPSchemeHandler(const Project& project);
 
     bool Open(CefRefPtr<CefRequest> request,
                bool& handle_request,
@@ -32,9 +38,9 @@ class CWPSchemeHandler : public CefResourceHandler {
                CefRefPtr<CefResourceReadCallback> callback) override;
 
   private:
-    std::shared_ptr<const Core::CProject> m_project = nullptr;
+    const Project& m_project;
 
-    std::shared_ptr<const Assets::CContainer> m_container = nullptr;
+    const Assets::CContainer& m_container;
     std::shared_ptr<const uint8_t[]> m_contents = nullptr;
     uint32_t m_filesize = 0;
     std::string m_mimeType = "";
diff --git a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.cpp b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.cpp
index 331eab9..3bdd42c 100644
--- a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.cpp
+++ b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.cpp
@@ -5,7 +5,7 @@
 
 using namespace WallpaperEngine::WebBrowser::CEF;
 
-CWPSchemeHandlerFactory::CWPSchemeHandlerFactory (const std::shared_ptr<const Core::CProject>& project) :
+CWPSchemeHandlerFactory::CWPSchemeHandlerFactory (const Project& project) :
     m_project (project) {}
 
 CefRefPtr<CefResourceHandler> CWPSchemeHandlerFactory::Create (
diff --git a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h
index 8ee1a4b..208fe86 100644
--- a/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h
+++ b/src/WallpaperEngine/WebBrowser/CEF/CWPSchemeHandlerFactory.h
@@ -1,16 +1,21 @@
 #pragma once
 
 #include <string>
-#include "WallpaperEngine/Core/CProject.h"
 #include "include/cef_scheme.h"
 
+namespace WallpaperEngine::Data::Model {
+class Project;
+}
+
 namespace WallpaperEngine::WebBrowser::CEF {
+using namespace WallpaperEngine::Data::Model;
+
 /**
  * Simple factory that creates a scheme handler for wp when requested by Cef
  */
 class CWPSchemeHandlerFactory : public CefSchemeHandlerFactory {
   public:
-    explicit CWPSchemeHandlerFactory (const std::shared_ptr<const Core::CProject>& project);
+    explicit CWPSchemeHandlerFactory (const Project& project);
 
     CefRefPtr<CefResourceHandler> Create (
         CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
@@ -18,7 +23,7 @@ class CWPSchemeHandlerFactory : public CefSchemeHandlerFactory {
 
     static std::string generateSchemeName (const std::string& workshopId);
   private:
-    std::shared_ptr<const Core::CProject> m_project = nullptr;
+    const Project& m_project;
 
     IMPLEMENT_REFCOUNTING (CWPSchemeHandlerFactory);
     DISALLOW_COPY_AND_ASSIGN (CWPSchemeHandlerFactory);
diff --git a/src/main.cpp b/src/main.cpp
index 54f8db3..21341c1 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -20,7 +20,7 @@ void initLogging () {
 }
 
 int main (int argc, char* argv[]) {
-    try {
+    //try {
         // if type parameter is specified, this is a subprocess, so no logging should be enabled from our side
         bool enableLogging = true;
         std::string typeZygote = "--type=zygote";
@@ -64,8 +64,8 @@ int main (int argc, char* argv[]) {
         delete app;
 
         return 0;
-    } catch (const std::exception& e) {
+/*    } catch (const std::exception& e) {
         std::cerr << e.what () << std::endl;
         return 1;
-    }
+    }*/
 }
\ No newline at end of file

From e5355d0013f09e7a5cc18b2506e849464a636404 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Thu, 14 Aug 2025 01:55:39 +0200
Subject: [PATCH 03/23] fix: small mistakes in parsing (fbos not taken into
 account, values not validated, failed to parse properties not ignored)

---
 .../Core/Projects/CProperty.cpp               |  8 +++++---
 .../Data/Parsers/EffectParser.cpp             | 20 +++++++++++++++++++
 .../Data/Parsers/EffectParser.h               |  1 +
 .../Data/Parsers/MaterialParser.cpp           |  2 +-
 .../Data/Parsers/ProjectParser.cpp            |  5 +++++
 5 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/src/WallpaperEngine/Core/Projects/CProperty.cpp b/src/WallpaperEngine/Core/Projects/CProperty.cpp
index bffbcea..ccfb1ef 100644
--- a/src/WallpaperEngine/Core/Projects/CProperty.cpp
+++ b/src/WallpaperEngine/Core/Projects/CProperty.cpp
@@ -24,9 +24,11 @@ std::shared_ptr<CProperty> CProperty::fromJSON (const json& data, const std::str
     if (*type == "text")
         return CPropertyText::fromJSON (data, name);
 
-    // show the error and ignore this property
-    sLog.error ("Unexpected type for property: ", *type);
-    sLog.error (data);
+    if (*type != "group") {
+        // show the error and ignore this property
+        sLog.error ("Unexpected type for property: ", *type);
+        sLog.error (data);
+    }
 
     return nullptr;
 }
diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
index 93ddda5..d2e63b3 100644
--- a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
@@ -16,6 +16,7 @@ EffectUniquePtr EffectParser::load (Project& project, const std::string& filenam
 
 EffectUniquePtr EffectParser::parse (const JSON& it, Project& project) {
     const auto dependencies = it.optional ("dependencies");
+    const auto fbos = it.optional ("fbos");
 
     return std::make_unique <Effect> (Effect {
         .name = it.optional <std::string> ("name", ""),
@@ -24,6 +25,7 @@ EffectUniquePtr EffectParser::parse (const JSON& it, Project& project) {
         .preview = it.optional <std::string> ("preview", ""),
         .dependencies = dependencies.has_value () ? parseDependencies (*dependencies) : std::vector <std::string> {},
         .passes = parseEffectPasses (it.require ("passes", "Effect file must have passes"), project),
+        .fbos = fbos.has_value () ? parseFBOs (*fbos) : std::vector <FBOUniquePtr> {},
     });
 }
 
@@ -91,5 +93,23 @@ std::map <int, std::string> EffectParser::parseBinds (const JSON& it) {
         );
     }
 
+    return result;
+}
+
+std::vector <FBOUniquePtr> EffectParser::parseFBOs (const JSON& it) {
+    std::vector <FBOUniquePtr> result = {};
+
+    if (!it.is_array ()) {
+        return result;
+    }
+
+    for (const auto& cur : it) {
+        result.push_back(std::make_unique<FBO>(FBO {
+            .name = cur.require <std::string> ("name", "FBO must have a name"),
+            .format = cur.optional <std::string> ("format", "rgba8888"),
+            .scale = cur.optional ("scale", 1.0f),
+        }));
+    }
+
     return result;
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.h b/src/WallpaperEngine/Data/Parsers/EffectParser.h
index 5897aca..0a64c31 100644
--- a/src/WallpaperEngine/Data/Parsers/EffectParser.h
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.h
@@ -16,5 +16,6 @@ class EffectParser {
     static std::vector <std::string> parseDependencies (const JSON& it);
     static std::vector <EffectPassUniquePtr> parseEffectPasses (const JSON& it, Project& project);
     static std::map <int, std::string> parseBinds (const JSON& it);
+    static std::vector <FBOUniquePtr> parseFBOs (const JSON& it);
 };
 } // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
index 4804bdb..edc2d3f 100644
--- a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
@@ -60,7 +60,7 @@ std::map <int, std::string> MaterialParser::parseTextures (const JSON& it) {
     int index = 0;
 
     for (const auto& cur : it) {
-        if (!it.is_null ()) {
+        if (!cur.is_null ()) {
             result.emplace (index, cur);
         }
 
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
index cc74d4a..b2dffe4 100644
--- a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
@@ -63,6 +63,11 @@ Properties ProjectParser::parseProperties (const std::optional <JSON>& data) {
     for (const auto& cur : properties.value ().items ()) {
         const auto& property = Property::fromJSON (cur.value (), cur.key ());
 
+        // ignore properties that failed, these are generally groups
+        if (property == nullptr) {
+            continue;
+        }
+
         result.emplace (property->getName (), property);
     }
 

From 958c97f7918dbe29ec04f9caf66e288a48d5472a Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Thu, 14 Aug 2025 01:56:00 +0200
Subject: [PATCH 04/23] fix: parsing tex0004

---
 src/WallpaperEngine/Assets/CTexture.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/WallpaperEngine/Assets/CTexture.cpp b/src/WallpaperEngine/Assets/CTexture.cpp
index d55b01a..19ab50f 100644
--- a/src/WallpaperEngine/Assets/CTexture.cpp
+++ b/src/WallpaperEngine/Assets/CTexture.cpp
@@ -284,7 +284,7 @@ std::unique_ptr<CTexture::TextureHeader> CTexture::parseHeader (const char* file
         header->freeImageFormat = static_cast<FreeImageFormat> (*pointer++);
         header->isVideoMp4 = *pointer++ == 1;
 
-        if (header->freeImageFormat == FIF_UNKNOWN) {
+        if (header->freeImageFormat == FIF_UNKNOWN && header->isVideoMp4) {
             header->freeImageFormat = FIF_MP4;
         }
 
@@ -412,6 +412,8 @@ std::shared_ptr<CTexture::TextureMipmap> CTexture::parseMipmap (const TextureHea
         fileData ++;
 
         pointer = reinterpret_cast<const uint32_t*> (fileData);
+        // this is another param to ignore
+        pointer++;
     }
 
     mipmap->width = *pointer++;

From aa44d88a2bcac7f6791f84c917e401772db10667 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Thu, 14 Aug 2025 23:38:50 +0200
Subject: [PATCH 05/23] fix: pass overrides

---
 .../Data/Parsers/ObjectParser.cpp             |  4 +-
 .../Render/Objects/Effects/CPass.cpp          | 55 +++++++++++--------
 .../Render/Wallpapers/CScene.cpp              | 11 +++-
 .../Render/Wallpapers/CScene.h                |  1 +
 4 files changed, 44 insertions(+), 27 deletions(-)

diff --git a/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
index c1b7a7f..8e5ba6c 100644
--- a/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
@@ -115,8 +115,8 @@ std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, P
 ImageEffectUniquePtr ObjectParser::parseEffect (const JSON& it, Project& project) {
     const auto& passsOverrides = it.optional ("passes");
     return std::make_unique <ImageEffect> (ImageEffect {
-        .id = it.require <int> ("id", "Image effect must have an id"),
-        .name = it.require <std::string> ("name", "Image effect must have a name"),
+        .id = it.optional <int> ("id", -1),
+        .name = it.optional <std::string> ("name", "Effect without name"),
         .visible = it.user ("visible", project.properties, true),
         .passOverrides = passsOverrides.has_value () ? parseEffectPassOverrides (passsOverrides.value (), project) : std::vector <ImageEffectPassOverrideUniquePtr> {},
         .effect = EffectParser::load (project, it.require ("file", "Image effect must have an effect"))
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index dc604b3..841235d 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -59,7 +59,7 @@ CPass::CPass (
     m_blendingmode (pass.blending),
     m_binds (binds.has_value () ? binds.value ().get () : DEFAULT_BINDS),
     m_override (override.has_value () ? override.value ().get () : DEFAULT_OVERRIDE),
-    m_fboProvider (fboProvider),
+    m_fboProvider (std::move(fboProvider)),
     m_target (target) {
     this->setupShaders ();
     this->setupShaderVariables ();
@@ -502,16 +502,11 @@ void CPass::setupTextureUniforms () {
     // and then try with fragment's and override any existing
     for (const auto& [index, textureName] : this->m_shader->getVertex ().getTextures ()) {
         try {
-            // resolve the texture first
-            std::shared_ptr<const ITexture> textureRef;
-
             if (textureName.find ("_rt_") == 0 || textureName.find ("_alias_") == 0) {
-                textureRef = this->resolveFBO (textureName);
-            } else {
-                textureRef = this->getContext ().resolveTexture (textureName);
+                this->m_textures [index] = this->resolveFBO (textureName);
+            } else if(!textureName.empty ()) {
+                this->m_textures [index] = this->getContext ().resolveTexture (textureName);
             }
-
-            this->m_textures [index] = textureRef;
         } catch (std::runtime_error& ex) {
             sLog.error ("Cannot resolve texture ", textureName, " for fragment shader ", ex.what ());
         }
@@ -519,16 +514,11 @@ void CPass::setupTextureUniforms () {
 
     for (const auto& [index, textureName] : this->m_shader->getFragment ().getTextures ()) {
         try {
-            // resolve the texture first
-            std::shared_ptr<const ITexture> textureRef;
-
             if (textureName.find ("_rt_") == 0 || textureName.find ("_alias_") == 0) {
-                textureRef = this->resolveFBO (textureName);
-            } else {
-                textureRef = this->getContext ().resolveTexture (textureName);
+                this->m_textures [index] = this->resolveFBO (textureName);
+            } else if(!textureName.empty ()) {
+                this->m_textures [index] = this->getContext ().resolveTexture (textureName);
             }
-
-            this->m_textures [index] = textureRef;
         } catch (std::runtime_error& ex) {
             sLog.error ("Cannot resolve texture ", textureName, " for fragment shader ", ex.what ());
         }
@@ -540,10 +530,31 @@ void CPass::setupTextureUniforms () {
             continue;
         }
 
-        if (textureName.find ("_rt_") == 0) {
-            this->m_textures[index] = this->resolveFBO (textureName);
-        } else if (!textureName.empty ()) {
-            this->m_textures[index] = this->m_image.getContext ().resolveTexture (textureName);
+        try {
+            if (textureName.find ("_rt_") == 0 || textureName.find ("_alias_") == 0) {
+                this->m_textures [index] = this->resolveFBO (textureName);
+            } else if (!textureName.empty ()) {
+                this->m_textures [index] = this->getContext ().resolveTexture (textureName);
+            }
+        } catch (std::runtime_error& ex) {
+            sLog.error ("Cannot resolve texture ", textureName, " for pass ", ex.what ());
+        }
+    }
+
+    // override any texture
+    for (const auto& [index, textureName] : this->m_override.textures) {
+        if (index == 0) {
+            continue;
+        }
+
+        try {
+            if (textureName.find ("_rt_") == 0 || textureName.find ("_alias_") == 0) {
+                this->m_textures [index] = this->resolveFBO (textureName);
+            } else if (!textureName.empty ()) {
+                this->m_textures [index] = this->getContext ().resolveTexture (textureName);
+            }
+        } catch (std::runtime_error& ex) {
+            sLog.error ("Cannot resolve texture ", textureName, " for override ", ex.what ());
         }
     }
 
@@ -552,7 +563,7 @@ void CPass::setupTextureUniforms () {
         if (bind == "previous") {
             // use nullptr as indication for "previous" texture
             this->m_textures [index] = nullptr;
-        } else {
+        } else if(!bind.empty ()) {
             // a normal bind, search for the corresponding FBO and set it
             this->m_textures [index] = this->resolveFBO (bind);
         }
diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
index 6f1b58e..b8a3c60 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
@@ -46,6 +46,14 @@ CScene::CScene (
     // setup framebuffers here as they're required for the scene setup
     this->setupFramebuffers ();
 
+    const uint32_t sceneWidth = this->m_camera->getWidth ();
+    const uint32_t sceneHeight = this->m_camera->getHeight ();
+
+    this->_rt_shadowAtlas =
+        this->create ("_rt_shadowAtlas", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
+                      {sceneWidth, sceneHeight}, {sceneWidth, sceneHeight});
+    this->alias ("_alias_lightCookie", "_rt_shadowAtlas");
+
     // set clear color
     // TODO: MAKE USE OF THE REFERENCE POSSIBILITIES?!
     const glm::vec3 clearColor = scene->colors.clear->value->getVec3 ();
@@ -67,9 +75,6 @@ CScene::CScene (
         this->m_objectsByRenderOrder.emplace_back (obj->second);
     }
 
-    const uint32_t sceneWidth = this->m_camera->getWidth ();
-    const uint32_t sceneHeight = this->m_camera->getHeight ();
-
     // create extra framebuffers for the bloom effect
     this->_rt_4FrameBuffer =
         this->create ("_rt_4FrameBuffer", ITexture::TextureFormat::ARGB8888, ITexture::TextureFlags::ClampUVs, 1.0,
diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.h b/src/WallpaperEngine/Render/Wallpapers/CScene.h
index c43be96..5519bde 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.h
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.h
@@ -52,5 +52,6 @@ class CScene final : public CWallpaper {
     std::shared_ptr<const CFBO> _rt_4FrameBuffer = nullptr;
     std::shared_ptr<const CFBO> _rt_8FrameBuffer = nullptr;
     std::shared_ptr<const CFBO> _rt_Bloom = nullptr;
+    std::shared_ptr<const CFBO> _rt_shadowAtlas = nullptr;
 };
 } // namespace WallpaperEngine::Render::Wallpaper

From ace12825220442fd53fda38eee6f6621c47b9f1d Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Fri, 15 Aug 2025 00:09:31 +0200
Subject: [PATCH 06/23] chore: cleanup bloom effect code

---
 .../Render/Wallpapers/CScene.cpp              | 113 +++++++++---------
 1 file changed, 55 insertions(+), 58 deletions(-)

diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
index b8a3c60..1f69d35 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
@@ -93,67 +93,64 @@ CScene::CScene (
     //
 
     // TODO: TAKE THIS OUT OF HERE AND INTO THE GENERAL WALLPAPER APPLICATION?!
-    const std::string imagejson = "{"
-                                  "\t\"image\": \"models/wpenginelinux.json\","
-                                  "\t\"name\": \"bloomimagewpenginelinux\","
-                                  "\t\"visible\": true,"
-                                  "\t\"scale\": \"1.0 1.0 1.0\","
-                                  "\t\"angles\": \"0.0 0.0 0.0\","
-                                  "\t\"origin\": \"" +
-                                  std::to_string (sceneWidth / 2) + " " + std::to_string (sceneHeight / 2) +
-                                  " 0.0\","
-                                  "\t\"id\": -1" +
-                                  ","
-                                  "\t\"effects\":"
-                                  "\t["
-                                  "\t\t{"
-                                  "\t\t\t\"file\": \"effects/wpenginelinux/bloomeffect.json\","
-                                  "\t\t\t\"id\": 15242000,"
-                                  "\t\t\t\"name\": \"\","
-                                  "\t\t\t\"passes\":"
-                                  "\t\t\t["
-                                  "\t\t\t\t{"
-                                  "\t\t\t\t\t\"constantshadervalues\":"
-                                  "\t\t\t\t\t{"
-                                  "\t\t\t\t\t\t\"bloomstrength\": " +
-                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
-                                  ","
-                                  "\t\t\t\t\t\t\"bloomthreshold\": " +
-                                  std::to_string (this->getScene ().camera.bloom.threshold->value->getFloat ()) +
-                                  "\t\t\t\t\t}"
-                                  "\t\t\t\t},"
-                                  "\t\t\t\t{"
-                                  "\t\t\t\t\t\"constantshadervalues\":"
-                                  "\t\t\t\t\t{"
-                                  "\t\t\t\t\t\t\"bloomstrength\": " +
-                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
-                                  ","
-                                  "\t\t\t\t\t\t\"bloomthreshold\": " +
-                                  std::to_string (this->getScene ().camera.bloom.threshold->value->getFloat ()) +
-                                  "\t\t\t\t\t}"
-                                  "\t\t\t\t},"
-                                  "\t\t\t\t{"
-                                  "\t\t\t\t\t\"constantshadervalues\":"
-                                  "\t\t\t\t\t{"
-                                  "\t\t\t\t\t\t\"bloomstrength\": " +
-                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
-                                  ","
-                                  "\t\t\t\t\t\t\"bloomthreshold\": " +
-                                  std::to_string (this->getScene ().camera.bloom.strength->value->getFloat ()) +
-                                  "\t\t\t\t\t}"
-                                  "\t\t\t\t}"
-                                  "\t\t\t]"
-                                  "\t\t}"
-                                  "\t],"
-                                  "\t\"size\": \"" +
-                                  std::to_string (sceneWidth) + " " + std::to_string (sceneHeight) +
-                                  "\""
-                                  "}";
-    const auto json = nlohmann::json::parse (imagejson);
+    const auto bloomOrigin = glm::vec3 { sceneWidth / 2, sceneHeight / 2, 0.0f };
+    const auto bloomSize = glm::vec2 { sceneWidth, sceneHeight };
+
+    const nlohmann::json bloom = {
+        {"image", "models/wpenginelinux.json"},
+        {"name", "bloomimagewpenginelinux"},
+        {"visible", true},
+        {"scale", "1.0 1.0 1.0"},
+        {"angles", "0.0 0.0 0.0"},
+        {"origin", std::to_string (bloomOrigin.x) + " " + std::to_string (bloomOrigin.y) + " " + std::to_string(bloomOrigin.z)},
+        {"size", std::to_string (bloomSize.x) + " " + std::to_string (bloomSize.y)},
+        {"id", -1},
+        {"effects",
+            json::array (
+                {
+                    {
+                        {"file", "effects/wpenginelinux/bloomeffect.json"},
+                        {"id", 15242000},
+                        {"name", ""},
+                        {"passes",
+                             json::array (
+                                 {
+                                     {
+                                         {"constantshadervalues",
+                                             {
+                                                 {"bloomstrength", this->getScene ().camera.bloom.strength->value->getFloat ()},
+                                                 {"bloomthreshold", this->getScene ().camera.bloom.threshold->value->getFloat ()}
+                                             }
+                                         }
+                                     },
+                                     {
+                                         {"constantshadervalues",
+                                            {
+                                                {"bloomstrength", this->getScene ().camera.bloom.strength->value->getFloat ()},
+                                                {"bloomthreshold", this->getScene ().camera.bloom.threshold->value->getFloat ()}
+                                            }
+                                        }
+                                     },
+                                     {
+                                         {"constantshadervalues",
+                                             {
+                                                 {"bloomstrength", this->getScene ().camera.bloom.strength->value->getFloat ()},
+                                                 {"bloomthreshold", this->getScene ().camera.bloom.threshold->value->getFloat ()}
+                                             }
+                                         }
+                                     }
+                                 }
+                             )
+                        }
+                    }
+                }
+            )
+        }
+    };
 
     // create image for bloom passes
     if (scene->camera.bloom.enabled->value->getBool ()) {
-        this->m_bloomObjectData = ObjectParser::parse (json, scene->project);
+        this->m_bloomObjectData = ObjectParser::parse (bloom, scene->project);
         this->m_bloomObject = this->createObject (*this->m_bloomObjectData);
 
         this->m_objectsByRenderOrder.push_back (this->m_bloomObject);

From 1a3f789cee5a1e4d60be45ee64399515555aa622 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Fri, 15 Aug 2025 00:53:11 +0200
Subject: [PATCH 07/23] chore: fix binds loading, more fixes on pass overrides,
 should cleanup soon

---
 src/WallpaperEngine/Data/Parsers/EffectParser.cpp    |  2 +-
 src/WallpaperEngine/Render/Objects/Effects/CPass.cpp |  2 +-
 src/WallpaperEngine/Render/Shaders/CShader.cpp       |  6 ++++--
 src/WallpaperEngine/Render/Shaders/CShader.h         |  5 +++++
 src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp   | 12 ++++++++----
 src/WallpaperEngine/Render/Shaders/CShaderUnit.h     |  6 ++++--
 6 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
index d2e63b3..98709d0 100644
--- a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
@@ -51,7 +51,7 @@ std::vector <EffectPassUniquePtr> EffectParser::parseEffectPasses (const JSON& i
     }
 
     for (const auto& cur : it) {
-        const auto binds = cur.optional ("binds");
+        const auto binds = cur.optional ("bind");
         std::optional <PassCommand> command = std::nullopt;
 
         if (cur.contains ("command")) {
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index 841235d..ac6c254 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -426,7 +426,7 @@ void CPass::setupShaders () {
     // use the combos copied from the pass so it includes the texture format
     this->m_shader = new Render::Shaders::CShader (
         this->m_image.getContainer (), this->m_pass.shader, this->m_combos,
-        this->m_pass.textures, this->m_override.constants
+        this->m_pass.textures, this->m_override.textures, this->m_override.constants
     );
 
     const auto shaders = Shaders::CGLSLContext::get ().toGlsl (
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.cpp b/src/WallpaperEngine/Render/Shaders/CShader.cpp
index 44ad97d..d2413ed 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShader.cpp
@@ -20,17 +20,19 @@ namespace WallpaperEngine::Render::Shaders {
 CShader::CShader (
     const CContainer& container, std::string filename,
     const ComboMap& combos, const TextureMap& textures,
+    const TextureMap& overrideTextures,
     const ShaderConstantMap& constants
 ) :
     m_file (std::move (filename)),
     m_combos (combos),
     m_passTextures (textures),
+    m_overrideTextures (overrideTextures),
     m_vertex (
         CGLSLContext::UnitType_Vertex, filename, container.readVertexShader (filename),
-        container, constants, textures, combos),
+        container, constants, textures, overrideTextures, combos),
     m_fragment (
         CGLSLContext::UnitType_Fragment, filename, container.readFragmentShader (filename),
-        container, constants, textures, combos) {
+        container, constants, textures, overrideTextures, combos) {
     // link shaders between them
     this->m_vertex.linkToUnit (&this->m_fragment);
     this->m_fragment.linkToUnit (&this->m_vertex);
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.h b/src/WallpaperEngine/Render/Shaders/CShader.h
index 4ca3445..0638f9b 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.h
+++ b/src/WallpaperEngine/Render/Shaders/CShader.h
@@ -47,6 +47,7 @@ class CShader {
     CShader (
         const CContainer& container, std::string filename,
         const ComboMap& combos, const TextureMap& textures,
+        const TextureMap& overrideTextures,
         const ShaderConstantMap& constants);
     /**
      * @return The vertex's shader coude for OpenGL to use
@@ -101,5 +102,9 @@ class CShader {
      * The list of textures the pass knows about
      */
     const TextureMap m_passTextures;
+    /**
+     * The list of the override textures
+     */
+    const TextureMap& m_overrideTextures;
 };
 } // namespace WallpaperEngine::Render::Shaders
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index 8c49614..4c00202 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -57,7 +57,8 @@ using namespace WallpaperEngine::Render::Shaders;
 
 CShaderUnit::CShaderUnit (
     CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
-    const ShaderConstantMap& constants, const TextureMap& passTextures, const ComboMap& combos
+    const ShaderConstantMap& constants, const TextureMap& passTextures, const TextureMap& overrideTextures,
+    const ComboMap& combos
 ) :
     m_type (type),
     m_link (nullptr),
@@ -66,6 +67,7 @@ CShaderUnit::CShaderUnit (
     m_constants (constants),
     m_content (std::move(content)),
     m_passTextures (passTextures),
+    m_overrideTextures (overrideTextures),
     m_combos (combos),
     m_discoveredCombos (),
     m_usedCombos () {
@@ -409,15 +411,17 @@ void CShaderUnit::parseParameterConfiguration (
         const auto requireany = data.find ("requireany");
         const auto require = data.find ("require");
         // now convert it to integer
+        // TODO: BETTER CONVERSION HERE
         size_t index = value - '0';
 
         if (combo != data.end ()) {
+            // TODO: CLEANUP HOW THIS IS DETERMINED FIRST
             // if the texture exists (and is not null), add to the combo
-            auto texture = this->m_passTextures.find (index);
+            auto textureSlotUsed = this->m_passTextures.find (index) != this->m_passTextures.end () || this->m_overrideTextures.find (index) != this->m_overrideTextures.end ();
             bool isRequired = false;
             int comboValue = 1;
 
-            if (texture != this->m_passTextures.end ()) {
+            if (textureSlotUsed) {
                 // nothing extra to do, the texture exists, the combo must be set
                 // these tend to not have default value
                 isRequired = true;
@@ -452,7 +456,7 @@ void CShaderUnit::parseParameterConfiguration (
                 }
             }
 
-            if (isRequired && texture == this->m_passTextures.end ()) {
+            if (isRequired && !textureSlotUsed) {
                 if (defvalue == data.end ()) {
                     isRequired = false;
                 } else {
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
index 97f6713..df365a3 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
@@ -27,7 +27,7 @@ class CShaderUnit {
     CShaderUnit (
         CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
         const ShaderConstantMap& constants, const TextureMap& passTextures,
-        const ComboMap& combos);
+        const TextureMap& overrideTextures, const ComboMap& combos);
     ~CShaderUnit () = default;
 
     /**
@@ -145,7 +145,9 @@ class CShaderUnit {
      */
     const ShaderConstantMap& m_constants;
     /** The textures that are already applied to this shader */
-    const TextureMap m_passTextures = {};
+    const TextureMap& m_passTextures;
+    /** The textures that are being overridden */
+    const TextureMap& m_overrideTextures;
     /** The default textures to use when a texture is not applied in a given slot */
     TextureMap m_defaultTextures = {};
     /**

From 04c85bebe4ea5d78e66ba5daa6469c97d9ee3fef Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Fri, 15 Aug 2025 01:04:32 +0200
Subject: [PATCH 08/23] chore: fix audio processing detection

---
 src/WallpaperEngine/Data/Parsers/ProjectParser.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
index b2dffe4..a26957e 100644
--- a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
@@ -22,7 +22,7 @@ ProjectUniquePtr ProjectParser::parse (const JSON& data, ContainerUniquePtr cont
         .title = data.require <std::string> ("title", "Project title missing"),
         .type = parseType (type),
         .workshopId = data.optional ("workshopid", std::to_string (--backgroundId)),
-        .supportsAudioProcessing = general.has_value () && general.value ().optional ("supportsAudioProcessing", false),
+        .supportsAudioProcessing = general.has_value () && general.value ().optional ("supportsaudioprocessing", false),
         .properties = parseProperties (general),
         .container = std::move(container),
     });

From 303a2b56249a06b74b281f9c8aa55dc66ec8af74 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Fri, 15 Aug 2025 07:20:15 +0200
Subject: [PATCH 09/23] chore: DynamicValues now keep track of current type,
 colors should be converted to vec4/ivec4 upon reading so alpha is correct,
 keep combo overrides too

---
 .../Core/DynamicValues/CDynamicValue.cpp      | 13 +++++++
 .../Core/DynamicValues/CDynamicValue.h        | 19 +++++++++-
 .../Data/Parsers/ObjectParser.cpp             | 19 +++++++---
 .../Render/Objects/Effects/CPass.cpp          |  4 +-
 .../Render/Shaders/CShader.cpp                |  9 +++--
 src/WallpaperEngine/Render/Shaders/CShader.h  |  8 +++-
 .../Render/Shaders/CShaderUnit.cpp            | 37 ++++++++++++++++---
 .../Render/Shaders/CShaderUnit.h              |  6 ++-
 8 files changed, 93 insertions(+), 22 deletions(-)

diff --git a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
index 2353c1e..f7c7750 100644
--- a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
+++ b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
@@ -19,6 +19,7 @@ void CDynamicValue::update(float newValue) {
     this->m_float = newValue;
     this->m_int = static_cast<int> (newValue);
     this->m_bool = static_cast<int> (newValue) != 0;
+    this->m_type = UnderlyingType::Float;
 
     this->propagate ();
 }
@@ -33,6 +34,7 @@ void CDynamicValue::update(int newValue) {
     this->m_float = static_cast<float> (newValue);
     this->m_int = newValue;
     this->m_bool = newValue != 0;
+    this->m_type = UnderlyingType::Int;
 
     this->propagate ();
 }
@@ -47,6 +49,7 @@ void CDynamicValue::update(bool newValue) {
     this->m_float = newValue;
     this->m_int = newValue;
     this->m_bool = newValue;
+    this->m_type = UnderlyingType::Boolean;
 
     this->propagate ();
 }
@@ -61,6 +64,7 @@ void CDynamicValue::update(const glm::vec2& newValue) {
     this->m_float = newValue.x;
     this->m_int = static_cast<int> (newValue.x);
     this->m_bool = newValue.x != 0.0f;
+    this->m_type = UnderlyingType::Vec2;
 
     this->propagate ();
 }
@@ -75,6 +79,7 @@ void CDynamicValue::update(const glm::vec3& newValue) {
     this->m_float = newValue.x;
     this->m_int = static_cast<int> (newValue.x);
     this->m_bool = newValue.x != 0.0f;
+    this->m_type = UnderlyingType::Vec3;
 
     this->propagate ();
 }
@@ -89,6 +94,7 @@ void CDynamicValue::update(const glm::vec4& newValue) {
     this->m_float = newValue.x;
     this->m_int = static_cast<int> (newValue.x);
     this->m_bool = newValue.x != 0.0f;
+    this->m_type = UnderlyingType::Vec4;
 
     this->propagate ();
 }
@@ -103,6 +109,7 @@ void CDynamicValue::update(const glm::ivec2& newValue) {
     this->m_float = static_cast<float> (newValue.x);
     this->m_int = static_cast<int> (newValue.x);
     this->m_bool = newValue.x != 0;
+    this->m_type = UnderlyingType::IVec2;
 
     this->propagate ();
 }
@@ -117,6 +124,7 @@ void CDynamicValue::update(const glm::ivec3& newValue) {
     this->m_float = static_cast<float> (newValue.x);
     this->m_int = static_cast<int> (newValue.x);
     this->m_bool = newValue.x != 0;
+    this->m_type = UnderlyingType::IVec3;
 
     this->propagate ();
 }
@@ -131,6 +139,7 @@ void CDynamicValue::update(const glm::ivec4& newValue) {
     this->m_float = static_cast<float> (newValue.x);
     this->m_int = static_cast<int> (newValue.x);
     this->m_bool = newValue.x != 0;
+    this->m_type = UnderlyingType::IVec4;
 
     this->propagate ();
 }
@@ -202,4 +211,8 @@ const int& CDynamicValue::getInt () const {
 
 const bool& CDynamicValue::getBool () const {
     return this->m_bool;
+}
+
+CDynamicValue::UnderlyingType CDynamicValue::getType () const {
+    return this->m_type;
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
index 177cb97..7347da8 100644
--- a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
+++ b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
@@ -19,6 +19,19 @@ class CDynamicValue {
     friend class WallpaperEngine::Data::Parsers::UserSettingParser;
     friend class WallpaperEngine::Data::Builders::UserSettingBuilder;
   public:
+    enum UnderlyingType {
+        Unknown = -1,
+        IVec4 = 0,
+        IVec3 = 1,
+        IVec2 = 2,
+        Vec4 = 3,
+        Vec3 = 4,
+        Vec2 = 5,
+        Float = 6,
+        Int = 7,
+        Boolean = 8
+    };
+
     virtual ~CDynamicValue ();
 
     [[nodiscard]] const glm::ivec4& getIVec4 () const;
@@ -30,6 +43,7 @@ class CDynamicValue {
     [[nodiscard]] const float& getFloat () const;
     [[nodiscard]] const int& getInt () const;
     [[nodiscard]] const bool& getBool () const;
+    [[nodiscard]] UnderlyingType getType () const;
 
     /**
      * Connects the current instance to the given instance, updating it's values
@@ -38,8 +52,6 @@ class CDynamicValue {
      * @param value
      */
     void connectOutgoing (CDynamicValue* value) const;
-
-  protected:
     void update (float newValue);
     void update (int newValue);
     void update (bool newValue);
@@ -49,6 +61,8 @@ class CDynamicValue {
     void update (const glm::ivec2& newValue);
     void update (const glm::ivec3& newValue);
     void update (const glm::ivec4& newValue);
+
+  protected:
     /**
      * Registers an incoming connection (another CDynamicValue affecting the current instance's value)
      * Useful mainly for destroying the connection on delete
@@ -65,6 +79,7 @@ class CDynamicValue {
   private:
     mutable std::vector<CDynamicValue*> m_outgoingConnections = {};
     mutable std::vector<const CDynamicValue*> m_incomingConnections = {};
+    UnderlyingType m_type = UnderlyingType::Unknown;
     // different values that we will be casted to automagically
     glm::ivec4 m_ivec4 = {};
     glm::ivec3 m_ivec3 = {};
diff --git a/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
index 8e5ba6c..8cb84d7 100644
--- a/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ObjectParser.cpp
@@ -78,7 +78,7 @@ ImageUniquePtr ObjectParser::parseImage (
     const auto& properties = project.properties;
     const auto& effects = it.optional ("effects");
 
-    return std::make_unique <Image> (
+    auto result = std::make_unique <Image> (
         std::move (base),
         ImageData {
             .origin = it.user ("origin", properties, glm::vec3 (0.0f)),
@@ -86,7 +86,7 @@ ImageUniquePtr ObjectParser::parseImage (
             .angles = it.user ("angles", properties, glm::vec3 (0.0)),
             .visible = it.user ("visible", properties, true),
             .alpha = it.user ("alpha", properties, 1.0f),
-            .color = it.user ("color", properties, glm::vec3 (1.0f)),
+            .color = it.user ("color", properties, glm::vec4 (1.0f)),
             .alignment = it.optional ("alignment", std::string ("center")),
             .size = it.optional ("size", glm::vec2 (0.0f)),
             .parallaxDepth = it.optional ("parallaxDepth", glm::vec2 (0.0f)),
@@ -96,6 +96,15 @@ ImageUniquePtr ObjectParser::parseImage (
             .effects = effects.has_value () ? parseEffects (*effects, project) : std::vector <ImageEffectUniquePtr> {},
         }
     );
+
+    // color should be a vec4 for alpha, but it's read as vec3
+    if (result->color->value->getType () == DynamicValue::UnderlyingType::Vec3) {
+        result->color->value->update (glm::vec4 (result->color->value->getVec3 (), 1.0f));
+    } else if (result->color->value->getType () == DynamicValue::UnderlyingType::IVec3) {
+        result->color->value->update (glm::vec4 (result->color->value->getIVec3 (), 255));
+    }
+
+    return result;
 }
 
 std::vector <ImageEffectUniquePtr> ObjectParser::parseEffects (const JSON& it, Project& project) {
@@ -163,10 +172,10 @@ TextureMap ObjectParser::parseTextureMap (const JSON& it) {
         textureIndex ++;
 
         if (cur.is_null ()) {
-            continue;
+            result.emplace (textureIndex, "");
+        } else {
+            result.emplace (textureIndex, cur);
         }
-
-        result.emplace (textureIndex, cur);
     }
 
     return result;
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index ac6c254..0dc01f3 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -425,7 +425,7 @@ void CPass::setupShaders () {
     // TODO: USED TO BUILD THE TEXTURES LATER
     // use the combos copied from the pass so it includes the texture format
     this->m_shader = new Render::Shaders::CShader (
-        this->m_image.getContainer (), this->m_pass.shader, this->m_combos,
+        this->m_image.getContainer (), this->m_pass.shader, this->m_combos, this->m_override.combos,
         this->m_pass.textures, this->m_override.textures, this->m_override.constants
     );
 
@@ -608,7 +608,7 @@ void CPass::setupUniforms () {
     this->addUniform ("g_UserAlpha", image.alpha->value->getFloat ());
     this->addUniform ("g_Alpha", image.alpha->value->getFloat ());
     this->addUniform ("g_Color", image.color->value->getVec3 ());
-    this->addUniform ("g_Color4", image.color->value->getVec4());
+    this->addUniform ("g_Color4", image.color->value->getVec4 ());
     // TODO: VALIDATE THAT G_COMPOSITECOLOR REALLY COMES FROM THIS ONE
     this->addUniform ("g_CompositeColor", image.color->value->getVec3 ());
     // add some external variables
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.cpp b/src/WallpaperEngine/Render/Shaders/CShader.cpp
index d2413ed..6b5d424 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShader.cpp
@@ -19,20 +19,21 @@ using namespace WallpaperEngine::Assets;
 namespace WallpaperEngine::Render::Shaders {
 CShader::CShader (
     const CContainer& container, std::string filename,
-    const ComboMap& combos, const TextureMap& textures,
-    const TextureMap& overrideTextures,
+    const ComboMap& combos, const ComboMap& overrideCombos,
+    const TextureMap& textures, const TextureMap& overrideTextures,
     const ShaderConstantMap& constants
 ) :
     m_file (std::move (filename)),
     m_combos (combos),
+    m_overrideCombos (overrideCombos),
     m_passTextures (textures),
     m_overrideTextures (overrideTextures),
     m_vertex (
         CGLSLContext::UnitType_Vertex, filename, container.readVertexShader (filename),
-        container, constants, textures, overrideTextures, combos),
+        container, constants, textures, overrideTextures, combos, overrideCombos),
     m_fragment (
         CGLSLContext::UnitType_Fragment, filename, container.readFragmentShader (filename),
-        container, constants, textures, overrideTextures, combos) {
+        container, constants, textures, overrideTextures, combos, overrideCombos) {
     // link shaders between them
     this->m_vertex.linkToUnit (&this->m_fragment);
     this->m_fragment.linkToUnit (&this->m_vertex);
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.h b/src/WallpaperEngine/Render/Shaders/CShader.h
index 0638f9b..5bbe810 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.h
+++ b/src/WallpaperEngine/Render/Shaders/CShader.h
@@ -46,8 +46,8 @@ class CShader {
      */
     CShader (
         const CContainer& container, std::string filename,
-        const ComboMap& combos, const TextureMap& textures,
-        const TextureMap& overrideTextures,
+        const ComboMap& combos, const ComboMap& overrideCombos,
+        const TextureMap& textures, const TextureMap& overrideTextures,
         const ShaderConstantMap& constants);
     /**
      * @return The vertex's shader coude for OpenGL to use
@@ -98,6 +98,10 @@ class CShader {
      * The combos the shader should be generated with
      */
     const ComboMap& m_combos;
+    /**
+     * The overriden combos
+     */
+    const ComboMap& m_overrideCombos;
     /**
      * The list of textures the pass knows about
      */
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index 4c00202..915510f 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -58,7 +58,7 @@ using namespace WallpaperEngine::Render::Shaders;
 CShaderUnit::CShaderUnit (
     CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
     const ShaderConstantMap& constants, const TextureMap& passTextures, const TextureMap& overrideTextures,
-    const ComboMap& combos
+    const ComboMap& combos, const ComboMap& overrideCombos
 ) :
     m_type (type),
     m_link (nullptr),
@@ -69,6 +69,7 @@ CShaderUnit::CShaderUnit (
     m_passTextures (passTextures),
     m_overrideTextures (overrideTextures),
     m_combos (combos),
+    m_overrideCombos (overrideCombos),
     m_discoveredCombos (),
     m_usedCombos () {
     // pre-process the shader so the units are clear
@@ -335,14 +336,14 @@ void CShaderUnit::parseComboConfiguration (const std::string& content, int defau
 
     // check the combos
     const auto entry = this->m_combos.find (combo->get<std::string> ());
+    const auto entryOverride = this->m_overrideCombos.find (combo->get<std::string> ());
 
     // add the combo to the found list
     this->m_usedCombos.emplace (*combo, true);
 
     // if the combo was not found in the predefined values this means that the default value in the JSON data can be
     // used so only define the ones that are not already defined
-    if (entry == this->m_combos.end ()) {
-
+    if (entry == this->m_combos.end () && entryOverride == this->m_overrideCombos.end ()) {
         // if no combo is defined just load the default settings
         if (defvalue == data.end ()) {
             // TODO: PROPERLY SUPPORT EMPTY COMBOS
@@ -406,6 +407,8 @@ void CShaderUnit::parseParameterConfiguration (
         // samplers can have special requirements, check what sampler we're working with and create definitions
         // if needed
         const auto textureName = data.find ("default");
+        // TODO: CREATE TEXTURE WITH THE GIVEN COLOR
+        const auto paintDefaultColor = data.find ("paintdefaultcolor");
         // extract the texture number from the name
         const char value = name.at (std::string ("g_Texture").length ());
         const auto requireany = data.find ("requireany");
@@ -414,6 +417,10 @@ void CShaderUnit::parseParameterConfiguration (
         // TODO: BETTER CONVERSION HERE
         size_t index = value - '0';
 
+        if (combo != data.end () && paintDefaultColor != data.end () && combo->get <std::string> () == "MASK" && this->m_file.find ("water")) {
+            sLog.debug("mask defaultcolor!");
+        }
+
         if (combo != data.end ()) {
             // TODO: CLEANUP HOW THIS IS DETERMINED FIRST
             // if the texture exists (and is not null), add to the combo
@@ -432,9 +439,10 @@ void CShaderUnit::parseParameterConfiguration (
                     for (const auto& item : require->items ()) {
                         const std::string& macro = item.key ();
                         const auto it = this->m_combos.find (macro);
+                        const auto itOverride = this->m_overrideCombos.find (macro);
 
                         // if any of the values matched, this option is required
-                        if (it == this->m_combos.end () || it->second != item.value ()) {
+                        if (it == this->m_combos.end () || itOverride != this->m_overrideCombos.end () || it->second != item.value ()) {
                             isRequired = true;
                             break;
                         }
@@ -446,9 +454,10 @@ void CShaderUnit::parseParameterConfiguration (
                     for (const auto& item : require->items ()) {
                         const std::string& macro = item.key ();
                         const auto it = this->m_combos.find (macro);
+                        const auto itOverride = this->m_overrideCombos.find (macro);
 
                         // these can not exist and that'd be fine, we just care about the values
-                        if (it != this->m_combos.end () && it->second == item.value ()) {
+                        if ((it != this->m_combos.end () || itOverride != this->m_overrideCombos.end ()) && it->second == item.value ()) {
                             isRequired = false;
                             break;
                         }
@@ -463,9 +472,10 @@ void CShaderUnit::parseParameterConfiguration (
                     // is the combo registered already?
                     // if not, add it with the default value
                     const auto combo_it = this->m_combos.find (*combo);
+                    const auto overridencombo_it = this->m_overrideCombos.find (*combo);
 
                     // there's already a combo providing this value, so it doesn't need to be added
-                    if (combo_it != this->m_combos.end ()) {
+                    if (combo_it != this->m_combos.end () || overridencombo_it != this->m_overrideCombos.end ()) {
                         isRequired = false;
                         // otherwise a default value must be used
                     } else if (defvalue->is_string ()) {
@@ -535,27 +545,42 @@ const std::string& CShaderUnit::compile () {
 
     std::map<std::string, bool> addedCombos;
 
+    for (const auto& combo : this->m_overrideCombos) {
+        if (addedCombos.find (combo.first) == addedCombos.end ()) {
+            this->m_final += DEFINE_COMBO (combo.first, combo.second);
+        }
+
+        addedCombos.emplace (combo.first, true);
+    }
     // now add all the combos to the source
     for (const auto& combo : this->m_combos) {
         if (addedCombos.find (combo.first) == addedCombos.end ()) {
             this->m_final += DEFINE_COMBO (combo.first, combo.second);
         }
+
+        addedCombos.emplace (combo.first, true);
     }
     for (const auto& combo : this->m_discoveredCombos) {
         if (addedCombos.find (combo.first) == addedCombos.end ()) {
             this->m_final += DEFINE_COMBO (combo.first, combo.second);
         }
+
+        addedCombos.emplace (combo.first, true);
     }
     if (this->m_link != nullptr) {
         for (const auto& combo : this->m_link->getCombos ()) {
             if (addedCombos.find (combo.first) == addedCombos.end ()) {
                 this->m_final += DEFINE_COMBO (combo.first, combo.second);
             }
+
+            addedCombos.emplace (combo.first, true);
         }
         for (const auto& combo : this->m_link->getDiscoveredCombos ()) {
             if (addedCombos.find (combo.first) == addedCombos.end ()) {
                 this->m_final += DEFINE_COMBO (combo.first, combo.second);
             }
+
+            addedCombos.emplace (combo.first, true);
         }
     }
 
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
index df365a3..19dc0c5 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
@@ -27,7 +27,7 @@ class CShaderUnit {
     CShaderUnit (
         CGLSLContext::UnitType type, std::string file, std::string content, const CContainer& container,
         const ShaderConstantMap& constants, const TextureMap& passTextures,
-        const TextureMap& overrideTextures, const ComboMap& combos);
+        const TextureMap& overrideTextures, const ComboMap& combos, const ComboMap& overrideCombos);
     ~CShaderUnit () = default;
 
     /**
@@ -132,6 +132,10 @@ class CShaderUnit {
      * Pre-defined values for the combos
      */
     const ComboMap& m_combos;
+    /**
+     * Pre-defined overriden values for the combos
+     */
+    const ComboMap& m_overrideCombos;
     /**
      * The combos discovered in the pre-processing step that were not in the combos list
      */

From 2eefc7ff64ee12141e852e0d014a4fe476728e0e Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sun, 17 Aug 2025 19:13:03 +0200
Subject: [PATCH 10/23] chore: update to latest glslang-WallpaperEngine version

---
 src/External/glslang-WallpaperEngine | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/External/glslang-WallpaperEngine b/src/External/glslang-WallpaperEngine
index 077d4f3..9fba00b 160000
--- a/src/External/glslang-WallpaperEngine
+++ b/src/External/glslang-WallpaperEngine
@@ -1 +1 @@
-Subproject commit 077d4f3c89bbfbb7951a9011d4551b075f092334
+Subproject commit 9fba00b655d79ef2fe6f05b459571bd3b1f119ea

From 806b65b490f8d365608808ed294084cf843e49fd Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Tue, 19 Aug 2025 10:35:33 +0200
Subject: [PATCH 11/23] chore: cleanup old Core stuff + update shader constant
 to use user settings as they should

---
 CMakeLists.txt                                | 51 -----------
 src/WallpaperEngine/Core/Core.cpp             |  4 -
 .../Core/DynamicValues/CDynamicValue.cpp      | 25 +++++
 .../Core/DynamicValues/CDynamicValue.h        |  1 +
 .../Core/Objects/CParticle.cpp                | 73 ---------------
 src/WallpaperEngine/Core/Objects/CParticle.h  | 60 ------------
 .../Effects/Constants/CShaderConstant.cpp     |  5 -
 .../Effects/Constants/CShaderConstant.h       | 40 --------
 .../Constants/CShaderConstantFloat.cpp        | 11 ---
 .../Effects/Constants/CShaderConstantFloat.h  | 17 ----
 .../Constants/CShaderConstantInteger.cpp      | 11 ---
 .../Constants/CShaderConstantInteger.h        | 17 ----
 .../Constants/CShaderConstantProperty.cpp     | 12 ---
 .../Constants/CShaderConstantProperty.h       | 20 ----
 .../Constants/CShaderConstantVector2.cpp      | 18 ----
 .../Constants/CShaderConstantVector2.h        | 19 ----
 .../Constants/CShaderConstantVector3.cpp      | 20 ----
 .../Constants/CShaderConstantVector3.h        | 18 ----
 .../Constants/CShaderConstantVector4.cpp      | 22 -----
 .../Constants/CShaderConstantVector4.h        | 18 ----
 .../Core/Objects/Particles/CControlPoint.cpp  | 28 ------
 .../Core/Objects/Particles/CControlPoint.h    | 39 --------
 .../Core/Objects/Particles/CEmitter.cpp       | 75 ---------------
 .../Core/Objects/Particles/CEmitter.h         | 65 -------------
 .../Core/Objects/Particles/CInitializer.cpp   | 59 ------------
 .../Core/Objects/Particles/CInitializer.h     | 56 ------------
 .../Particles/Initializers/CAlphaRandom.cpp   | 24 -----
 .../Particles/Initializers/CAlphaRandom.h     | 34 -------
 .../Initializers/CAngularVelocityRandom.cpp   | 24 -----
 .../Initializers/CAngularVelocityRandom.h     | 34 -------
 .../Particles/Initializers/CColorRandom.cpp   | 24 -----
 .../Particles/Initializers/CColorRandom.h     | 35 -------
 .../Initializers/CLifeTimeRandom.cpp          | 24 -----
 .../Particles/Initializers/CLifeTimeRandom.h  | 35 -------
 .../Initializers/CRotationRandom.cpp          | 77 ----------------
 .../Particles/Initializers/CRotationRandom.h  | 70 --------------
 .../Particles/Initializers/CSizeRandom.cpp    | 24 -----
 .../Particles/Initializers/CSizeRandom.h      | 35 -------
 .../Initializers/CTurbulentVelocityRandom.cpp | 46 ----------
 .../Initializers/CTurbulentVelocityRandom.h   | 54 -----------
 .../Initializers/CVelocityRandom.cpp          | 24 -----
 .../Particles/Initializers/CVelocityRandom.h  | 35 -------
 .../Core/UserSettings/CUserSettingBoolean.cpp | 91 -------------------
 .../Core/UserSettings/CUserSettingBoolean.h   | 25 -----
 .../Core/UserSettings/CUserSettingFloat.cpp   | 85 -----------------
 .../Core/UserSettings/CUserSettingFloat.h     | 26 ------
 .../Core/UserSettings/CUserSettingValue.cpp   |  5 -
 .../Core/UserSettings/CUserSettingValue.h     | 35 -------
 .../Core/UserSettings/CUserSettingVector3.cpp | 86 ------------------
 .../Core/UserSettings/CUserSettingVector3.h   | 28 ------
 .../Data/Builders/UserSettingBuilder.h        |  4 +-
 .../Data/Dumpers/StringPrinter.cpp            |  2 +-
 src/WallpaperEngine/Data/JSON.cpp             |  2 +-
 src/WallpaperEngine/Data/JSON.h               |  4 +-
 src/WallpaperEngine/Data/Model/Types.h        | 18 +---
 src/WallpaperEngine/Data/Model/UserSetting.h  |  1 +
 src/WallpaperEngine/Data/Model/Wallpaper.h    |  8 +-
 .../Data/Parsers/ShaderConstantParser.cpp     | 62 +------------
 .../Data/Parsers/ShaderConstantParser.h       |  1 -
 .../Data/Parsers/UserSettingParser.cpp        | 15 ++-
 .../Data/Parsers/UserSettingParser.h          |  2 +-
 src/WallpaperEngine/Render/Objects/CImage.cpp |  1 -
 .../Render/Objects/Effects/CPass.cpp          | 11 +--
 .../Render/Objects/Effects/CPass.h            |  3 -
 .../Render/Shaders/CShader.cpp                |  3 -
 src/WallpaperEngine/Render/Shaders/CShader.h  |  2 -
 .../Render/Shaders/CShaderUnit.cpp            |  6 --
 .../Render/Shaders/CShaderUnit.h              |  2 -
 68 files changed, 55 insertions(+), 1856 deletions(-)
 delete mode 100644 src/WallpaperEngine/Core/Objects/CParticle.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/CParticle.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
 delete mode 100644 src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingValue.cpp
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingValue.h
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
 delete mode 100644 src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6f72994..f9eeb54 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -407,15 +407,6 @@ add_executable(
     src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
     src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
 
-    src/WallpaperEngine/Core/UserSettings/CUserSettingValue.cpp
-    src/WallpaperEngine/Core/UserSettings/CUserSettingValue.h
-    src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
-    src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
-    src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
-    src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
-    src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
-    src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
-
     src/WallpaperEngine/Core/Projects/CProperty.h
     src/WallpaperEngine/Core/Projects/CProperty.cpp
     src/WallpaperEngine/Core/Projects/CPropertyColor.h
@@ -429,48 +420,6 @@ add_executable(
     src/WallpaperEngine/Core/Projects/CPropertyText.h
     src/WallpaperEngine/Core/Projects/CPropertyText.cpp
 
-#    src/WallpaperEngine/Core/Objects/CParticle.cpp
-#    src/WallpaperEngine/Core/Objects/CParticle.h
-
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.cpp
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h
-    src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp
-
-#    src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
-#    src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
-#    src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
-#
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
-#    src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
-
     src/WallpaperEngine/Data/Model/Types.h
     src/WallpaperEngine/Data/Model/Project.h
     src/WallpaperEngine/Data/Model/Wallpaper.h
diff --git a/src/WallpaperEngine/Core/Core.cpp b/src/WallpaperEngine/Core/Core.cpp
index 0f33015..2758281 100644
--- a/src/WallpaperEngine/Core/Core.cpp
+++ b/src/WallpaperEngine/Core/Core.cpp
@@ -1,12 +1,8 @@
 #include "Core.h"
 
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingFloat.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingVector3.h"
 #include "WallpaperEngine/Logging/CLog.h"
 
 using namespace WallpaperEngine;
-using namespace WallpaperEngine::Core::UserSettings;
 
 glm::vec4 Core::aToVector4 (const char* str) {
     float x = strtof (str, const_cast<char**> (&str));
diff --git a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
index f7c7750..49e1689 100644
--- a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
+++ b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
@@ -215,4 +215,29 @@ const bool& CDynamicValue::getBool () const {
 
 CDynamicValue::UnderlyingType CDynamicValue::getType () const {
     return this->m_type;
+}
+
+std::string CDynamicValue::toString () const {
+    switch (this->m_type) {
+        case UnderlyingType::Float:
+            return std::to_string (this->m_float);
+        case UnderlyingType::Int:
+            return std::to_string (this->m_int);
+        case UnderlyingType::Boolean:
+            return std::to_string (this->m_bool);
+        case UnderlyingType::Vec2:
+            return std::to_string (this->m_vec2.x) + ", " + std::to_string (this->m_vec2.y);
+        case UnderlyingType::Vec3:
+            return std::to_string (this->m_vec3.x) + ", " + std::to_string (this->m_vec3.y) + ", " + std::to_string (this->m_vec3.z);
+        case UnderlyingType::Vec4:
+            return std::to_string (this->m_vec4.x) + ", " + std::to_string (this->m_vec4.y) + ", " + std::to_string (this->m_vec4.z) + ", " + std::to_string (this->m_vec4.w);
+        case UnderlyingType::IVec2:
+            return std::to_string (this->m_ivec2.x) + ", " + std::to_string (this->m_ivec2.y);
+        case UnderlyingType::IVec3:
+            return std::to_string (this->m_ivec3.x) + ", " + std::to_string (this->m_ivec3.y) + ", " + std::to_string (this->m_ivec3.z);
+        case UnderlyingType::IVec4:
+            return std::to_string (this->m_ivec4.x) + ", " + std::to_string (this->m_ivec4.y) + ", " + std::to_string (this->m_ivec4.z) + ", " + std::to_string (this->m_ivec4.w);
+        default:
+            return "Unknown conversion for dynamic value of type: " + std::to_string (static_cast<int> (this->m_type));
+    }
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
index 7347da8..904fbba 100644
--- a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
+++ b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
@@ -44,6 +44,7 @@ class CDynamicValue {
     [[nodiscard]] const int& getInt () const;
     [[nodiscard]] const bool& getBool () const;
     [[nodiscard]] UnderlyingType getType () const;
+    [[nodiscard]] std::string toString () const;
 
     /**
      * Connects the current instance to the given instance, updating it's values
diff --git a/src/WallpaperEngine/Core/Objects/CParticle.cpp b/src/WallpaperEngine/Core/Objects/CParticle.cpp
deleted file mode 100644
index 11ec6ba..0000000
--- a/src/WallpaperEngine/Core/Objects/CParticle.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "CParticle.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects;
-
-const CParticle* CParticle::fromFile (
-    std::shared_ptr <const Core::CProject> project, const std::string& filename,
-    const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
-    const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* angles,
-    const CUserSettingVector3* scale, std::vector<int> dependencies
-) {
-    json data = json::parse (container->readFileAsString (filename));
-    const auto controlpoint_it = data.find ("controlpoint");
-    const auto emitter_it = jsonFindRequired (data, "emitter", "Particles must have emitters");
-    const auto initializer_it = jsonFindRequired (data, "initializer", "Particles must have initializers");
-
-    std::vector<const Particles::CControlPoint*> controlpoints;
-    std::vector<const Particles::CEmitter*> emitters;
-    std::vector<const Particles::CInitializer*> initializers;
-
-    if (controlpoint_it != data.end ())
-        for (const auto& cur : (*controlpoint_it))
-            controlpoints.push_back (Particles::CControlPoint::fromJSON (cur));
-
-    for (const auto& cur : (*emitter_it))
-        emitters.push_back (Particles::CEmitter::fromJSON (cur));
-    for (const auto& cur : (*initializer_it))
-        initializers.push_back (Particles::CInitializer::fromJSON (cur));
-
-    return new CParticle (
-        project,
-        jsonFindRequired <uint32_t> (data, "starttime", "Particles must have start time"),
-        jsonFindRequired <uint32_t> (data, "maxcount", "Particles must have maximum count"),
-        visible,
-        id,
-        name,
-        origin,
-        scale,
-        angles,
-        controlpoints,
-        emitters,
-        initializers,
-        std::move(dependencies)
-    );
-}
-
-CParticle::CParticle (
-    std::shared_ptr <const Core::CProject> project, uint32_t starttime, uint32_t maxcount,
-    const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
-    const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-    const std::vector<const Particles::CControlPoint*>& controlpoints,
-    const std::vector<const Particles::CEmitter*>& emitters,
-    const std::vector<const Particles::CInitializer*>& initializers, std::vector<int> dependencies
-) :
-    CObject (project, visible, id, name, origin, scale, angles, std::move(dependencies)),
-    m_starttime (starttime),
-    m_maxcount (maxcount),
-    m_controlpoints (controlpoints),
-    m_emitters (emitters),
-    m_initializers (initializers) {}
-
-const std::vector<const Particles::CEmitter*>& CParticle::getEmitters () const {
-    return this->m_emitters;
-}
-
-const std::vector<const Particles::CControlPoint*>& CParticle::getControlPoints () const {
-    return this->m_controlpoints;
-}
-
-const std::vector<const Particles::CInitializer*>& CParticle::getInitializers () const {
-    return this->m_initializers;
-}
diff --git a/src/WallpaperEngine/Core/Objects/CParticle.h b/src/WallpaperEngine/Core/Objects/CParticle.h
deleted file mode 100644
index 687b50e..0000000
--- a/src/WallpaperEngine/Core/Objects/CParticle.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CControlPoint.h"
-#include "WallpaperEngine/Core/Objects/Particles/CEmitter.h"
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include "WallpaperEngine/Core/CObject.h"
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects {
-using json = nlohmann::json;
-
-/**
- * Represents a particle system in the background
- */
-class CParticle : public CObject {
-    friend class CObject;
-
-  public:
-    static const CParticle* fromFile (
-        std::shared_ptr <const Core::CProject> project, const std::string& filename,
-        const std::shared_ptr<const CContainer>& container, const CUserSettingBoolean* visible, int id,
-        const std::string& name, const CUserSettingVector3* origin, const CUserSettingVector3* angles,
-        const CUserSettingVector3* scale, std::vector<int> dependencies);
-
-    /**
-     * @return The list of emitters for the particle system
-     */
-    [[nodiscard]] const std::vector<const Particles::CEmitter*>& getEmitters () const;
-    /**
-     * @return The list of control points for the particle system
-     */
-    [[nodiscard]] const std::vector<const Particles::CControlPoint*>& getControlPoints () const;
-    /**
-     * @return The list of initializers for the particle system
-     */
-    [[nodiscard]] const std::vector<const Particles::CInitializer*>& getInitializers () const;
-
-  protected:
-    CParticle (
-        std::shared_ptr <const Core::CProject> project, uint32_t starttime, uint32_t maxcount,
-        const CUserSettingBoolean* visible, int id, const std::string& name, const CUserSettingVector3* origin,
-        const CUserSettingVector3* scale, const CUserSettingVector3* angles,
-        const std::vector<const Particles::CControlPoint*>& controlpoints,
-        const std::vector<const Particles::CEmitter*>& emitters,
-        const std::vector<const Particles::CInitializer*>& initializers, std::vector<int> dependencies);
-
-  private:
-    /** The time at which the particle system should start emitting */
-    const uint32_t m_starttime;
-    /** Maximum number of particles at the same time */
-    const uint32_t m_maxcount;
-    /** List of control points */
-    const std::vector<const Particles::CControlPoint*> m_controlpoints;
-    /** List of emitters */
-    const std::vector<const Particles::CEmitter*> m_emitters;
-    /** List of initializers */
-    const std::vector<const Particles::CInitializer*> m_initializers;
-};
-} // namespace WallpaperEngine::Core::Objects
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp
deleted file mode 100644
index 2f7f343..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "CShaderConstant.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h
deleted file mode 100644
index df80be6..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <string>
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constants base class
- */
-class CShaderConstant : public DynamicValues::CDynamicValue {
-  public:
-    virtual ~CShaderConstant () = default;
-
-    template <class T> [[nodiscard]] const T* as () const {
-        if (is <T> ()) {
-            return static_cast <const T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] T* as () {
-        if (is <T> ()) {
-            return static_cast <T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] bool is () const {
-        return typeid (*this) == typeid(T);
-    }
-
-    /**
-     * @return String representation of the constant's value
-     */
-    [[nodiscard]] virtual std::string toString () const = 0;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.cpp b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.cpp
deleted file mode 100644
index 43eb304..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "CShaderConstantFloat.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantFloat::CShaderConstantFloat (float value) {
-    this->update (value);
-}
-
-std::string CShaderConstantFloat::toString () const {
-    return std::to_string (this->getFloat ());
-}
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h
deleted file mode 100644
index 6cc3eff..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of type float
- */
-class CShaderConstantFloat : public CShaderConstant {
-  public:
-    explicit CShaderConstantFloat (float value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.cpp b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.cpp
deleted file mode 100644
index 766d3a3..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-#include "CShaderConstantInteger.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantInteger::CShaderConstantInteger (int32_t value) {
-    this->update (value);
-}
-
-std::string CShaderConstantInteger::toString () const {
-    return std::to_string (this->getInt ());
-}
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h
deleted file mode 100644
index da70241..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of type integer
- */
-class CShaderConstantInteger : public CShaderConstant {
-  public:
-    explicit CShaderConstantInteger (int32_t value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp
deleted file mode 100644
index 18fbc99..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-#include "CShaderConstantProperty.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantProperty::CShaderConstantProperty (const std::shared_ptr <const CProperty>& property) {
-    property->connectOutgoing (this);
-}
-
-std::string CShaderConstantProperty::toString () const {
-    return "no string representation yet!";
-}
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h
deleted file mode 100644
index 2ce8c86..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-
-#include "CShaderConstant.h"
-
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-using namespace WallpaperEngine::Core::Projects;
-/**
- * Shader constant that comes from a property
- */
-class CShaderConstantProperty : public CShaderConstant {
-  public:
-    explicit CShaderConstantProperty (const std::shared_ptr <const CProperty>& property);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.cpp b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.cpp
deleted file mode 100644
index 28b7a35..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "CShaderConstantVector2.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantVector2::CShaderConstantVector2 (glm::vec2 value) {
-    this->update (value);
-}
-
-std::string CShaderConstantVector2::toString () const {
-    std::string result = "(";
-
-    result.append (std::to_string (this->getVec2 ().x));
-    result.append (",");
-    result.append (std::to_string (this->getVec2 ().y));
-    result.append (")");
-
-    return result;
-}
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h
deleted file mode 100644
index e9d6f3a..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of vector2 type
- */
-class CShaderConstantVector2 : public CShaderConstant {
-  public:
-    explicit CShaderConstantVector2 (glm::vec2 value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.cpp b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.cpp
deleted file mode 100644
index b588d28..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "CShaderConstantVector3.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantVector3::CShaderConstantVector3 (glm::vec3 value) {
-    this->update (value);
-}
-
-std::string CShaderConstantVector3::toString () const {
-    std::string result = "(";
-
-    result.append (std::to_string (this->getVec3 ().x));
-    result.append (",");
-    result.append (std::to_string (this->getVec3 ().y));
-    result.append (",");
-    result.append (std::to_string (this->getVec3 ().z));
-    result.append (")");
-
-    return result;
-}
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h
deleted file mode 100644
index 693d124..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <glm/vec3.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of vector3 type
- */
-class CShaderConstantVector3 : public CShaderConstant {
-  public:
-    explicit CShaderConstantVector3 (glm::vec3 value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.cpp b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.cpp
deleted file mode 100644
index 4cf2ee1..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include "CShaderConstantVector4.h"
-
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
-CShaderConstantVector4::CShaderConstantVector4 (glm::vec4 value) {
-    this->update (value);
-}
-
-std::string CShaderConstantVector4::toString () const {
-    std::string result = "(";
-
-    result.append (std::to_string (this->getVec4 ().x));
-    result.append (",");
-    result.append (std::to_string (this->getVec4 ().y));
-    result.append (",");
-    result.append (std::to_string (this->getVec4 ().z));
-    result.append (",");
-    result.append (std::to_string (this->getVec4 ().w));
-    result.append (")");
-
-    return result;
-}
diff --git a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h b/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h
deleted file mode 100644
index 119662d..0000000
--- a/src/WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include "CShaderConstant.h"
-
-#include <glm/vec4.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core::Objects::Effects::Constants {
-/**
- * Shader constant of vector4 type
- */
-class CShaderConstantVector4 : public CShaderConstant {
-  public:
-    explicit CShaderConstantVector4 (glm::vec4 value);
-
-    [[nodiscard]] std::string toString () const override;
-};
-} // namespace WallpaperEngine::Core::Objects::Effects::Constants
diff --git a/src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp b/src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
deleted file mode 100644
index 586bf3a..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/CControlPoint.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "CControlPoint.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles;
-
-const CControlPoint* CControlPoint::fromJSON (const json& data) {
-    return new CControlPoint (
-        jsonFindRequired <uint32_t> (data, "id", "Particle's control point must have id"),
-        jsonFindDefault (data, "flags", 0),
-        jsonFindDefault (data, "offset", glm::vec3())
-    );
-}
-
-CControlPoint::CControlPoint (uint32_t id, uint32_t flags, glm::vec3 offset) :
-    m_id (id),
-    m_flags (flags),
-    m_offset (offset) {}
-
-uint32_t CControlPoint::getId () const {
-    return this->m_id;
-}
-
-const glm::vec3& CControlPoint::getOffset () const {
-    return this->m_offset;
-}
-
-uint32_t CControlPoint::getFlags () const {
-    return this->m_flags;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h b/src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
deleted file mode 100644
index 734c714..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/CControlPoint.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles {
-using json = nlohmann::json;
-
-/**
- * Control point for particles
- */
-class CControlPoint {
-  public:
-    static const CControlPoint* fromJSON (const json& data);
-
-    /**
-     * @return The id of the controlpoint used for ordering purposes
-     */
-    [[nodiscard]] uint32_t getId () const;
-    /**
-     * @return The offset from origin
-     */
-    [[nodiscard]] const glm::vec3& getOffset () const;
-    /**
-     * @return Flags for the control point, controls how it should behave
-     */
-    [[nodiscard]] uint32_t getFlags () const;
-
-  protected:
-    explicit CControlPoint (uint32_t id, uint32_t flags, glm::vec3 offset);
-
-  private:
-    /** ID used for ordering purposes */
-    const uint32_t m_id;
-    /** Flags that control how it behaves */
-    const uint32_t m_flags;
-    /** The offset from starting position */
-    const glm::vec3 m_offset;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles
diff --git a/src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp b/src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
deleted file mode 100644
index d067c46..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/CEmitter.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#include "CEmitter.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::Objects::Particles;
-
-const CEmitter* CEmitter::fromJSON (const json& data) {
-    const auto distancemax_it = jsonFindRequired (data, "distancemax", "Particle emitter must have maximum distance");
-    const auto distancemin_it = jsonFindRequired (data, "distancemin", "Particle emitter must have minimum distance");
-
-    auto distancemin = glm::vec3(0);
-    auto distancemax = glm::vec3(0);
-
-    if (distancemin_it->is_number()) {
-        distancemin = glm::vec3(static_cast<uint32_t>(*distancemin_it));
-    } else {
-        distancemin = WallpaperEngine::Core::aToVector3(*distancemin_it);
-    }
-
-    if (distancemax_it->is_number()) {
-        distancemax = glm::vec3(static_cast<uint32_t>(*distancemax_it));
-    } else {
-        distancemax = WallpaperEngine::Core::aToVector3(*distancemax_it);
-    }
-
-    return new CEmitter (
-        jsonFindRequired <glm::vec3> (data, "directions", "Particle emitter must have direction specified"),
-        distancemax,
-        distancemin,
-        jsonFindDefault (data, "id", 0),
-        jsonFindRequired <std::string> (data, "name", "Particle emitter must have a name"),
-        jsonFindRequired <glm::vec3> (data, "origin", "Particle emitter must have an origin"),
-        jsonFindRequired <double> (data, "rate", "Particle emitter must have a rate")
-    );
-}
-
-CEmitter::CEmitter (
-    glm::vec3 directions, glm::vec3 distancemax, glm::vec3 distancemin, uint32_t id, std::string name, glm::vec3 origin,
-    double rate
-) :
-    m_directions (directions),
-    m_distancemax (distancemax),
-    m_distancemin (distancemin),
-    m_id (id),
-    m_name (std::move(name)),
-    m_origin (origin),
-    m_rate (rate) {}
-
-uint32_t CEmitter::getId () const {
-    return this->m_id;
-}
-
-const std::string& CEmitter::getName () const {
-    return this->m_name;
-}
-
-const glm::vec3& CEmitter::getDistanceMax () const {
-    return this->m_distancemax;
-}
-
-const glm::vec3& CEmitter::getDistanceMin () const {
-    return this->m_distancemin;
-}
-
-const glm::vec3& CEmitter::getDirections () const {
-    return this->m_directions;
-}
-
-const glm::vec3& CEmitter::getOrigin () const {
-    return this->m_origin;
-}
-
-const double CEmitter::getRate () const {
-    return this->m_rate;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/CEmitter.h b/src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
deleted file mode 100644
index c96cd3b..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/CEmitter.h
+++ /dev/null
@@ -1,65 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles {
-using json = nlohmann::json;
-
-/**
- * Particle emitter, controls the area where the particles have to be created
- */
-class CEmitter {
-  public:
-    static const CEmitter* fromJSON (const json& data);
-
-    /**
-     * @return The ID of the emitter
-     */
-    [[nodiscard]] uint32_t getId () const;
-    /**
-     * @return The name of the emitter, indicates what type of emission to do
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return The maximum distance a particle can travel before being dead
-     */
-    [[nodiscard]] const glm::vec3& getDistanceMax () const;
-    /**
-     * @return The minimum distance a particle can travel before being dead
-     */
-    [[nodiscard]] const glm::vec3& getDistanceMin () const;
-    /**
-     * @return The direction a particle should move to
-     */
-    [[nodiscard]] const glm::vec3& getDirections () const;
-    /**
-     * @return The center of the particle emission
-     */
-    [[nodiscard]] const glm::vec3& getOrigin () const;
-    /**
-     * @return The rate of particle emission
-     */
-    [[nodiscard]] const double getRate () const;
-
-  protected:
-    CEmitter (
-        glm::vec3 directions, glm::vec3 distancemax, glm::vec3 distancemin, uint32_t id, std::string name,
-        glm::vec3 origin, double rate);
-
-  private:
-    /** Direction the particles should move to */
-    const glm::vec3 m_directions;
-    /** Maximum distance before the particle is dead */
-    const glm::vec3 m_distancemax;
-    /** Minimum distance before the particle is dead */
-    const glm::vec3 m_distancemin;
-    /** ID of the emitter */
-    const uint32_t m_id;
-    /** Name of the emitter, indicates the type of emitter */
-    const std::string m_name;
-    /** The center of the emitter */
-    const glm::vec3 m_origin;
-    /** The rate of emission */
-    const double m_rate;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles
diff --git a/src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp b/src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
deleted file mode 100644
index 5d0be86..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/CInitializer.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "CInitializer.h"
-
-#include <utility>
-
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h"
-#include "WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles;
-
-const CInitializer* CInitializer::fromJSON (const json& data) {
-    const auto name = jsonFindRequired <std::string> (data, "name", "Particle's initializer must have a name");
-    const auto id = jsonFindDefault (data, "id", 0);
-
-    if (name == "lifetimerandom") {
-        return Initializers::CLifeTimeRandom::fromJSON (data, id);
-    }
-    if (name == "sizerandom") {
-        return Initializers::CSizeRandom::fromJSON (data, id);
-    }
-    if (name == "rotationrandom") {
-        return Initializers::CRotationRandom::fromJSON (data, id);
-    }
-    if (name == "velocityrandom") {
-        return Initializers::CVelocityRandom::fromJSON (data, id);
-    }
-    if (name == "colorrandom") {
-        return Initializers::CColorRandom::fromJSON (data, id);
-    }
-    if (name == "alpharandom") {
-        return Initializers::CAlphaRandom::fromJSON (data, id);
-    }
-    if (name == "angularvelocityrandom") {
-        return Initializers::CAngularVelocityRandom::fromJSON (data, id);
-    }
-    if (name == "turbulentvelocityrandom") {
-        return Initializers::CTurbulentVelocityRandom::fromJSON (data, id);
-    }
-
-    sLog.exception ("Found unknown initializer for particles: ", name);
-}
-
-CInitializer::CInitializer (uint32_t id, std::string name) :
-    m_id (id),
-    m_name (std::move(name)) {}
-
-const std::string& CInitializer::getName () const {
-    return this->m_name;
-}
-
-uint32_t CInitializer::getId () const {
-    return this->m_id;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/CInitializer.h b/src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
deleted file mode 100644
index b3884cb..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/CInitializer.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles {
-using json = nlohmann::json;
-
-/**
- * Initializer for particles, controls the different attributes a particle will have
- * on emission
- */
-class CInitializer {
-  public:
-    static const CInitializer* fromJSON (const json& data);
-
-    template <class T> [[nodiscard]] const T* as () const {
-        if (is <T> ()) {
-            return static_cast <const T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] T* as () {
-        if (is <T> ()) {
-            return static_cast <T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] bool is () const {
-        return typeid (*this) == typeid(T);
-    }
-
-    /**
-     * @return The name of the particle initializer, indicates what type of initialization to do
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return The id of the initializer
-     */
-    [[nodiscard]] uint32_t getId () const;
-
-  protected:
-    CInitializer (uint32_t id, std::string name);
-
-    virtual ~CInitializer() = default;
-
-  private:
-    /** ID for ordering purposes */
-    const uint32_t m_id;
-    /** The name of the initializer, indicates what type of initialization to do */
-    const std::string m_name;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
deleted file mode 100644
index 2d33066..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "CAlphaRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CAlphaRandom* CAlphaRandom::fromJSON (const json& data, uint32_t id) {
-    return new CAlphaRandom (
-        id,
-        jsonFindRequired<double> (data, "min", "Alpharandom initializer must have a minimum value"),
-        jsonFindRequired<double> (data, "max", "Alpharandom initializer must have a maximum value")
-    );
-}
-
-CAlphaRandom::CAlphaRandom (uint32_t id, double min, double max) :
-    CInitializer (id, "alpharandom"),
-    m_max (max),
-    m_min (min) {}
-
-double CAlphaRandom::getMinimum () const {
-    return this->m_min;
-}
-
-double CAlphaRandom::getMaximum () const {
-    return this->m_max;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
deleted file mode 100644
index 4c3e08b..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAlphaRandom.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base alpha for the particles
- */
-class CAlphaRandom : CInitializer {
-  public:
-    /**
-     * @return The minimum alpha value to be used
-     */
-    [[nodiscard]] double getMinimum () const;
-    /**
-     * @return The maximum alpha value to be used
-     */
-    [[nodiscard]] double getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CAlphaRandom* fromJSON (const json& data, uint32_t id);
-
-    CAlphaRandom (uint32_t id, double min, double max);
-
-  private:
-    /** Maximum alpha */
-    const double m_max;
-    /** Minimum alpha */
-    const double m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
deleted file mode 100644
index 838e90e..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "CAngularVelocityRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CAngularVelocityRandom* CAngularVelocityRandom::fromJSON (const json& data, uint32_t id) {
-    return new CAngularVelocityRandom (
-        id,
-        jsonFindRequired <glm::vec3> (data, "min", "Angularvelocityrandom initializer must have a minimum value"),
-        jsonFindRequired <glm::vec3> (data, "max", "Angularvelocityrandom initializer must have a maximum value")
-    );
-}
-
-CAngularVelocityRandom::CAngularVelocityRandom (uint32_t id, glm::vec3 min, glm::vec3 max) :
-    CInitializer (id, "angularvelocityrandom"),
-    m_max (max),
-    m_min (min) {}
-
-const glm::vec3& CAngularVelocityRandom::getMinimum () const {
-    return this->m_min;
-}
-
-const glm::vec3& CAngularVelocityRandom::getMaximum () const {
-    return this->m_max;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
deleted file mode 100644
index ffc99ee..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CAngularVelocityRandom.h
+++ /dev/null
@@ -1,34 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base angular velocity for particles
- */
-class CAngularVelocityRandom : CInitializer {
-  public:
-    /**
-     * @return Minimum angular velocity (direction * speed)
-     */
-    [[nodiscard]] const glm::vec3& getMinimum () const;
-    /**
-     * @return Maximum angular velocity (direction * speed)
-     */
-    [[nodiscard]] const glm::vec3& getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CAngularVelocityRandom* fromJSON (const json& data, uint32_t id);
-
-    CAngularVelocityRandom (uint32_t id, glm::vec3 min, glm::vec3 max);
-
-  private:
-    /** Maximum velocity (direction * speed) */
-    const glm::vec3 m_max;
-    /** Minimum velocity (direction * speed) */
-    const glm::vec3 m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
deleted file mode 100644
index e23c019..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "CColorRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CColorRandom* CColorRandom::fromJSON (const json& data, uint32_t id) {
-    return new CColorRandom (
-        id,
-        jsonFindRequired <glm::ivec3> (data, "min", "Colorrandom initializer must have a minimum value"),
-        jsonFindRequired <glm::ivec3> (data, "max", "Colorrandom initializer must have a maximum value")
-    );
-}
-
-CColorRandom::CColorRandom (uint32_t id, glm::ivec3 min, glm::ivec3 max) :
-    CInitializer (id, "colorrandom"),
-    m_max (max),
-    m_min (min) {}
-
-const glm::ivec3& CColorRandom::getMinimum () const {
-    return this->m_min;
-}
-
-const glm::ivec3& CColorRandom::getMaximum () const {
-    return this->m_max;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
deleted file mode 100644
index b84f30b..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CColorRandom.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base color
- */
-class CColorRandom : CInitializer {
-  public:
-    /**
-     * @return The minimum color to use (RGB)
-     */
-    [[nodiscard]] const glm::ivec3& getMinimum () const;
-    /**
-     * @return The maximum color to use (RGB)
-     */
-    [[nodiscard]] const glm::ivec3& getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CColorRandom* fromJSON (const json& data, uint32_t id);
-
-    CColorRandom (uint32_t id, glm::ivec3 min, glm::ivec3 max);
-
-  private:
-    /** Maximum color */
-    const glm::ivec3 m_max;
-    /** Minimum color */
-    const glm::ivec3 m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
deleted file mode 100644
index 421ca2e..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "CLifeTimeRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CLifeTimeRandom* CLifeTimeRandom::fromJSON (const json& data, uint32_t id) {
-    return new CLifeTimeRandom (
-        id,
-        jsonFindRequired <uint32_t> (data, "min", "Lifetimerandom initializer must have a minimum value"),
-        jsonFindRequired <uint32_t> (data, "max", "Lifetimerandom initializer must have a maximum value")
-    );
-}
-
-CLifeTimeRandom::CLifeTimeRandom (uint32_t id, uint32_t min, uint32_t max) :
-    CInitializer (id, "lifetimerandom"),
-    m_max (max),
-    m_min (min) {}
-
-uint32_t CLifeTimeRandom::getMinimum () const {
-    return this->m_min;
-}
-
-uint32_t CLifeTimeRandom::getMaximum () const {
-    return this->m_max;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
deleted file mode 100644
index efdf379..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CLifeTimeRandom.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the lifetime of each particle on startup
- */
-class CLifeTimeRandom : CInitializer {
-  public:
-    /**
-     * @return The minimum lifetime to be used
-     */
-    [[nodiscard]] uint32_t getMinimum () const;
-    /**
-     * @return The maximum lifetime to be used
-     */
-    [[nodiscard]] uint32_t getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CLifeTimeRandom* fromJSON (const json& data, uint32_t id);
-
-    CLifeTimeRandom (uint32_t id, uint32_t min, uint32_t max);
-
-  private:
-    /** Maximum lifetime */
-    const uint32_t m_max;
-    /** Minimum lifetime */
-    const uint32_t m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
deleted file mode 100644
index 0787bf7..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "CRotationRandom.h"
-
-#include "WallpaperEngine/Core/Core.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CRotationRandom* CRotationRandom::fromJSON (const json& data, uint32_t id) {
-    const auto min_it = data.find ("minVector");
-    const auto max_it = data.find ("max");
-
-    glm::vec3 minVector = glm::vec3 ();
-    glm::vec3 maxVector = glm::vec3 ();
-    double minNumber = 0.0f;
-    double maxNumber = 0.0f;
-    bool isMinVector = false;
-    bool isMaxVector = false;
-
-    if (min_it != data.end () && min_it->is_string ()) {
-        minVector = WallpaperEngine::Core::aToVector3 (*min_it);
-        isMinVector = true;
-    } else if (min_it != data.end () && min_it->is_number ()) {
-        minNumber = *min_it;
-        isMinVector = false;
-    }
-
-    if (max_it != data.end () && max_it->is_string ()) {
-        maxVector = WallpaperEngine::Core::aToVector3 (*max_it);
-        isMaxVector = true;
-    } else if (max_it != data.end () && max_it->is_number ()) {
-        maxNumber = *max_it;
-        isMaxVector = false;
-    }
-
-    return new CRotationRandom (id, minVector, minNumber, isMinVector, maxVector, maxNumber, isMaxVector);
-}
-
-CRotationRandom::CRotationRandom (uint32_t id, glm::vec3 minVector, double minNumber, bool isMinimumVector,
-                                  glm::vec3 maxVector, double maxNumber, bool isMaximumVector) :
-    CInitializer (id, "rotationrandom"),
-    m_maxVector (maxVector),
-    m_maxNumber (maxNumber),
-    m_minVector (minVector),
-    m_minNumber (minNumber),
-    m_isMinimumVector (isMinimumVector),
-    m_isMaximumVector (isMaximumVector) {}
-
-glm::vec3 CRotationRandom::getMinimumVector () const {
-    return this->m_minVector;
-}
-
-glm::vec3 CRotationRandom::getMaximumVector () const {
-    return this->m_maxVector;
-}
-
-double CRotationRandom::getMinimumNumber () const {
-    return this->m_minNumber;
-}
-
-double CRotationRandom::getMaximumNumber () const {
-    return this->m_maxNumber;
-}
-
-bool CRotationRandom::isMinimumVector () const {
-    return this->m_isMinimumVector;
-}
-
-bool CRotationRandom::isMinimumNumber () const {
-    return !this->m_isMinimumVector;
-}
-
-bool CRotationRandom::isMaximumVector () const {
-    return this->m_isMaximumVector;
-}
-
-bool CRotationRandom::isMaximumNumber () const {
-    return !this->m_isMaximumVector;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
deleted file mode 100644
index cc5d2ff..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CRotationRandom.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include <nlohmann/json.hpp>
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base rotation for the particles
- */
-class CRotationRandom : CInitializer {
-  public:
-    /**
-     * @return The minimum rotation in vector format if available
-     */
-    [[nodiscard]] glm::vec3 getMinimumVector () const;
-    /**
-     * @return The maximum rotation in vector format if available
-     */
-    [[nodiscard]] glm::vec3 getMaximumVector () const;
-    /**
-     * @return The minimum rotation in angle format if available
-     */
-    [[nodiscard]] double getMinimumNumber () const;
-    /**
-     * @return The maximum rotation in angle format if available
-     */
-    [[nodiscard]] double getMaximumNumber () const;
-
-    /**
-     * @return Indicates if the minimum rotation is a vector
-     */
-    [[nodiscard]] bool isMinimumVector () const;
-    /**
-     * @return Indicates if the minimum rotation is an angle
-     */
-    [[nodiscard]] bool isMinimumNumber () const;
-    /**
-     * @return Indicates if the maximum rotation is a vector
-     */
-    [[nodiscard]] bool isMaximumVector () const;
-    /**
-     * @return Indicates if the maximum rotation is an angle
-     */
-    [[nodiscard]] bool isMaximumNumber () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CRotationRandom* fromJSON (const json& data, uint32_t id);
-
-    CRotationRandom (uint32_t id, glm::vec3 minVector, double minNumber, bool isMinimumVector, glm::vec3 maxVector,
-                     double maxNumber, bool isMaximumVector);
-
-  private:
-    /** Maximum rotation vector */
-    const glm::vec3 m_maxVector;
-    /** Maximum rotation angle */
-    const double m_maxNumber;
-    /** Minimum rotation vector */
-    const glm::vec3 m_minVector;
-    /** Minimum rotation angle */
-    const double m_minNumber;
-
-    /** If minimum is a vector */
-    const bool m_isMinimumVector;
-    /** If maximum is a vector */
-    const bool m_isMaximumVector;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
deleted file mode 100644
index 191ff37..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "CSizeRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CSizeRandom* CSizeRandom::fromJSON (const json& data, uint32_t id) {
-    return new CSizeRandom (
-        id,
-        jsonFindRequired <uint32_t> (data, "min", "Sizerandom initializer must have a minimum value"),
-        jsonFindRequired <uint32_t> (data, "max", "Sizerandom initializer must have a maximum value")
-    );
-}
-
-CSizeRandom::CSizeRandom (uint32_t id, uint32_t min, uint32_t max) :
-    CInitializer (id, "sizerandom"),
-    m_max (max),
-    m_min (min) {}
-
-uint32_t CSizeRandom::getMinimum () const {
-    return this->m_min;
-}
-
-uint32_t CSizeRandom::getMaximum () const {
-    return this->m_max;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
deleted file mode 100644
index a398760..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CSizeRandom.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base size for the particles
- */
-class CSizeRandom : CInitializer {
-  public:
-    /**
-     * @return The minimum size to be used
-     */
-    [[nodiscard]] uint32_t getMinimum () const;
-    /**
-     * @return The maximum size to be used
-     */
-    [[nodiscard]] uint32_t getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CSizeRandom* fromJSON (const json& data, uint32_t id);
-
-    CSizeRandom (uint32_t id, uint32_t min, uint32_t max);
-
-  private:
-    /** Maximum size */
-    const uint32_t m_max;
-    /** Minimum size */
-    const uint32_t m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
deleted file mode 100644
index 40c92fb..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "CTurbulentVelocityRandom.h"
-
-#include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CTurbulentVelocityRandom* CTurbulentVelocityRandom::fromJSON (const json& data, uint32_t id) {
-    return new CTurbulentVelocityRandom (
-        id,
-        jsonFindRequired <double> (data, "phasemax", "TurbulentVelocityRandom initializer must have a phasemax value"),
-        jsonFindRequired <double> (data, "scale", "TurbulentVelocityRandom initializer must have a scale value"),
-        jsonFindRequired <double>(data, "timescale", "TurbulentVelocityRandom initializer must have a timescale value"),
-        jsonFindRequired <uint32_t> (data, "speedmin", "TurbulentVelocityRandom initializer must have a minimum speed value"),
-        jsonFindRequired <uint32_t> (data, "speedmax", "TurbulentVelocityRandom initializer must have a maximum speed value")
-    );
-}
-
-CTurbulentVelocityRandom::CTurbulentVelocityRandom (uint32_t id, double phasemax, double scale, double timescale,
-                                                    uint32_t speedmin, uint32_t speedmax) :
-    CInitializer (id, "turbulentvelocityrandom"),
-    m_phasemax (phasemax),
-    m_scale (scale),
-    m_timescale (timescale),
-    m_speedmin (speedmin),
-    m_speedmax (speedmax) {}
-
-double CTurbulentVelocityRandom::getPhaseMax () const {
-    return this->m_phasemax;
-}
-
-double CTurbulentVelocityRandom::getScale () const {
-    return this->m_scale;
-}
-
-double CTurbulentVelocityRandom::getTimeScale () const {
-    return this->m_timescale;
-}
-
-uint32_t CTurbulentVelocityRandom::getMinimumSpeed () const {
-    return this->m_speedmin;
-}
-
-uint32_t CTurbulentVelocityRandom::getMaximumSpeed () const {
-    return this->m_speedmax;
-}
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
deleted file mode 100644
index e1d2293..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CTurbulentVelocityRandom.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include <nlohmann/json.hpp>
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the turbulent velocity for the particles
- */
-class CTurbulentVelocityRandom : CInitializer {
-  public:
-    /**
-     * @return The phase to use
-     */
-    double getPhaseMax () const;
-    /**
-     * @return The scale to use
-     */
-    double getScale () const;
-    /**
-     * @return How time affects to the scale
-     */
-    double getTimeScale () const;
-    /**
-     * @return The minimum speed
-     */
-    uint32_t getMinimumSpeed () const;
-    /**
-     * @return The maximum speed
-     */
-    uint32_t getMaximumSpeed () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CTurbulentVelocityRandom* fromJSON (const json& data, uint32_t id);
-
-    CTurbulentVelocityRandom (uint32_t id, double phasemax, double scale, double timescale, uint32_t speedmin,
-                              uint32_t speedmax);
-
-  private:
-    /** Phase */
-    const double m_phasemax;
-    /** Scale */
-    const double m_scale;
-    /** Time scale, how the time affects the scale */
-    const double m_timescale;
-    /** Minimum speed */
-    const uint32_t m_speedmin;
-    /** Maximum speed */
-    const uint32_t m_speedmax;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
deleted file mode 100644
index 3559850..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "CVelocityRandom.h"
-
-using namespace WallpaperEngine::Core::Objects::Particles::Initializers;
-
-const CVelocityRandom* CVelocityRandom::fromJSON (const json& data, uint32_t id) {
-    return new CVelocityRandom (
-        id,
-        jsonFindRequired <glm::vec3> (data, "min", "Velocityrandom initializer must have a minimum value"),
-        jsonFindRequired <glm::vec3> (data, "max", "Velocityrandom initializer must have a maximum value")
-    );
-}
-
-CVelocityRandom::CVelocityRandom (uint32_t id, glm::vec3 min, glm::vec3 max) :
-    CInitializer (id, "velocityrandom"),
-    m_max (max),
-    m_min (min) {}
-
-const glm::vec3& CVelocityRandom::getMinimum () const {
-    return this->m_min;
-}
-
-const glm::vec3& CVelocityRandom::getMaximum () const {
-    return this->m_max;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h b/src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
deleted file mode 100644
index 1fb390a..0000000
--- a/src/WallpaperEngine/Core/Objects/Particles/Initializers/CVelocityRandom.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Core/Objects/Particles/CInitializer.h"
-
-#include "WallpaperEngine/Core/Core.h"
-
-namespace WallpaperEngine::Core::Objects::Particles::Initializers {
-/**
- * Initializer for particles that decides the base velocity for the particles
- */
-class CVelocityRandom : CInitializer {
-  public:
-    /**
-     * @return The minimum velocity (direction * speed)
-     */
-    [[nodiscard]] const glm::vec3& getMinimum () const;
-    /**
-     * @return The maximum velocity (direction * speed)
-     */
-    [[nodiscard]] const glm::vec3& getMaximum () const;
-
-  protected:
-    friend class CInitializer;
-
-    static const CVelocityRandom* fromJSON (const json& data, uint32_t id);
-
-    CVelocityRandom (uint32_t id, glm::vec3 min, glm::vec3 max);
-
-  private:
-    /** Maximum velocity */
-    const glm::vec3 m_max;
-    /** Minimum velocity */
-    const glm::vec3 m_min;
-};
-} // namespace WallpaperEngine::Core::Objects::Particles::Initializers
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
deleted file mode 100644
index ba6601f..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#include "CUserSettingBoolean.h"
-
-#include <utility>
-#include "WallpaperEngine/Core/Core.h"
-
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-#include "WallpaperEngine/Core/Projects/CPropertyBoolean.h"
-#include "WallpaperEngine/Core/Projects/CPropertyCombo.h"
-#include "WallpaperEngine/Core/Projects/CPropertySlider.h"
-#include "WallpaperEngine/Core/Projects/CPropertyText.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Projects;
-using namespace WallpaperEngine::Core::UserSettings;
-
-CUserSettingBoolean::CUserSettingBoolean (
-    bool hasCondition, bool defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue
-) :
-    CUserSettingValue (),
-    m_hasCondition (hasCondition),
-    m_source (source),
-    m_expectedValue (std::move(expectedValue)) {
-    this->update (defaultValue);
-
-    if (this->m_source != nullptr) {
-        this->m_source->subscribe ([this](const Projects::CProperty* property) -> void {
-            if (!this->m_hasCondition) {
-                this->update (property->getBool ());
-            } else if (property->is <CPropertyCombo> ()) {
-                this->update (
-                    property->as <CPropertyCombo> ()->translateValueToIndex (this->m_expectedValue) == property->getInt ()
-                );
-            } else {
-                sLog.error ("Cannot update boolean user setting for an unknown property type ", property->getType ());
-            }
-        });
-    }
-}
-
-const CUserSettingBoolean* CUserSettingBoolean::fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties) {
-    bool hasCondition = false;
-    std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
-    bool defaultValue;
-    std::string source;
-    std::string expectedValue;
-
-    if (data.is_object ()) {
-        auto animation = data.find ("animation");
-        auto userIt = data.find ("user");
-        defaultValue = jsonFindDefault (data, "value", true); // is this default value right?
-
-        if (userIt != data.end ()) {
-            if (userIt->is_string ()) {
-                source = *userIt;
-            } else {
-                hasCondition = true;
-                source = jsonFindRequired <std::string> (userIt, "name", "Name for conditional setting must be present");
-                expectedValue =
-                    jsonFindRequired <std::string> (userIt, "condition", "Condition for conditional setting must be present");
-            }
-
-            const auto propertyIt = properties.find (source);
-
-            if (propertyIt != properties.end ()) {
-                sourceProperty = propertyIt->second;
-            }
-
-            if (sourceProperty == nullptr) {
-                sLog.error ("Cannot find property ", source, " to get value from for user setting value, using default value: ", defaultValue);
-            }
-        } else {
-            sLog.error ("Boolean property doesn't have user member, this could mean an scripted value");
-        }
-
-        if (animation != data.end ()) {
-            sLog.error ("Detected a setting with animation data, which is not supported yet!");
-        }
-    } else {
-        if (!data.is_boolean ())
-            sLog.error ("Expected boolean value on user setting");
-
-        defaultValue = data.get<bool> ();
-    }
-
-    return new CUserSettingBoolean (hasCondition, defaultValue, sourceProperty, expectedValue);
-}
-
-const CUserSettingBoolean* CUserSettingBoolean::fromScalar (const bool value) {
-    return new CUserSettingBoolean (false, value, nullptr, "");
-}
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
deleted file mode 100644
index 8b6930e..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "CUserSettingValue.h"
-
-namespace WallpaperEngine::Core::Projects {
-class CProperty;
-}
-
-namespace WallpaperEngine::Core::UserSettings {
-class CUserSettingBoolean : public CUserSettingValue {
-  public:
-    typedef bool data_type;
-
-    static const CUserSettingBoolean* fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties);
-    static const CUserSettingBoolean* fromScalar (bool value);
-
-  private:
-    CUserSettingBoolean (
-        bool hasCondition, bool defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue);
-
-    const bool m_hasCondition;
-    const std::string m_expectedValue;
-    const std::shared_ptr <const Projects::CProperty> m_source;
-};
-} // namespace WallpaperEngine::Core::UserSettings
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
deleted file mode 100644
index 7e99230..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.cpp
+++ /dev/null
@@ -1,85 +0,0 @@
-#include "CUserSettingFloat.h"
-
-#include <utility>
-#include "WallpaperEngine/Core/Core.h"
-
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-#include "WallpaperEngine/Core/Projects/CPropertySlider.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Projects;
-using namespace WallpaperEngine::Core::UserSettings;
-
-CUserSettingFloat::CUserSettingFloat (
-    bool hasCondition, float defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue
-) :
-    CUserSettingValue (),
-    m_default (defaultValue),
-    m_hasCondition (hasCondition),
-    m_source (source),
-    m_expectedValue (std::move(expectedValue)) {
-    this->update (defaultValue);
-
-    if (this->m_source != nullptr) {
-        this->m_source->subscribe ([this](const Projects::CProperty* property) -> void {
-            if (!this->m_hasCondition) {
-                this->update (property->getFloat ());
-            } else {
-                sLog.error ("Don't know how to check for condition on a float property... Expected value: ", this->m_expectedValue);
-            }
-        });
-    }
-}
-
-const CUserSettingFloat* CUserSettingFloat::fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties) {
-    float defaultValue;
-    std::string source;
-    std::string expectedValue;
-    bool hasCondition = false;
-    std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
-
-    if (data.is_object ()) {
-        auto animation = data.find ("animation");
-        auto userIt = data.find ("user");
-        defaultValue = jsonFindDefault (data, "value", 1.0f); // is this default value right?
-
-        if (userIt != data.end ()) {
-            if (userIt->is_string ()) {
-                source = *userIt;
-            } else {
-                hasCondition = true;
-                source = jsonFindRequired <std::string> (userIt, "name", "Name for conditional setting must be present");
-                expectedValue =
-                    jsonFindRequired <std::string> (userIt, "condition", "Condition for conditional setting must be present");
-            }
-
-            const auto propertyIt = properties.find (source);
-
-            if (propertyIt != properties.end ()) {
-                sourceProperty = propertyIt->second;
-            }
-
-            if (sourceProperty == nullptr) {
-                sLog.error ("Cannot find property ", source, " to get value from for user setting value, using default value: ", defaultValue);
-            }
-
-        if (animation != data.end ()) {
-            sLog.error ("Detected a setting with animation data, which is not supported yet!");
-        }
-        } else {
-            sLog.error ("Float property doesn't have user member, this could mean an scripted value");
-        }
-    } else {
-        if (!data.is_number ())
-            sLog.exception ("Expected numeric value on user settings");
-
-        defaultValue = data.get<float> ();
-    }
-
-    return new CUserSettingFloat (hasCondition, defaultValue, sourceProperty, expectedValue);
-}
-
-const CUserSettingFloat* CUserSettingFloat::fromScalar (const float value) {
-    return new CUserSettingFloat (false, value, nullptr, "");
-}
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
deleted file mode 100644
index eea2fa1..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingFloat.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-#include "CUserSettingValue.h"
-
-namespace WallpaperEngine::Core::Projects {
-class CProperty;
-}
-
-namespace WallpaperEngine::Core::UserSettings {
-class CUserSettingFloat : public CUserSettingValue {
-  public:
-    typedef float data_type;
-
-    static const CUserSettingFloat* fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties);
-    static const CUserSettingFloat* fromScalar (float value);
-
-  private:
-    CUserSettingFloat (
-        bool hasCondition, float defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue);
-
-    const double m_default;
-    const bool m_hasCondition;
-    const std::shared_ptr <const Projects::CProperty> m_source;
-    const std::string m_expectedValue;
-};
-} // namespace WallpaperEngine::Core::UserSettings
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingValue.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingValue.cpp
deleted file mode 100644
index 5bcb172..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingValue.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "CUserSettingValue.h"
-
-#include <utility>
-
-using namespace WallpaperEngine::Core::UserSettings;
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingValue.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingValue.h
deleted file mode 100644
index 90ee8f7..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingValue.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-
-#include <nlohmann/json.hpp>
-
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-
-namespace WallpaperEngine::Core::UserSettings {
-using namespace WallpaperEngine::Core::DynamicValues;
-
-class CUserSettingValue : public CDynamicValue {
-  public:
-    template <class T> [[nodiscard]] const T* as () const {
-        if (is <T> ()) {
-            return static_cast <const T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] T* as () {
-        if (is <T> ()) {
-            return static_cast <T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] bool is () const {
-        return typeid (*this) == typeid(T);
-    }
-
-  protected:
-    virtual ~CUserSettingValue() = default;
-};
-} // namespace WallpaperEngine::Core::UserSettings
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
deleted file mode 100644
index a1c7659..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "CUserSettingVector3.h"
-
-#include <utility>
-#include "WallpaperEngine/Core/Core.h"
-
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-#include "WallpaperEngine/Core/Projects/CPropertyColor.h"
-#include "WallpaperEngine/Core/Projects/CPropertySlider.h"
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core;
-using namespace WallpaperEngine::Core::Projects;
-using namespace WallpaperEngine::Core::UserSettings;
-
-CUserSettingVector3::CUserSettingVector3 (
-    bool hasCondition, glm::vec3 defaultValue, std::shared_ptr <const Projects::CProperty> source, std::string expectedValue
-) :
-    CUserSettingValue (),
-    m_hasCondition (hasCondition),
-    m_source (source),
-    m_expectedValue (std::move(expectedValue)) {
-    this->update (defaultValue);
-
-    if (this->m_source != nullptr) {
-        this->m_source->subscribe ([this](const Projects::CProperty* property) -> void {
-            if (this->m_hasCondition) {
-                sLog.error ("Don't know how to check for condition on a float property... Expected value: ", this->m_expectedValue);
-                return;
-            }
-
-            this->update (property->getVec3 ());
-        });
-    }
-}
-
-const CUserSettingVector3* CUserSettingVector3::fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties) {
-    bool hasCondition = false;
-    std::shared_ptr <const Projects::CProperty> sourceProperty = nullptr;
-    glm::vec3 defaultValue;
-    std::string source;
-    std::string expectedValue;
-
-    if (data.is_object ()) {
-        auto animation = data.find ("animation");
-        auto userIt = data.find ("user");
-        defaultValue = jsonFindDefault (data, "value", glm::vec3()); // is this default value right?
-
-        if (userIt != data.end ()) {
-            if (userIt->is_string ()) {
-                source = *userIt;
-            } else {
-                hasCondition = true;
-                source = jsonFindRequired <std::string> (userIt, "name", "Name for conditional setting must be present");
-                expectedValue =
-                    jsonFindRequired <std::string> (userIt, "condition", "Condition for conditional setting must be present");
-            }
-
-            const auto propertyIt = properties.find (source);
-
-            if (propertyIt != properties.end ()) {
-                sourceProperty = propertyIt->second;
-            }
-
-            if (sourceProperty == nullptr) {
-                sLog.error ("Cannot find property ", source, " to get value from for user setting value, using default value: (", defaultValue.x, ",", defaultValue.y, ",", defaultValue.z, ")");
-            }
-        } else {
-            sLog.error ("Vector property doesn't have user member, this could mean an scripted value");
-        }
-
-        if (animation != data.end ()) {
-            sLog.error ("Detected a setting with animation data, which is not supported yet!");
-        }
-    } else {
-        if (!data.is_string ())
-            sLog.exception ("Expected vector value on user settings");
-
-        defaultValue = WallpaperEngine::Core::aToColorf (data.get<std::string> ().c_str ());
-    }
-
-    return new CUserSettingVector3 (hasCondition, defaultValue, sourceProperty, expectedValue);
-}
-
-const CUserSettingVector3* CUserSettingVector3::fromScalar (const glm::vec3 value) {
-    return new CUserSettingVector3 (false, value, nullptr, "");
-}
diff --git a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h b/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
deleted file mode 100644
index 992c461..0000000
--- a/src/WallpaperEngine/Core/UserSettings/CUserSettingVector3.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <glm/vec3.hpp>
-
-#include "CUserSettingValue.h"
-
-namespace WallpaperEngine::Core::Projects {
-class CProperty;
-}
-
-namespace WallpaperEngine::Core::UserSettings {
-class CUserSettingVector3 : public CUserSettingValue {
-  public:
-    typedef glm::vec3 data_type;
-
-    static const CUserSettingVector3* fromJSON (const nlohmann::json& data, const std::map <std::string, std::shared_ptr <Projects::CProperty>>& properties);
-    static const CUserSettingVector3* fromScalar (glm::vec3 value);
-
-  private:
-    CUserSettingVector3 (
-        bool hasCondition, glm::vec3 defaultValue, std::shared_ptr<const Projects::CProperty> source,
-        std::string expectedValue);
-
-    const bool m_hasCondition;
-    const std::shared_ptr <const Projects::CProperty> m_source;
-    const std::string m_expectedValue;
-};
-} // namespace WallpaperEngine::Core::UserSettings
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
index fbd63c9..bc5dfe5 100644
--- a/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
+++ b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
@@ -8,12 +8,12 @@ using namespace WallpaperEngine::Data::Model;
 class UserSettingBuilder {
   public:
     template <typename T>
-    static UserSettingSharedPtr fromValue (T defaultValue) {
+    static UserSettingUniquePtr fromValue (T defaultValue) {
         DynamicValueUniquePtr value = std::make_unique <DynamicValue> ();
 
         value->update (defaultValue);
 
-        return std::make_shared <UserSetting> (UserSetting {
+        return std::make_unique <UserSetting> (UserSetting {
             .value = std::move (value),
             .property = PropertyWeakPtr (),
             .condition = std::nullopt,
diff --git a/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
index 3e544a0..3a52b04 100644
--- a/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
+++ b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
@@ -191,7 +191,7 @@ void StringPrinter::printImageEffectPassOverride (const ImageEffectPassOverride&
 
         for (const auto& constant : imageEffectPass.constants) {
             this->lineEnd ();
-            this->m_out << "Constant " << constant.first << "=" << constant.second->toString();
+            this->m_out << "Constant " << constant.first << "=" << constant.second->value->toString();
         }
 
         this->decreaseIndentation ();
diff --git a/src/WallpaperEngine/Data/JSON.cpp b/src/WallpaperEngine/Data/JSON.cpp
index 41848c1..4371890 100644
--- a/src/WallpaperEngine/Data/JSON.cpp
+++ b/src/WallpaperEngine/Data/JSON.cpp
@@ -5,7 +5,7 @@
 using namespace WallpaperEngine::Data::JSON;
 using namespace WallpaperEngine::Data::Model;
 
-UserSettingSharedPtr JsonExtensions::user (const std::string& key, const Properties& properties) const {
+UserSettingUniquePtr JsonExtensions::user (const std::string& key, const Properties& properties) const {
     const auto value = this->require (key, "User setting without default value must be present");
 
     return UserSettingParser::parse (value, properties);
diff --git a/src/WallpaperEngine/Data/JSON.h b/src/WallpaperEngine/Data/JSON.h
index f3dc81d..b3564c3 100644
--- a/src/WallpaperEngine/Data/JSON.h
+++ b/src/WallpaperEngine/Data/JSON.h
@@ -130,9 +130,9 @@ class JsonExtensions {
 
         return (*it);
     }
-    [[nodiscard]] UserSettingSharedPtr user (const std::string& key, const Properties& properties) const;
+    [[nodiscard]] UserSettingUniquePtr user (const std::string& key, const Properties& properties) const;
     template <typename T>
-    [[nodiscard]] UserSettingSharedPtr user (const std::string& key, const Properties& properties, T defaultValue) const {
+    [[nodiscard]] UserSettingUniquePtr user (const std::string& key, const Properties& properties, T defaultValue) const {
         const auto value = this->optional (key);
 
         if (!value.has_value ()) {
diff --git a/src/WallpaperEngine/Data/Model/Types.h b/src/WallpaperEngine/Data/Model/Types.h
index 20a7f43..2b1c101 100644
--- a/src/WallpaperEngine/Data/Model/Types.h
+++ b/src/WallpaperEngine/Data/Model/Types.h
@@ -4,13 +4,6 @@
 
 #include "WallpaperEngine/Assets/CContainer.h"
 #include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h"
 #include "WallpaperEngine/Core/Projects/CProperty.h"
 
 namespace WallpaperEngine::Data::Model {
@@ -35,13 +28,6 @@ struct ModelStruct;
 
 // TODO: REMOVE ONCE THESE ARE RENAMED AND MOVED
 using Container = WallpaperEngine::Assets::CContainer;
-using ShaderConstant = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstant;
-using ShaderConstantProperty = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantProperty;
-using ShaderConstantFloat = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantFloat;
-using ShaderConstantInteger = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantInteger;
-using ShaderConstantVector2 = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantVector2;
-using ShaderConstantVector3 = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantVector3;
-using ShaderConstantVector4 = WallpaperEngine::Core::Objects::Effects::Constants::CShaderConstantVector4;
 
 using Property = WallpaperEngine::Core::Projects::CProperty;
 using PropertySharedPtr = std::shared_ptr <Property>;
@@ -52,11 +38,11 @@ using DynamicValueUniquePtr = std::unique_ptr <DynamicValue>;
 using DynamicValueSharedPtr = std::shared_ptr <DynamicValue>;
 using DynamicValueWeakPtr = std::weak_ptr <DynamicValue>;
 using UserSettingSharedPtr = std::shared_ptr <UserSetting>;
+using UserSettingUniquePtr = std::unique_ptr <UserSetting>;
 using UserSettingWeakPtr = std::weak_ptr <UserSetting>;
-using ShaderConstantUniquePtr = std::unique_ptr <ShaderConstant>;
 // TODO: UP TO THIS POINT
 
-using ShaderConstantMap = std::map <std::string, ShaderConstantUniquePtr>;
+using ShaderConstantMap = std::map <std::string, UserSettingUniquePtr>;
 
 using ProjectUniquePtr = std::unique_ptr <Project>;
 using WallpaperUniquePtr = std::unique_ptr <Wallpaper>;
diff --git a/src/WallpaperEngine/Data/Model/UserSetting.h b/src/WallpaperEngine/Data/Model/UserSetting.h
index 82612b9..ce3f46b 100644
--- a/src/WallpaperEngine/Data/Model/UserSetting.h
+++ b/src/WallpaperEngine/Data/Model/UserSetting.h
@@ -27,5 +27,6 @@ struct UserSetting {
     PropertyWeakPtr property;
     /** Condition required for this setting, this should be possible to run in JS' V8 */
     std::optional <ConditionInfo> condition;
+    /** TODO: Value might come from a script and not have conditions, implement this later */
 };
 } // namespace WallpaperEngine::Data::Model
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Wallpaper.h b/src/WallpaperEngine/Data/Model/Wallpaper.h
index 0717e56..327fff5 100644
--- a/src/WallpaperEngine/Data/Model/Wallpaper.h
+++ b/src/WallpaperEngine/Data/Model/Wallpaper.h
@@ -44,7 +44,7 @@ struct SceneData {
     struct {
         glm::vec3 ambient;
         glm::vec3 skylight;
-        UserSettingSharedPtr clear;
+        UserSettingUniquePtr clear;
     } colors;
     /**
      * Camera configuration
@@ -60,11 +60,11 @@ struct SceneData {
          */
         struct {
             /** If bloom is enabled or not */
-            UserSettingSharedPtr enabled;
+            UserSettingUniquePtr enabled;
             /** Bloom's strength to pass onto the shader */
-            UserSettingSharedPtr strength;
+            UserSettingUniquePtr strength;
             /** Bloom's threshold to pass onto the shader */
-            UserSettingSharedPtr threshold;
+            UserSettingUniquePtr threshold;
         } bloom;
         /**
          * Parallax effect configuration
diff --git a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
index 5e2c01b..066a330 100644
--- a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
@@ -1,5 +1,6 @@
 #include "ShaderConstantParser.h"
 
+#include "WallpaperEngine/Data/Parsers/UserSettingParser.h"
 #include "WallpaperEngine/Data/Model/Project.h"
 
 using namespace WallpaperEngine::Data::Parsers;
@@ -10,68 +11,11 @@ ShaderConstantMap ShaderConstantParser::parse (const JSON& it, Project& project)
         return {};
     }
 
-    std::map <std::string, ShaderConstantUniquePtr> result = {};
+    ShaderConstantMap result = {};
 
     for (const auto& cur : it.items ()) {
-        result.emplace (cur.key(), parseConstant (cur.value(), project));
+        result.emplace (cur.key(), UserSettingParser::parse (cur.value(), project.properties));
     }
 
     return result;
 }
-
-ShaderConstantUniquePtr ShaderConstantParser::parseConstant (const JSON& it, Project& project) {
-    ShaderConstant* constant = nullptr;
-    auto valueIt = it;
-
-    if (it.is_object ()) {
-        auto user = it.find ("user");
-        auto value = it.find ("value");
-
-        if (user == it.end () && value == it.end ()) {
-            sLog.error (R"(Found object for shader constant without "value" and "user" setting)");
-            return ShaderConstantUniquePtr (constant);
-        }
-
-        if (user != it.end () && user->is_string ()) {
-            const auto& properties = project.properties;
-            const auto& propertyIt = properties.find (*user);
-
-            if (propertyIt != properties.end ()) {
-                constant = new ShaderConstantProperty (propertyIt->second);
-            } else {
-                sLog.error ("Shader constant pointing to non-existant project property: ", user->get <std::string> ());
-            }
-        } else {
-            valueIt = *value;
-        }
-    }
-
-    // TODO: REFACTOR THIS, SAME OLD THING WE HAD BEFORE, THESE SHADERCONSTANT CLASSES HAVE TO GO AND WE SHOULD HAVE JUST ONE
-    if (constant == nullptr) {
-        if (valueIt.is_number_float ()) {
-            constant = new ShaderConstantFloat (valueIt);
-        } else if (valueIt.is_number_integer ()) {
-            constant = new ShaderConstantInteger (valueIt);
-        } else if (valueIt.is_string ()) {
-            // TODO: USE VECTOR PARSER HERE? MAKE USE OF CDYNAMICVALUE FOR SHADERCONSTANTS TOO
-
-            // count the number of spaces to determine which type of vector we have
-            std::string value = valueIt;
-
-            size_t spaces =
-                std::count_if (value.begin (), value.end (), [&] (const auto& item) { return item == ' '; });
-
-            if (spaces == 1) {
-                constant = new ShaderConstantVector2 (valueIt);
-            } else if (spaces == 2) {
-                constant = new ShaderConstantVector3 (valueIt);
-            } else if (spaces == 3) {
-                constant = new ShaderConstantVector4 (valueIt);
-            } else {
-                sLog.exception ("unknown shader constant type ", value);
-            }
-        }
-    }
-
-    return ShaderConstantUniquePtr (constant);
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
index 2911131..c02edd7 100644
--- a/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
+++ b/src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
@@ -10,6 +10,5 @@ using namespace WallpaperEngine::Data::Model;
 class ShaderConstantParser {
   public:
     static ShaderConstantMap parse (const JSON& it, Project& project);
-    static ShaderConstantUniquePtr parseConstant (const JSON& it, Project& project);
 };
 } // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp b/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
index 3ea6acd..9d7224a 100644
--- a/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
@@ -5,19 +5,26 @@
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Builders;
 
-UserSettingSharedPtr UserSettingParser::parse (const json& data, const Properties& properties) {
+UserSettingUniquePtr UserSettingParser::parse (const json& data, const Properties& properties) {
     DynamicValueUniquePtr value = std::make_unique <DynamicValue> ();
     PropertyWeakPtr property;
     std::optional<ConditionInfo> condition;
     auto valueIt = data;
+    std::string content = data.dump ();
 
     if (data.is_object ()) {
         const auto user = data.optional ("user");
+        const auto script = data.optional ("script");
         valueIt = data.require ("value", "User setting must have a value");
 
-        if (user.has_value ()) {
+        // TODO: PARSE SCRIPT VALUES
+        if (script.has_value () && !script->is_null ()) {
+            sLog.error ("Found user setting with script value: ", script.value ().dump ());
+        }
+
+        if (user.has_value () && !user->is_null ()) {
             std::string source;
-            const auto& it = user.value ();
+            const auto& it = *user;
 
             if (it.is_string ()) {
                 source = it;
@@ -61,7 +68,7 @@ UserSettingSharedPtr UserSettingParser::parse (const json& data, const Propertie
         sLog.exception ("Unsupported user setting type ", valueIt.type_name ());
     }
 
-    return std::make_shared <UserSetting> (UserSetting {
+    return std::make_unique <UserSetting> (UserSetting {
         .value = std::move (value),
         .property = property,
         .condition = condition,
diff --git a/src/WallpaperEngine/Data/Parsers/UserSettingParser.h b/src/WallpaperEngine/Data/Parsers/UserSettingParser.h
index 94508c8..758497b 100644
--- a/src/WallpaperEngine/Data/Parsers/UserSettingParser.h
+++ b/src/WallpaperEngine/Data/Parsers/UserSettingParser.h
@@ -11,6 +11,6 @@ using namespace WallpaperEngine::Data::Model;
 
 class UserSettingParser {
   public:
-    static UserSettingSharedPtr parse (const json& data, const Properties& properties);
+    static UserSettingUniquePtr parse (const json& data, const Properties& properties);
 };
 } // namespace WallpaperEngine::Data::Parsers
diff --git a/src/WallpaperEngine/Render/Objects/CImage.cpp b/src/WallpaperEngine/Render/Objects/CImage.cpp
index a4d36b2..d0ca2b0 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.cpp
+++ b/src/WallpaperEngine/Render/Objects/CImage.cpp
@@ -1,7 +1,6 @@
 #include "CImage.h"
 #include <sstream>
 
-#include "WallpaperEngine/Core/UserSettings/CUserSettingBoolean.h"
 #include "WallpaperEngine/Data/Parsers/MaterialParser.h"
 #include "WallpaperEngine/Data/Builders/UserSettingBuilder.h"
 #include "WallpaperEngine/Data/Model/Object.h"
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index 0dc01f3..433c89f 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -23,21 +23,12 @@
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.h"
 
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantProperty.h"
 #include "WallpaperEngine/Logging/CLog.h"
 
 using namespace WallpaperEngine;
 using namespace WallpaperEngine::Render;
 using namespace WallpaperEngine::Render::Objects;
 
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
-
 using namespace WallpaperEngine::Render::Shaders::Variables;
 using namespace WallpaperEngine::Render::Objects::Effects;
 
@@ -725,7 +716,7 @@ void CPass::setupShaderVariables () {
 
         // this takes care of all possible casts, even invalid ones, which will use whatever default behaviour
         // of the underlying CDynamicValue used for the value
-        this->addUniform (var, value.get ());
+        this->addUniform (var, value->value.get ());
     }
 }
 
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.h b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
index e853b41..b1eb6a1 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.h
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
@@ -4,8 +4,6 @@
 #include <utility>
 
 #include "WallpaperEngine/Assets/ITexture.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
-#include "WallpaperEngine/Core/UserSettings/CUserSettingValue.h"
 #include "WallpaperEngine/Render/CFBO.h"
 #include "WallpaperEngine/Render/CFBOProvider.h"
 #include "WallpaperEngine/Render/Helpers/CContextAware.h"
@@ -20,7 +18,6 @@ namespace WallpaperEngine::Render::Objects::Effects {
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Render::Shaders::Variables;
 using namespace WallpaperEngine::Core::Projects;
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
 using namespace WallpaperEngine::Data::Model;
 
 class CPass final : public Helpers::CContextAware {
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.cpp b/src/WallpaperEngine/Render/Shaders/CShader.cpp
index 6b5d424..947b9fd 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShader.cpp
@@ -3,9 +3,6 @@
 #include <utility>
 
 // shader compiler
-#include <WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h>
-#include <WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h>
-#include <WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h>
 #include <WallpaperEngine/Render/Shaders/CShader.h>
 #include <regex>
 
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.h b/src/WallpaperEngine/Render/Shaders/CShader.h
index 5bbe810..25e992b 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.h
+++ b/src/WallpaperEngine/Render/Shaders/CShader.h
@@ -7,7 +7,6 @@
 #include "WallpaperEngine/Assets/CContainer.h"
 #include "WallpaperEngine/Assets/ITexture.h"
 #include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
 
 #include "CShaderUnit.h"
@@ -18,7 +17,6 @@
 namespace WallpaperEngine::Render::Shaders {
 using json = nlohmann::json;
 using namespace WallpaperEngine::Assets;
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
 using namespace WallpaperEngine::Data::Model;
 
 /**
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index 915510f..45c1989 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -6,12 +6,6 @@
 #include <utility>
 #include "WallpaperEngine/Logging/CLog.h"
 
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantFloat.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantInteger.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector2.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector3.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstantVector4.h"
-
 #include "CGLSLContext.h"
 #include "WallpaperEngine/Assets/CAssetLoadException.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
index 19dc0c5..4974f44 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
@@ -7,7 +7,6 @@
 #include "CGLSLContext.h"
 #include "WallpaperEngine/Assets/CContainer.h"
 #include "WallpaperEngine/Core/Core.h"
-#include "WallpaperEngine/Core/Objects/Effects/Constants/CShaderConstant.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
 #include "nlohmann/json.hpp"
 
@@ -16,7 +15,6 @@
 namespace WallpaperEngine::Render::Shaders {
 using json = nlohmann::json;
 using namespace WallpaperEngine::Assets;
-using namespace WallpaperEngine::Core::Objects::Effects::Constants;
 using namespace WallpaperEngine::Data::Model;
 
 /**

From 4dc9a61223373f774740307266e8fe1c9e570312 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Tue, 19 Aug 2025 19:26:39 +0200
Subject: [PATCH 12/23] chore: cleanup of properties, dynamic values and shader
 variables

---
 CMakeLists.txt                                |  13 +-
 .../Application/CWallpaperApplication.cpp     |   2 +
 src/WallpaperEngine/Core/Core.cpp             | 498 ------------------
 src/WallpaperEngine/Core/Core.h               |  46 --
 .../Core/DynamicValues/CDynamicValue.h        |  95 ----
 .../Core/Projects/CProperty.cpp               |  30 +-
 src/WallpaperEngine/Core/Projects/CProperty.h |  49 +-
 .../Core/Projects/CPropertyBoolean.cpp        |   9 +-
 .../Core/Projects/CPropertyBoolean.h          |   6 +-
 .../Core/Projects/CPropertyColor.cpp          |  18 +-
 .../Core/Projects/CPropertyColor.h            |   8 +-
 .../Core/Projects/CPropertyCombo.cpp          |  19 +-
 .../Core/Projects/CPropertyCombo.h            |   6 +-
 .../Core/Projects/CPropertySlider.cpp         |  12 +-
 .../Core/Projects/CPropertySlider.h           |   8 +-
 .../Core/Projects/CPropertyText.cpp           |  10 +-
 .../Core/Projects/CPropertyText.h             |   6 +-
 .../Data/Builders/UserSettingBuilder.h        |   4 +-
 .../Data/Builders/VectorBuilder.h             |  19 +-
 src/WallpaperEngine/Data/JSON.cpp             |   1 +
 src/WallpaperEngine/Data/JSON.h               |  24 +-
 .../Model/DynamicValue.cpp}                   | 382 ++++++++------
 src/WallpaperEngine/Data/Model/DynamicValue.h | 105 ++++
 src/WallpaperEngine/Data/Model/Types.h        |  12 +-
 src/WallpaperEngine/Data/Model/UserSetting.h  |   4 +-
 .../Data/Parsers/ProjectParser.cpp            |   1 +
 src/WallpaperEngine/Data/Utils/SFINAE.h       |  25 +
 src/WallpaperEngine/Render/CFBOProvider.h     |   2 +
 .../Render/Objects/Effects/CPass.cpp          |   2 +-
 .../Render/Objects/Effects/CPass.h            |   2 +-
 src/WallpaperEngine/Render/Shaders/CShader.h  |   1 -
 .../Render/Shaders/CShaderUnit.cpp            |  56 +-
 .../Render/Shaders/CShaderUnit.h              |   4 +-
 .../Shaders/Variables/CShaderVariable.h       |  35 +-
 .../Variables/CShaderVariableFloat.cpp        |   8 +-
 .../Shaders/Variables/CShaderVariableFloat.h  |   3 +-
 .../Variables/CShaderVariableInteger.cpp      |  10 +-
 .../Variables/CShaderVariableInteger.h        |   5 +-
 .../Variables/CShaderVariableVector2.cpp      |   8 +-
 .../Variables/CShaderVariableVector2.h        |   3 +-
 .../Variables/CShaderVariableVector3.cpp      |   8 +-
 .../Variables/CShaderVariableVector3.h        |   3 +-
 .../Variables/CShaderVariableVector4.cpp      |   8 +-
 .../Variables/CShaderVariableVector4.h        |   3 +-
 .../Render/Wallpapers/CScene.cpp              |   2 -
 45 files changed, 512 insertions(+), 1063 deletions(-)
 delete mode 100644 src/WallpaperEngine/Core/Core.cpp
 delete mode 100644 src/WallpaperEngine/Core/Core.h
 delete mode 100644 src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
 rename src/WallpaperEngine/{Core/DynamicValues/CDynamicValue.cpp => Data/Model/DynamicValue.cpp} (65%)
 create mode 100644 src/WallpaperEngine/Data/Model/DynamicValue.h
 create mode 100644 src/WallpaperEngine/Data/Utils/SFINAE.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f9eeb54..49e64a0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -198,8 +198,7 @@ if(X11_SUPPORT_FOUND)
         src/WallpaperEngine/Render/Drivers/Output/CX11Output.cpp
         src/WallpaperEngine/Render/Drivers/Output/CX11Output.h
         src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.cpp
-        src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h
-            src/WallpaperEngine/Data/Model/UserSetting.h)
+        src/WallpaperEngine/Render/Drivers/Detectors/CX11FullScreenDetector.h)
     SET(X11_INCLUDES
         ${X11_INCLUDE_DIR}
         ${XRANDR_INCLUDE_DIR})
@@ -284,9 +283,6 @@ add_executable(
     src/WallpaperEngine/Assets/CTexture.h
     src/WallpaperEngine/Assets/CTexture.cpp
 
-    src/WallpaperEngine/Core/Core.h
-    src/WallpaperEngine/Core/Core.cpp
-
     src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp
     src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.h
     src/WallpaperEngine/Audio/Drivers/Recorders/CPlaybackRecorder.cpp
@@ -404,9 +400,6 @@ add_executable(
     src/WallpaperEngine/WebBrowser/CWebBrowserContext.cpp
     src/WallpaperEngine/WebBrowser/CWebBrowserContext.h
 
-    src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
-    src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
-
     src/WallpaperEngine/Core/Projects/CProperty.h
     src/WallpaperEngine/Core/Projects/CProperty.cpp
     src/WallpaperEngine/Core/Projects/CPropertyColor.h
@@ -427,8 +420,12 @@ add_executable(
     src/WallpaperEngine/Data/Model/Material.h
     src/WallpaperEngine/Data/Model/Effect.h
     src/WallpaperEngine/Data/Model/Model.h
+    src/WallpaperEngine/Data/Model/UserSetting.h
+    src/WallpaperEngine/Data/Model/DynamicValue.h
+    src/WallpaperEngine/Data/Model/DynamicValue.cpp
     src/WallpaperEngine/Data/Utils/TypeCaster.cpp
     src/WallpaperEngine/Data/Utils/TypeCaster.h
+    src/WallpaperEngine/Data/Utils/SFINAE.h
     src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
     src/WallpaperEngine/Data/Parsers/ProjectParser.h
     src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index e6a71f5..a32ec59 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -10,6 +10,8 @@
 #include "WallpaperEngine/Render/CRenderContext.h"
 #include "WallpaperEngine/Render/Drivers/CVideoFactories.h"
 
+#include "WallpaperEngine/Core/Projects/CProperty.h"
+
 #include "WallpaperEngine/Data/Parsers/ProjectParser.h"
 #include "WallpaperEngine/Data/Dumpers/StringPrinter.h"
 
diff --git a/src/WallpaperEngine/Core/Core.cpp b/src/WallpaperEngine/Core/Core.cpp
deleted file mode 100644
index 2758281..0000000
--- a/src/WallpaperEngine/Core/Core.cpp
+++ /dev/null
@@ -1,498 +0,0 @@
-#include "Core.h"
-
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine;
-
-glm::vec4 Core::aToVector4 (const char* str) {
-    float x = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float y = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float z = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float w = strtof (str, const_cast<char**> (&str));
-
-    return {x, y, z, w};
-}
-
-glm::vec3 Core::aToVector3 (const char* str) {
-    float x = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float y = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float z = strtof (str, const_cast<char**> (&str));
-
-    return {x, y, z};
-}
-
-glm::vec2 Core::aToVector2 (const char* str) {
-    float x = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float y = strtof (str, const_cast<char**> (&str));
-
-    return {x, y};
-}
-
-glm::ivec4 Core::aToVector4i (const char* str) {
-    int x = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int y = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int z = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int w = strtol (str, const_cast<char**> (&str), 10);
-
-    return {x, y, z, w};
-}
-
-glm::ivec3 Core::aToVector3i (const char* str) {
-    int x = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int y = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int z = strtol (str, const_cast<char**> (&str), 10);
-
-    return {x, y, z};
-}
-
-glm::ivec2 Core::aToVector2i (const char* str) {
-    int x = strtol (str, const_cast<char**> (&str), 10);
-    while (*str == ' ')
-        str++;
-    int y = strtol (str, const_cast<char**> (&str), 10);
-
-    return {x, y};
-}
-
-glm::vec4 Core::aToVector4 (const std::string& str) {
-    return Core::aToVector4 (str.c_str ());
-}
-
-glm::vec3 Core::aToVector3 (const std::string& str) {
-    return Core::aToVector3 (str.c_str ());
-}
-
-glm::vec2 Core::aToVector2 (const std::string& str) {
-    return Core::aToVector2 (str.c_str ());
-}
-
-glm::ivec4 Core::aToVector4i (const std::string& str) {
-    return Core::aToVector4i (str.c_str ());
-}
-
-glm::ivec3 Core::aToVector3i (const std::string& str) {
-    return Core::aToVector3i (str.c_str ());
-}
-
-glm::ivec2 Core::aToVector2i (const std::string& str) {
-    return Core::aToVector2i (str.c_str ());
-}
-
-glm::vec3 Core::aToColorf (const char* str) {
-    float r = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float g = strtof (str, const_cast<char**> (&str));
-    while (*str == ' ')
-        str++;
-    float b = strtof (str, const_cast<char**> (&str));
-
-    return {r, g, b};
-}
-
-glm::vec3 Core::aToColorf (const std::string& str) {
-    return aToColorf (str.c_str ());
-}
-
-glm::ivec3 Core::aToColori (const char* str) {
-    auto r = static_cast<uint8_t> (strtol (str, const_cast<char**> (&str), 10));
-    while (*str == ' ')
-        str++;
-    auto g = static_cast<uint8_t> (strtol (str, const_cast<char**> (&str), 10));
-    while (*str == ' ')
-        str++;
-    auto b = static_cast<uint8_t> (strtol (str, const_cast<char**> (&str), 10));
-
-    return {r, g, b};
-}
-
-glm::ivec3 Core::aToColori (const std::string& str) {
-    return aToColori (str.c_str ());
-}
-
-template <typename T> bool typeCheck (const nlohmann::json::const_iterator& value) {
-    if (value->type () == nlohmann::detail::value_t::null) {
-        return false;
-    }
-
-    // type checks
-    if constexpr ((std::is_same_v<T, float> || std::is_same_v<T, double>) ) {
-        if (value->type () != nlohmann::detail::value_t::number_float &&
-            value->type () != nlohmann::detail::value_t::number_integer &&
-            value->type () != nlohmann::detail::value_t::number_unsigned) {
-            return false;
-        }
-    } else if constexpr (std::is_same_v<T, std::string>) {
-        if (value->type () != nlohmann::detail::value_t::string) {
-            return false;
-        }
-    } else if constexpr (std::is_same_v<T, bool>) {
-        if (value->type () != nlohmann::detail::value_t::boolean) {
-            return false;
-        }
-    } else if constexpr (
-        std::is_same_v<T, glm::vec2> || std::is_same_v<T, glm::vec3> || std::is_same_v<T, glm::vec4> ||
-        std::is_same_v<T, glm::ivec2> || std::is_same_v<T, glm::ivec3> || std::is_same_v<T, glm::ivec4>) {
-        if (value->type () != nlohmann::detail::value_t::string) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-template <typename T> const T Core::jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg
-) {
-    const auto iterator = jsonFindRequired (data, key, notFoundMsg);
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, std::string>) {
-        // std::strings are special, type checking doesn't need to happen, we just want the string representation
-        // of whatever is in there
-        if (iterator->is_number_integer ()) {
-            return std::to_string (iterator->get <int> ());
-        } else if (iterator->is_number_float ()) {
-            return std::to_string (iterator->get <float> ());
-        } else if (iterator->is_boolean()) {
-            return std::to_string (iterator->get <bool> ());
-        } else if (iterator->is_null ()) {
-            return "null";
-        } else if (iterator->is_string ()) {
-            return *iterator;
-        }
-    } else if  constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2i (*iterator);
-    } else if (typeCheck<T> (iterator)) {
-        return *iterator;
-    }
-
-    sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), ": ", notFoundMsg);
-}
-
-template const bool Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const std::string Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const int16_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const uint16_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const int32_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const uint32_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const int64_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const uint64_t Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const float Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const double Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::vec4 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::vec3 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::vec2 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::ivec4 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::ivec3 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template const glm::ivec2 Core::jsonFindRequired (const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-
-template <typename T> const T Core::jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg
-) {
-    const auto iterator = jsonFindRequired (data, key, notFoundMsg);
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, std::string>) {
-        // std::strings are special, type checking doesn't need to happen, we just want the string representation
-        // of whatever is in there
-        if (iterator->is_number_integer ()) {
-            return std::to_string (iterator->get <int> ());
-        } else if (iterator->is_number_float ()) {
-            return std::to_string (iterator->get <float> ());
-        } else if (iterator->is_boolean()) {
-            return std::to_string (iterator->get <bool> ());
-        } else if (iterator->is_null ()) {
-            return "null";
-        } else if (iterator->is_string ()) {
-            return *iterator;
-        }
-    } else if constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2 (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector4i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector3i (*iterator);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (iterator)) {
-            sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), " expected vector-like-string", ": ", notFoundMsg);
-        }
-
-        return aToVector2i (*iterator);
-    } else if (typeCheck<T> (iterator)) {
-        return *iterator;
-    }
-
-    sLog.exception ("key value doesn't match expected type. Got ", iterator->type_name(), ": ", notFoundMsg);
-}
-
-template const bool Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const std::string Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const int16_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const uint16_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const int32_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const uint32_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const int64_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const uint64_t Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const float Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const double Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::vec4 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::vec3 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::vec2 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::ivec4 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::ivec3 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template const glm::ivec2 Core::jsonFindRequired (const nlohmann::json& data, const char* key, const char* notFoundMsg);
-
-nlohmann::json::const_iterator Core::jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg
-) {
-    auto value = data->find (key);
-
-    if (value == data->end ())
-        sLog.exception ("Cannot find required key (", key, ") in json: ", notFoundMsg);
-
-    return value;
-}
-
-nlohmann::json::const_iterator Core::jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg
-) {
-    auto value = data.find (key);
-
-    if (value == data.end ())
-        sLog.exception ("Cannot find required key (", key, ") in json: ", notFoundMsg);
-
-    return value;
-}
-
-template <typename T> const T Core::jsonFindDefault (
-    const nlohmann::json::const_iterator& data, const char* key, const T defaultValue
-) {
-    const auto value = data->find (key);
-
-    if (value == data->end () || value->type () == nlohmann::detail::value_t::null)
-        return defaultValue;
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, std::string>) {
-        // std::strings are special, type checking doesn't need to happen, we just want the string representation
-        // of whatever is in there
-        if (value->is_number_integer ()) {
-            return std::to_string (value->get <int> ());
-        } else if (value->is_number_float ()) {
-            return std::to_string (value->get <float> ());
-        } else if (value->is_boolean()) {
-            return std::to_string (value->get <bool> ());
-        } else if (value->is_null ()) {
-            return "null";
-        } else if (value->is_string ()) {
-            return *value;
-        }
-    } else if constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2 (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2i (*value);
-    } else if (typeCheck<T> (value)) {
-        return *value;
-    }
-
-    return defaultValue;
-}
-
-template const bool Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const bool defaultValue);
-template const std::string Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const std::string defaultValue);
-template const int16_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const int16_t defaultValue);
-template const uint16_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const uint16_t defaultValue);
-template const int32_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const int32_t defaultValue);
-template const uint32_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const uint32_t defaultValue);
-template const int64_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const int64_t defaultValue);
-template const uint64_t Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const uint64_t defaultValue);
-template const float Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const float defaultValue);
-template const double Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const double defaultValue);
-template const glm::vec2 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::vec2 defaultValue);
-template const glm::vec3 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::vec3 defaultValue);
-template const glm::vec4 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::vec4 defaultValue);
-template const glm::ivec2 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::ivec2 defaultValue);
-template const glm::ivec3 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::ivec3 defaultValue);
-template const glm::ivec4 Core::jsonFindDefault (const nlohmann::json::const_iterator& data, const char* key, const glm::ivec4 defaultValue);
-
-template <typename T> const T Core::jsonFindDefault (
-    const nlohmann::json& data, const char* key, const T defaultValue
-) {
-    const auto value = data.find (key);
-
-    if (value == data.end () || value->type () == nlohmann::detail::value_t::null)
-        return defaultValue;
-
-    // vector types need of special handling
-    if constexpr (std::is_same_v<T, glm::vec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3 (*value);
-    } else if constexpr (std::is_same_v<T, glm::vec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2 (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec4>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector4i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec3>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector3i (*value);
-    } else if constexpr (std::is_same_v<T, glm::ivec2>) {
-        if (!typeCheck<T> (value)) {
-            return defaultValue;
-        }
-
-        return aToVector2i (*value);
-    } else if (typeCheck<T> (value)) {
-        return *value;
-    }
-
-    return defaultValue;
-}
-
-template const bool Core::jsonFindDefault (const nlohmann::json& data, const char* key, const bool defaultValue);
-template const std::string Core::jsonFindDefault (const nlohmann::json& data, const char* key, const std::string defaultValue);
-template const int16_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const int16_t defaultValue);
-template const uint16_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const uint16_t defaultValue);
-template const int32_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const int32_t defaultValue);
-template const uint32_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const uint32_t defaultValue);
-template const int64_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const int64_t defaultValue);
-template const uint64_t Core::jsonFindDefault (const nlohmann::json& data, const char* key, const uint64_t defaultValue);
-template const float Core::jsonFindDefault (const nlohmann::json& data, const char* key, const float defaultValue);
-template const double Core::jsonFindDefault (const nlohmann::json& data, const char* key, const double defaultValue);
-template const glm::vec2 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::vec2 defaultValue);
-template const glm::vec3 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::vec3 defaultValue);
-template const glm::vec4 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::vec4 defaultValue);
-template const glm::ivec2 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec2 defaultValue);
-template const glm::ivec3 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec3 defaultValue);
-template const glm::ivec4 Core::jsonFindDefault (const nlohmann::json& data, const char* key, const glm::ivec4 defaultValue);
diff --git a/src/WallpaperEngine/Core/Core.h b/src/WallpaperEngine/Core/Core.h
deleted file mode 100644
index f3fb7fd..0000000
--- a/src/WallpaperEngine/Core/Core.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#pragma once
-
-#include <glm/mat4x4.hpp>
-#include <glm/vec2.hpp>
-#include <glm/vec3.hpp>
-#include <nlohmann/json.hpp>
-#include <string>
-
-namespace WallpaperEngine::Core {
-class CProject;
-
-glm::vec4 aToVector4 (const char* str);
-glm::vec3 aToVector3 (const char* str);
-glm::vec2 aToVector2 (const char* str);
-
-glm::vec4 aToVector4 (const std::string& str);
-glm::vec3 aToVector3 (const std::string& str);
-glm::vec2 aToVector2 (const std::string& str);
-
-glm::ivec4 aToVector4i (const char* str);
-glm::ivec3 aToVector3i (const char* str);
-glm::ivec2 aToVector2i (const char* str);
-
-glm::ivec4 aToVector4i (const std::string& str);
-glm::ivec3 aToVector3i (const std::string& str);
-glm::ivec2 aToVector2i (const std::string& str);
-
-glm::vec3 aToColorf (const char* str);
-glm::vec3 aToColorf (const std::string& str);
-
-glm::ivec3 aToColori (const char* str);
-glm::ivec3 aToColori (const std::string& str);
-
-template <typename T> const T jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-template <typename T> const T jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg);
-nlohmann::json::const_iterator jsonFindRequired (
-    const nlohmann::json::const_iterator& data, const char* key, const char* notFoundMsg);
-nlohmann::json::const_iterator jsonFindRequired (
-    const nlohmann::json& data, const char* key, const char* notFoundMsg);
-template <typename T> const T jsonFindDefault (
-    const nlohmann::json::const_iterator& data, const char* key, const T defaultValue);
-template <typename T> const T jsonFindDefault (
-    const nlohmann::json& data, const char* key, const T defaultValue);
-} // namespace WallpaperEngine::Core
diff --git a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h b/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
deleted file mode 100644
index 904fbba..0000000
--- a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.h
+++ /dev/null
@@ -1,95 +0,0 @@
-#pragma once
-
-#include <functional>
-#include <string>
-#include <vector>
-#include <glm/glm.hpp>
-
-namespace WallpaperEngine::Data::Parsers {
-class UserSettingParser;
-}
-
-namespace WallpaperEngine::Data::Builders {
-class UserSettingBuilder;
-}
-
-namespace WallpaperEngine::Core::DynamicValues {
-class CDynamicValue {
-    //TODO: THIS SHOULD BE CHANGED ONCE THINGS ARE FINISHED
-    friend class WallpaperEngine::Data::Parsers::UserSettingParser;
-    friend class WallpaperEngine::Data::Builders::UserSettingBuilder;
-  public:
-    enum UnderlyingType {
-        Unknown = -1,
-        IVec4 = 0,
-        IVec3 = 1,
-        IVec2 = 2,
-        Vec4 = 3,
-        Vec3 = 4,
-        Vec2 = 5,
-        Float = 6,
-        Int = 7,
-        Boolean = 8
-    };
-
-    virtual ~CDynamicValue ();
-
-    [[nodiscard]] const glm::ivec4& getIVec4 () const;
-    [[nodiscard]] const glm::ivec3& getIVec3 () const;
-    [[nodiscard]] const glm::ivec2& getIVec2 () const;
-    [[nodiscard]] const glm::vec4& getVec4 () const;
-    [[nodiscard]] const glm::vec3& getVec3 () const;
-    [[nodiscard]] const glm::vec2& getVec2 () const;
-    [[nodiscard]] const float& getFloat () const;
-    [[nodiscard]] const int& getInt () const;
-    [[nodiscard]] const bool& getBool () const;
-    [[nodiscard]] UnderlyingType getType () const;
-    [[nodiscard]] std::string toString () const;
-
-    /**
-     * Connects the current instance to the given instance, updating it's values
-     * based on current instance's changes
-     *
-     * @param value
-     */
-    void connectOutgoing (CDynamicValue* value) const;
-    void update (float newValue);
-    void update (int newValue);
-    void update (bool newValue);
-    void update (const glm::vec2& newValue);
-    void update (const glm::vec3& newValue);
-    void update (const glm::vec4& newValue);
-    void update (const glm::ivec2& newValue);
-    void update (const glm::ivec3& newValue);
-    void update (const glm::ivec4& newValue);
-
-  protected:
-    /**
-     * Registers an incoming connection (another CDynamicValue affecting the current instance's value)
-     * Useful mainly for destroying the connection on delete
-     *
-     * @param value
-     */
-    void connectIncoming (const CDynamicValue* value) const;
-    void destroyOutgoingConnection (CDynamicValue* value) const;
-    /**
-     * Propagates the current value to all it's connections
-     */
-    virtual void propagate () const;
-
-  private:
-    mutable std::vector<CDynamicValue*> m_outgoingConnections = {};
-    mutable std::vector<const CDynamicValue*> m_incomingConnections = {};
-    UnderlyingType m_type = UnderlyingType::Unknown;
-    // different values that we will be casted to automagically
-    glm::ivec4 m_ivec4 = {};
-    glm::ivec3 m_ivec3 = {};
-    glm::ivec2 m_ivec2 = {};
-    glm::vec4 m_vec4 = {};
-    glm::vec3 m_vec3 = {};
-    glm::vec2 m_vec2 = {};
-    float m_float = 0.0f;
-    int m_int = 0;
-    bool m_bool = false;
-};
-};
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Projects/CProperty.cpp b/src/WallpaperEngine/Core/Projects/CProperty.cpp
index ccfb1ef..0b40e9d 100644
--- a/src/WallpaperEngine/Core/Projects/CProperty.cpp
+++ b/src/WallpaperEngine/Core/Projects/CProperty.cpp
@@ -10,23 +10,23 @@
 
 using namespace WallpaperEngine::Core::Projects;
 
-std::shared_ptr<CProperty> CProperty::fromJSON (const json& data, const std::string& name) {
-    const auto type = jsonFindRequired (data, "type", "Project properties must have the type field");
+std::shared_ptr<CProperty> CProperty::fromJSON (const JSON& data, const std::string& name) {
+    const auto type = data.require <std::string> ("type", "Project properties must have the type field");
 
-    if (*type == "color")
+    if (type == "color")
         return CPropertyColor::fromJSON (data, name);
-    if (*type == "bool")
+    if (type == "bool")
         return CPropertyBoolean::fromJSON (data, name);
-    if (*type == "slider")
+    if (type == "slider")
         return CPropertySlider::fromJSON (data, name);
-    if (*type == "combo")
+    if (type == "combo")
         return CPropertyCombo::fromJSON (data, name);
-    if (*type == "text")
+    if (type == "text")
         return CPropertyText::fromJSON (data, name);
 
-    if (*type != "group") {
+    if (type != "group") {
         // show the error and ignore this property
-        sLog.error ("Unexpected type for property: ", *type);
+        sLog.error ("Unexpected type for property: ", type);
         sLog.error (data);
     }
 
@@ -37,18 +37,6 @@ CProperty::CProperty (std::string name, std::string text) :
     m_name (std::move(name)),
     m_text (std::move(text)) {}
 
-void CProperty::subscribe (const function_type& callback) const {
-    this->m_subscriptions.push_back (callback);
-}
-
-void CProperty::propagate () const {
-    CDynamicValue::propagate ();
-
-    for (const auto& callback : this->m_subscriptions) {
-        callback(this);
-    }
-}
-
 const std::string& CProperty::getName () const {
     return this->m_name;
 }
diff --git a/src/WallpaperEngine/Core/Projects/CProperty.h b/src/WallpaperEngine/Core/Projects/CProperty.h
index f172ae4..80f49a4 100644
--- a/src/WallpaperEngine/Core/Projects/CProperty.h
+++ b/src/WallpaperEngine/Core/Projects/CProperty.h
@@ -1,46 +1,26 @@
 #pragma once
 
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-#include "WallpaperEngine/Core/Core.h"
+#include "WallpaperEngine/Data/Utils/TypeCaster.h"
+#include "WallpaperEngine/Data/Model/DynamicValue.h"
+#include "WallpaperEngine/Data/JSON.h"
 
 namespace WallpaperEngine::Core::Projects {
-using json = nlohmann::json;
-using namespace WallpaperEngine::Core::DynamicValues;
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+using namespace WallpaperEngine::Data::Utils;
 /**
  * Represents a property in a background
  *
  * Properties are settings that alter how the background looks or works
  * and are configurable by the user so they can customize it to their likings
  */
-class CProperty : public CDynamicValue {
+class CProperty : public DynamicValue, public TypeCaster {
   public:
     using UniquePtr = std::unique_ptr<CProperty>;
     using SharedPtr = std::shared_ptr<CProperty>;
     using WeakPtr = std::weak_ptr<CProperty>;
 
-    typedef std::function<void(const CProperty*)> function_type;
-    virtual ~CProperty () = default;
-    static std::shared_ptr<CProperty> fromJSON (const json& data, const std::string& name);
-
-    template <class T> [[nodiscard]] const T* as () const {
-        if (is <T> ()) {
-            return static_cast <const T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] T* as () {
-        if (is <T> ()) {
-            return static_cast <T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] bool is () const {
-        return typeid (*this) == typeid(T);
-    }
+    static std::shared_ptr<CProperty> fromJSON (const JSON& data, const std::string& name);
 
     /**
      * @return Representation of what the property does and the default values
@@ -59,25 +39,14 @@ class CProperty : public CDynamicValue {
     /**
      * @return Textual type representation of this property
      */
-    [[nodiscard]] virtual const char* getType () const = 0;
+    [[nodiscard]] virtual const char* getPropertyType () const = 0;
     /**
      * @return Text of the property
      */
     [[nodiscard]] const std::string& getText () const;
-    /**
-     * Registers a function to be called when this instance's value changes
-     *
-     * @param callback
-     */
-    void subscribe (const function_type& callback) const;
 
   protected:
-    void propagate () const override;
-
     CProperty (std::string name, std::string text);
-
-    /** Functions to call when this property's value changes */
-    mutable std::vector<function_type> m_subscriptions;
     /** Name of the property */
     const std::string m_name;
     /** Description of the property for the user */
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp b/src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
index 0c59ce8..dc1d0f6 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
+++ b/src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
@@ -2,15 +2,14 @@
 #include <utility>
 
 #include "CPropertyBoolean.h"
-#include "WallpaperEngine/Core/Core.h"
 
 using namespace WallpaperEngine::Core::Projects;
 
-std::shared_ptr<CPropertyBoolean> CPropertyBoolean::fromJSON (const json& data, std::string name) {
+std::shared_ptr<CPropertyBoolean> CPropertyBoolean::fromJSON (const JSON& data, std::string name) {
     return std::make_shared <CPropertyBoolean> (
-        jsonFindRequired <bool> (data, "value", "Boolean property must have a value"),
+        data.require ("value", "Boolean property must have a value"),
         std::move(name),
-        jsonFindDefault<std::string> (data, "text", "")
+        data.optional <std::string> ("text", "")
     );
 }
 
@@ -31,7 +30,7 @@ std::string CPropertyBoolean::dump () const {
     return ss.str ();
 }
 
-const char* CPropertyBoolean::getType () const {
+const char* CPropertyBoolean::getPropertyType () const {
     return "bool";
 }
 
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.h b/src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
index ebaee63..72f3f85 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
+++ b/src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
@@ -3,7 +3,7 @@
 #include "CProperty.h"
 
 namespace WallpaperEngine::Core::Projects {
-using json = nlohmann::json;
+using JSON = WallpaperEngine::Data::JSON::JSON;
 
 /**
  * Represents a boolean property
@@ -12,10 +12,10 @@ class CPropertyBoolean final : public CProperty {
   public:
     CPropertyBoolean (bool value, std::string name, std::string text);
 
-    static std::shared_ptr<CPropertyBoolean> fromJSON (const json& data, std::string name);
+    static std::shared_ptr<CPropertyBoolean> fromJSON (const JSON& data, std::string name);
     [[nodiscard]] std::string dump () const override;
     void set (const std::string& value) override;
 
-    [[nodiscard]] const char* getType () const override;
+    [[nodiscard]] const char* getPropertyType () const override;
 };
 } // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp b/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
index 71f8a21..a60ff88 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
+++ b/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
@@ -3,6 +3,7 @@
 
 #include "CPropertyColor.h"
 
+using namespace WallpaperEngine::Data::Builders;
 using namespace WallpaperEngine::Core::Projects;
 
 glm::vec3 ParseColor (std::string value) {
@@ -13,19 +14,20 @@ glm::vec3 ParseColor (std::string value) {
     }
 
     if (value.find ('.') == std::string::npos && value != "0 0 0" && value != "1 1 1") {
-        const glm::ivec3 intcolor = WallpaperEngine::Core::aToColori (value);
+        const auto intcolor = VectorBuilder::parse <glm::ivec3> (value);
 
         return {intcolor.r / 255.0, intcolor.g / 255.0, intcolor.b / 255.0};
     }
 
-    return WallpaperEngine::Core::aToColorf (value);
+    return VectorBuilder::parse <glm::vec3> (value);
 }
 
-std::shared_ptr<CPropertyColor> CPropertyColor::fromJSON (const json& data, std::string name) {
-    const auto value = jsonFindRequired <std::string> (data, "value", "Color property must have a value");
-    const auto text = jsonFindDefault<std::string> (data, "text", "");
-
-    return std::make_shared <CPropertyColor> (value, std::move(name), text);
+std::shared_ptr<CPropertyColor> CPropertyColor::fromJSON (const JSON& data, std::string name) {
+    return std::make_shared <CPropertyColor> (
+        data.require ("value", "Color property must have a value"),
+        std::move(name),
+        data.optional <std::string> ("text", "")
+    );
 }
 
 void CPropertyColor::set (const std::string& value) {
@@ -45,7 +47,7 @@ std::string CPropertyColor::dump () const {
     return ss.str ();
 }
 
-const char* CPropertyColor::getType () const {
+const char* CPropertyColor::getPropertyType () const {
     return "color";
 }
 
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyColor.h b/src/WallpaperEngine/Core/Projects/CPropertyColor.h
index 317bbd5..4718e59 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyColor.h
+++ b/src/WallpaperEngine/Core/Projects/CPropertyColor.h
@@ -2,10 +2,10 @@
 
 #include "CProperty.h"
 
-#include "WallpaperEngine/Core/Core.h"
+#include "WallpaperEngine/Data/JSON.h"
 
 namespace WallpaperEngine::Core::Projects {
-using json = nlohmann::json;
+using JSON = WallpaperEngine::Data::JSON::JSON;
 
 /**
  * Represents a color property
@@ -14,10 +14,10 @@ class CPropertyColor final : public CProperty {
   public:
     CPropertyColor (const std::string& color, std::string name, std::string text);
 
-    static std::shared_ptr<CPropertyColor> fromJSON (const json& data, std::string name);
+    static std::shared_ptr<CPropertyColor> fromJSON (const JSON& data, std::string name);
     [[nodiscard]] std::string dump () const override;
     void set (const std::string& value) override;
 
-    [[nodiscard]] const char* getType () const override;
+    [[nodiscard]] const char* getPropertyType () const override;
 };
 } // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp b/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
index 96dac63..e73fd2a 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
+++ b/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
@@ -3,34 +3,33 @@
 
 #include "CPropertyCombo.h"
 
-#include "WallpaperEngine/Core/Core.h"
 #include "WallpaperEngine/Logging/CLog.h"
 
 using namespace WallpaperEngine::Core::Projects;
 
-std::shared_ptr<CPropertyCombo> CPropertyCombo::fromJSON (const json& data, std::string name) {
+std::shared_ptr<CPropertyCombo> CPropertyCombo::fromJSON (const JSON& data, std::string name) {
     std::vector<CPropertyComboValue> values;
-    const auto options = jsonFindRequired (data, "options", "Options for a property combo is required");
+    const auto options = data.require ("options", "Options for a property combo is required");
 
-    if (!options->is_array ())
+    if (!options.is_array ())
         sLog.exception ("Property combo options should be an array");
 
-    for (auto& cur : (*options)) {
+    for (auto& cur : options) {
         // TODO: PROPERLY REPORT THESE ISSUES
         if (!cur.is_object ())
             continue;
 
         // check for label and value to ensure they're there
         values.push_back ({
-            .label = jsonFindRequired<std::string> (cur, "label", "Label is required for a property combo option"),
-            .value = jsonFindRequired<std::string> (cur, "value", "Value is required for a property combo option")
+            .label = cur.require ("label", "Label is required for a property combo option"),
+            .value = cur.require ("value", "Value is required for a property combo option")
         });
     }
 
     return std::make_shared <CPropertyCombo> (
         std::move(name),
-        jsonFindDefault<std::string> (data, "text", ""),
-        jsonFindRequired<std::string> (data, "value", "Value is required for a property combo"),
+        data.optional <std::string> ("text", ""),
+        data.require ("value", "Value is required for a property combo"),
         values
     );
 }
@@ -102,6 +101,6 @@ int CPropertyCombo::translateValueToIndex (const std::string& value) const {
     return index;
 }
 
-const char* CPropertyCombo::getType () const {
+const char* CPropertyCombo::getPropertyType () const {
     return "combo";
 }
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyCombo.h b/src/WallpaperEngine/Core/Projects/CPropertyCombo.h
index d7015b1..9d7b323 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyCombo.h
+++ b/src/WallpaperEngine/Core/Projects/CPropertyCombo.h
@@ -3,7 +3,7 @@
 #include "CProperty.h"
 
 namespace WallpaperEngine::Core::Projects {
-using json = nlohmann::json;
+using JSON = WallpaperEngine::Data::JSON::JSON;;
 
 /**
  * Represents different combo values
@@ -23,7 +23,7 @@ struct CPropertyComboValue {
  */
 class CPropertyCombo final : public CProperty {
   public:
-    static std::shared_ptr<CPropertyCombo> fromJSON (const json& data, std::string name);
+    static std::shared_ptr<CPropertyCombo> fromJSON (const JSON& data, std::string name);
 
     CPropertyCombo (
         std::string name, std::string text, const std::string& defaultValue,
@@ -33,7 +33,7 @@ class CPropertyCombo final : public CProperty {
     void set (const std::string& value) override;
     int translateValueToIndex (const std::string& value) const;
 
-    [[nodiscard]] const char* getType () const override;
+    [[nodiscard]] const char* getPropertyType () const override;
 
   private:
     /** List of values available to select */
diff --git a/src/WallpaperEngine/Core/Projects/CPropertySlider.cpp b/src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
index d83e1ad..f8b7d47 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
+++ b/src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
@@ -4,12 +4,12 @@
 
 using namespace WallpaperEngine::Core::Projects;
 
-std::shared_ptr<CPropertySlider> CPropertySlider::fromJSON (const json& data, const std::string& name) {
+std::shared_ptr<CPropertySlider> CPropertySlider::fromJSON (const JSON& data, const std::string& name) {
     const auto value = data.find ("value");
-    const auto text = jsonFindDefault<std::string> (data, "text", "");
-    const auto min = jsonFindDefault (data, "min", 0.0f);
-    const auto max = jsonFindDefault (data, "max", 0.0f);
-    const auto step = jsonFindDefault (data, "step", 0.0f);
+    const auto text = data.optional <std::string> ("text", "");
+    const auto min = data.optional ("min", 0.0f);
+    const auto max = data.optional ("max", 0.0f);
+    const auto step = data.optional ("step", 0.0f);
 
     return std::make_shared <CPropertySlider> (*value, name, text, min, max, step);
 }
@@ -53,7 +53,7 @@ void CPropertySlider::set (const std::string& value) {
     this->update (newValue);
 }
 
-const char* CPropertySlider::getType () const {
+const char* CPropertySlider::getPropertyType () const {
     return "slider";
 }
 
diff --git a/src/WallpaperEngine/Core/Projects/CPropertySlider.h b/src/WallpaperEngine/Core/Projects/CPropertySlider.h
index 3366a4a..bfb13f2 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertySlider.h
+++ b/src/WallpaperEngine/Core/Projects/CPropertySlider.h
@@ -2,10 +2,8 @@
 
 #include "CProperty.h"
 
-#include "WallpaperEngine/Core/Core.h"
-
 namespace WallpaperEngine::Core::Projects {
-using json = nlohmann::json;
+using JSON = WallpaperEngine::Data::JSON::JSON;
 
 /**
  * Represents a slider value with a minimum and maximum value
@@ -14,7 +12,7 @@ class CPropertySlider final : public CProperty {
   public:
     CPropertySlider (float value, const std::string& name, const std::string& text, float min, float max, float step);
 
-    static std::shared_ptr<CPropertySlider> fromJSON (const json& data, const std::string& name);
+    static std::shared_ptr<CPropertySlider> fromJSON (const JSON& data, const std::string& name);
     /**
      * @return The slider's minimum value
      */
@@ -30,7 +28,7 @@ class CPropertySlider final : public CProperty {
     [[nodiscard]] std::string dump () const override;
     void set (const std::string& value) override;
 
-    [[nodiscard]] const char* getType () const override;
+    [[nodiscard]] const char* getPropertyType () const override;
 
   private:
     /** Minimum value */
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyText.cpp b/src/WallpaperEngine/Core/Projects/CPropertyText.cpp
index 3079bd5..6e27910 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyText.cpp
+++ b/src/WallpaperEngine/Core/Projects/CPropertyText.cpp
@@ -1,13 +1,15 @@
 #include "CPropertyText.h"
-#include "WallpaperEngine/Core/Core.h"
 #include <sstream>
 #include <utility>
 
 using namespace WallpaperEngine::Core::Projects;
 
-std::shared_ptr<CPropertyText> CPropertyText::fromJSON (const json& data, std::string name) {
+std::shared_ptr<CPropertyText> CPropertyText::fromJSON (const JSON& data, std::string name) {
     //TODO: VALIDATE THIS IS RIGHT
-    return std::make_shared <CPropertyText> (std::move(name), *data.find ("type"));
+    return std::make_shared <CPropertyText> (
+        std::move(name),
+        data.optional <std::string> ("text", "")
+    );
 }
 
 std::string CPropertyText::dump () const {
@@ -24,7 +26,7 @@ void CPropertyText::set (const std::string& value) {
     this->m_text = value;
 }
 
-const char* CPropertyText::getType () const {
+const char* CPropertyText::getPropertyType () const {
     return "text";
 }
 
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyText.h b/src/WallpaperEngine/Core/Projects/CPropertyText.h
index 07cd717..b64e88d 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyText.h
+++ b/src/WallpaperEngine/Core/Projects/CPropertyText.h
@@ -3,7 +3,7 @@
 #include "CProperty.h"
 
 namespace WallpaperEngine::Core::Projects {
-using json = nlohmann::json;
+using JSON = WallpaperEngine::Data::JSON::JSON;
 
 /**
  * Represents a text property
@@ -12,11 +12,11 @@ class CPropertyText final : public CProperty {
   public:
     CPropertyText (std::string name, std::string text);
 
-    static std::shared_ptr<CPropertyText> fromJSON (const json& data, std::string name);
+    static std::shared_ptr<CPropertyText> fromJSON (const JSON& data, std::string name);
     [[nodiscard]] std::string dump () const override;
     void set (const std::string& value) override;
 
-    [[nodiscard]] const char* getType () const override;
+    [[nodiscard]] const char* getPropertyType () const override;
   private:
 };
 } // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
index bc5dfe5..82c55cc 100644
--- a/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
+++ b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
@@ -9,9 +9,7 @@ class UserSettingBuilder {
   public:
     template <typename T>
     static UserSettingUniquePtr fromValue (T defaultValue) {
-        DynamicValueUniquePtr value = std::make_unique <DynamicValue> ();
-
-        value->update (defaultValue);
+        DynamicValueUniquePtr value = std::make_unique <DynamicValue> (defaultValue);
 
         return std::make_unique <UserSetting> (UserSetting {
             .value = std::move (value),
diff --git a/src/WallpaperEngine/Data/Builders/VectorBuilder.h b/src/WallpaperEngine/Data/Builders/VectorBuilder.h
index 5bf6f17..6d932a8 100644
--- a/src/WallpaperEngine/Data/Builders/VectorBuilder.h
+++ b/src/WallpaperEngine/Data/Builders/VectorBuilder.h
@@ -2,11 +2,15 @@
 
 #include <cstring>
 #include <string>
-#include <glm/glm.hpp>
+#include <glm/detail/qualifier.hpp>
+#include <glm/detail/type_vec1.hpp>
 
 #include "WallpaperEngine/Logging/CLog.h"
+#include "WallpaperEngine/Data/Utils/SFINAE.h"
 
 namespace WallpaperEngine::Data::Builders {
+using namespace WallpaperEngine::Data::Utils::SFINAE;
+
 class VectorBuilder {
   private:
     /**
@@ -60,7 +64,7 @@ class VectorBuilder {
      * @return
      */
     template <int length, typename type, glm::qualifier qualifier>
-    static glm::vec<length, type, qualifier> parse (const std::string& str) {
+    [[nodiscard]] static glm::vec<length, type, qualifier> parse (const std::string& str) {
         const char* p = str.c_str ();
 
         // get up to 4 spaces
@@ -118,6 +122,15 @@ class VectorBuilder {
             };
         }
     }
+    template <typename T, typename std::enable_if_t<is_glm_vec<T>::value, int> = 0>
+    [[nodiscard]] static T parse (const std::string& str) {
+        constexpr int length = GlmVecTraits<T>::length;
+        constexpr glm::qualifier qualifier = GlmVecTraits<T>::qualifier;
+
+        // call the specialized version of the function
+        return parse<length, typename GlmVecTraits<T>::type, qualifier> (str);
+    }
+  private:
 };
 
 template <>
@@ -127,7 +140,7 @@ inline float VectorBuilder::convert<float> (const char* str) {
 
 template <>
 inline int VectorBuilder::convert<int> (const char* str) {
-    return std::strtol (str, nullptr, 10);
+    return std::stoi (str);
 }
 
 template <>
diff --git a/src/WallpaperEngine/Data/JSON.cpp b/src/WallpaperEngine/Data/JSON.cpp
index 4371890..65cda15 100644
--- a/src/WallpaperEngine/Data/JSON.cpp
+++ b/src/WallpaperEngine/Data/JSON.cpp
@@ -4,6 +4,7 @@
 
 using namespace WallpaperEngine::Data::JSON;
 using namespace WallpaperEngine::Data::Model;
+using namespace WallpaperEngine::Data::Parsers;
 
 UserSettingUniquePtr JsonExtensions::user (const std::string& key, const Properties& properties) const {
     const auto value = this->require (key, "User setting without default value must be present");
diff --git a/src/WallpaperEngine/Data/JSON.h b/src/WallpaperEngine/Data/JSON.h
index b3564c3..0e08645 100644
--- a/src/WallpaperEngine/Data/JSON.h
+++ b/src/WallpaperEngine/Data/JSON.h
@@ -9,34 +9,14 @@
 
 #include "WallpaperEngine/Data/Builders/UserSettingBuilder.h"
 #include "WallpaperEngine/Data/Builders/VectorBuilder.h"
+#include "WallpaperEngine/Data/Utils/SFINAE.h"
 #include "WallpaperEngine/Data/Model/Types.h"
 #include "WallpaperEngine/Logging/CLog.h"
 
-namespace WallpaperEngine::Data::Parsers {
-class UserSettingParser;
-}
 namespace WallpaperEngine::Data::JSON {
 using namespace WallpaperEngine::Data::Builders;
-using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Model;
-
-// sfinae to detect the type for template specialization
-template <typename T>
-struct is_glm_vec : std::false_type {};
-
-template <glm::length_t L, typename S, glm::qualifier Q>
-struct is_glm_vec<glm::vec<L, S, Q>> : std::true_type {};
-
-// traits used to guess the type of the vector and it's length
-template <typename T>
-struct GlmVecTraits;
-
-template <glm::length_t L, typename T, glm::qualifier Q>
-struct GlmVecTraits<glm::vec<L, T, Q>> {
-    static constexpr int length = L;
-    using type = T;
-    static constexpr glm::qualifier qualifier = Q;
-};
+using namespace WallpaperEngine::Data::Utils::SFINAE;
 
 class JsonExtensions;
 
diff --git a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp b/src/WallpaperEngine/Data/Model/DynamicValue.cpp
similarity index 65%
rename from src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
rename to src/WallpaperEngine/Data/Model/DynamicValue.cpp
index 49e1689..7450ac3 100644
--- a/src/WallpaperEngine/Core/DynamicValues/CDynamicValue.cpp
+++ b/src/WallpaperEngine/Data/Model/DynamicValue.cpp
@@ -1,223 +1,89 @@
-#include <algorithm>
-#include "CDynamicValue.h"
+#include "DynamicValue.h"
 
-using namespace WallpaperEngine::Core::DynamicValues;
+using namespace WallpaperEngine::Data::Model;
 
-CDynamicValue::~CDynamicValue() {
-    for (auto* connection : this->m_incomingConnections) {
-        connection->destroyOutgoingConnection (this);
-    }
+DynamicValue::DynamicValue (const glm::ivec4& value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(float newValue) {
-    this->m_ivec4 = glm::ivec4(static_cast<int> (newValue));
-    this->m_ivec3 = glm::ivec3(static_cast<int> (newValue));
-    this->m_ivec2 = glm::ivec2(static_cast<int> (newValue));
-    this->m_vec4 = glm::vec4(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_float = newValue;
-    this->m_int = static_cast<int> (newValue);
-    this->m_bool = static_cast<int> (newValue) != 0;
-    this->m_type = UnderlyingType::Float;
-
-    this->propagate ();
+DynamicValue::DynamicValue (const glm::ivec3& value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(int newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec4 = glm::vec4(static_cast<float> (newValue));
-    this->m_vec3 = glm::vec3(static_cast<float> (newValue));
-    this->m_vec2 = glm::vec2(static_cast<float> (newValue));
-    this->m_float = static_cast<float> (newValue);
-    this->m_int = newValue;
-    this->m_bool = newValue != 0;
-    this->m_type = UnderlyingType::Int;
-
-    this->propagate ();
+DynamicValue::DynamicValue (const glm::ivec2& value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(bool newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec4 = glm::vec4(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_float = newValue;
-    this->m_int = newValue;
-    this->m_bool = newValue;
-    this->m_type = UnderlyingType::Boolean;
-
-    this->propagate ();
+DynamicValue::DynamicValue (const glm::vec4& value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(const glm::vec2& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0, 0);
-    this->m_ivec3 = glm::ivec3(newValue, 0);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = newValue;
-    this->m_vec3 = glm::vec3(newValue, 0.0f);
-    this->m_vec4 = glm::vec4(newValue, 0.0f, 0.0f);
-    this->m_float = newValue.x;
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0.0f;
-    this->m_type = UnderlyingType::Vec2;
-
-    this->propagate ();
+DynamicValue::DynamicValue (const glm::vec3& value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(const glm::vec3& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = newValue;
-    this->m_vec4 = glm::vec4(newValue, 0.0f);
-    this->m_float = newValue.x;
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0.0f;
-    this->m_type = UnderlyingType::Vec3;
-
-    this->propagate ();
+DynamicValue::DynamicValue (const glm::vec2& value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(const glm::vec4& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec4 = newValue;
-    this->m_float = newValue.x;
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0.0f;
-    this->m_type = UnderlyingType::Vec4;
-
-    this->propagate ();
+DynamicValue::DynamicValue (float value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(const glm::ivec2& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0, 0);
-    this->m_ivec3 = glm::ivec3(newValue, 0);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = newValue;
-    this->m_vec3 = glm::vec3(newValue, 0.0f);
-    this->m_vec4 = glm::vec4(newValue, 0.0f, 0.0f);
-    this->m_float = static_cast<float> (newValue.x);
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0;
-    this->m_type = UnderlyingType::IVec2;
-
-    this->propagate ();
+DynamicValue::DynamicValue (int value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(const glm::ivec3& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue, 0);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = newValue;
-    this->m_vec4 = glm::vec4(newValue, 0.0f);
-    this->m_float = static_cast<float> (newValue.x);
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0;
-    this->m_type = UnderlyingType::IVec3;
-
-    this->propagate ();
+DynamicValue::DynamicValue (bool value) {
+    this->update (value);
 }
 
-void CDynamicValue::update(const glm::ivec4& newValue) {
-    this->m_ivec4 = glm::ivec4(newValue);
-    this->m_ivec3 = glm::ivec3(newValue);
-    this->m_ivec2 = glm::ivec2(newValue);
-    this->m_vec2 = glm::vec2(newValue);
-    this->m_vec3 = glm::vec3(newValue);
-    this->m_vec4 = newValue;
-    this->m_float = static_cast<float> (newValue.x);
-    this->m_int = static_cast<int> (newValue.x);
-    this->m_bool = newValue.x != 0;
-    this->m_type = UnderlyingType::IVec4;
-
-    this->propagate ();
+DynamicValue::~DynamicValue () {
+    this->disconnect ();
+    this->m_listeners.clear ();
 }
 
-void CDynamicValue::connectOutgoing (CDynamicValue* value) const {
-    this->m_outgoingConnections.push_back (value);
-
-    // ensure that new connection has the right value
-    this->propagate ();
-    // ensure the other value keeps track of our connection too
-    value->connectIncoming (this);
-}
-
-void CDynamicValue::connectIncoming (const CDynamicValue* value) const {
-    this->m_incomingConnections.push_back (value);
-}
-
-void CDynamicValue::destroyOutgoingConnection (CDynamicValue* value) const {
-    this->m_outgoingConnections.erase (
-        std::remove (this->m_outgoingConnections.begin (), this->m_outgoingConnections.end (), value), this->m_outgoingConnections.end ()
-    );
-}
-
-void CDynamicValue::propagate () const {
-    for (auto* cur : this->m_outgoingConnections) {
-        cur->m_bool = this->m_bool;
-        cur->m_int = this->m_int;
-        cur->m_float = this->m_float;
-        cur->m_ivec2 = this->m_ivec2;
-        cur->m_ivec3 = this->m_ivec3;
-        cur->m_ivec4 = this->m_ivec4;
-        cur->m_vec2 = this->m_vec2;
-        cur->m_vec3 = this->m_vec3;
-        cur->m_vec4 = this->m_vec4;
-    }
-}
-
-const glm::ivec4& CDynamicValue::getIVec4 () const {
+const glm::ivec4& DynamicValue::getIVec4 () const {
     return this->m_ivec4;
 }
 
-const glm::ivec3& CDynamicValue::getIVec3 () const {
+const glm::ivec3& DynamicValue::getIVec3 () const {
     return this->m_ivec3;
 }
 
-const glm::ivec2& CDynamicValue::getIVec2 () const {
+const glm::ivec2& DynamicValue::getIVec2 () const {
     return this->m_ivec2;
 }
 
-const glm::vec4& CDynamicValue::getVec4 () const {
+const glm::vec4& DynamicValue::getVec4 () const {
     return this->m_vec4;
 }
 
-const glm::vec3& CDynamicValue::getVec3 () const {
+const glm::vec3& DynamicValue::getVec3 () const {
     return this->m_vec3;
 }
 
-const glm::vec2& CDynamicValue::getVec2 () const {
+const glm::vec2& DynamicValue::getVec2 () const {
     return this->m_vec2;
 }
 
-const float& CDynamicValue::getFloat () const {
+const float& DynamicValue::getFloat () const {
     return this->m_float;
 }
 
-const int& CDynamicValue::getInt () const {
+const int& DynamicValue::getInt () const {
     return this->m_int;
 }
 
-const bool& CDynamicValue::getBool () const {
+const bool& DynamicValue::getBool () const {
     return this->m_bool;
 }
 
-CDynamicValue::UnderlyingType CDynamicValue::getType () const {
+DynamicValue::UnderlyingType DynamicValue::getType () const {
     return this->m_type;
 }
 
-std::string CDynamicValue::toString () const {
+std::string DynamicValue::toString () const {
     switch (this->m_type) {
         case UnderlyingType::Float:
             return std::to_string (this->m_float);
@@ -240,4 +106,184 @@ std::string CDynamicValue::toString () const {
         default:
             return "Unknown conversion for dynamic value of type: " + std::to_string (static_cast<int> (this->m_type));
     }
+}
+
+void DynamicValue::update(float newValue) {
+    this->m_ivec4 = glm::ivec4(static_cast<int> (newValue));
+    this->m_ivec3 = glm::ivec3(static_cast<int> (newValue));
+    this->m_ivec2 = glm::ivec2(static_cast<int> (newValue));
+    this->m_vec4 = glm::vec4(newValue);
+    this->m_vec3 = glm::vec3(newValue);
+    this->m_vec2 = glm::vec2(newValue);
+    this->m_float = newValue;
+    this->m_int = static_cast<int> (newValue);
+    this->m_bool = static_cast<int> (newValue) != 0;
+    this->m_type = UnderlyingType::Float;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(int newValue) {
+    this->m_ivec4 = glm::ivec4(newValue);
+    this->m_ivec3 = glm::ivec3(newValue);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec4 = glm::vec4(static_cast<float> (newValue));
+    this->m_vec3 = glm::vec3(static_cast<float> (newValue));
+    this->m_vec2 = glm::vec2(static_cast<float> (newValue));
+    this->m_float = static_cast<float> (newValue);
+    this->m_int = newValue;
+    this->m_bool = newValue != 0;
+    this->m_type = UnderlyingType::Int;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(bool newValue) {
+    this->m_ivec4 = glm::ivec4(newValue);
+    this->m_ivec3 = glm::ivec3(newValue);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec4 = glm::vec4(newValue);
+    this->m_vec3 = glm::vec3(newValue);
+    this->m_vec2 = glm::vec2(newValue);
+    this->m_float = newValue;
+    this->m_int = newValue;
+    this->m_bool = newValue;
+    this->m_type = UnderlyingType::Boolean;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(const glm::vec2& newValue) {
+    this->m_ivec4 = glm::ivec4(newValue, 0, 0);
+    this->m_ivec3 = glm::ivec3(newValue, 0);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec2 = newValue;
+    this->m_vec3 = glm::vec3(newValue, 0.0f);
+    this->m_vec4 = glm::vec4(newValue, 0.0f, 0.0f);
+    this->m_float = newValue.x;
+    this->m_int = static_cast<int> (newValue.x);
+    this->m_bool = newValue.x != 0.0f;
+    this->m_type = UnderlyingType::Vec2;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(const glm::vec3& newValue) {
+    this->m_ivec4 = glm::ivec4(newValue, 0);
+    this->m_ivec3 = glm::ivec3(newValue);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec2 = glm::vec2(newValue);
+    this->m_vec3 = newValue;
+    this->m_vec4 = glm::vec4(newValue, 0.0f);
+    this->m_float = newValue.x;
+    this->m_int = static_cast<int> (newValue.x);
+    this->m_bool = newValue.x != 0.0f;
+    this->m_type = UnderlyingType::Vec3;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(const glm::vec4& newValue) {
+    this->m_ivec4 = glm::ivec4(newValue);
+    this->m_ivec3 = glm::ivec3(newValue);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec2 = glm::vec2(newValue);
+    this->m_vec3 = glm::vec3(newValue);
+    this->m_vec4 = newValue;
+    this->m_float = newValue.x;
+    this->m_int = static_cast<int> (newValue.x);
+    this->m_bool = newValue.x != 0.0f;
+    this->m_type = UnderlyingType::Vec4;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(const glm::ivec2& newValue) {
+    this->m_ivec4 = glm::ivec4(newValue, 0, 0);
+    this->m_ivec3 = glm::ivec3(newValue, 0);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec2 = newValue;
+    this->m_vec3 = glm::vec3(newValue, 0.0f);
+    this->m_vec4 = glm::vec4(newValue, 0.0f, 0.0f);
+    this->m_float = static_cast<float> (newValue.x);
+    this->m_int = static_cast<int> (newValue.x);
+    this->m_bool = newValue.x != 0;
+    this->m_type = UnderlyingType::IVec2;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(const glm::ivec3& newValue) {
+    this->m_ivec4 = glm::ivec4(newValue, 0);
+    this->m_ivec3 = glm::ivec3(newValue);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec2 = glm::vec2(newValue);
+    this->m_vec3 = newValue;
+    this->m_vec4 = glm::vec4(newValue, 0.0f);
+    this->m_float = static_cast<float> (newValue.x);
+    this->m_int = static_cast<int> (newValue.x);
+    this->m_bool = newValue.x != 0;
+    this->m_type = UnderlyingType::IVec3;
+
+    this->propagate ();
+}
+
+void DynamicValue::update(const glm::ivec4& newValue) {
+    this->m_ivec4 = glm::ivec4(newValue);
+    this->m_ivec3 = glm::ivec3(newValue);
+    this->m_ivec2 = glm::ivec2(newValue);
+    this->m_vec2 = glm::vec2(newValue);
+    this->m_vec3 = glm::vec3(newValue);
+    this->m_vec4 = newValue;
+    this->m_float = static_cast<float> (newValue.x);
+    this->m_int = static_cast<int> (newValue.x);
+    this->m_bool = newValue.x != 0;
+    this->m_type = UnderlyingType::IVec4;
+
+    this->propagate ();
+}
+
+void DynamicValue::update (const DynamicValue& other) {
+    this->m_ivec4 = other.getIVec4 ();
+    this->m_ivec3 = other.getIVec3 ();
+    this->m_ivec2 = other.getIVec2 ();
+    this->m_vec2 = other.getVec2 ();
+    this->m_vec3 = other.getVec3 ();
+    this->m_vec4 = other.getVec4 ();
+    this->m_float = other.getFloat ();
+    this->m_int = other.getInt ();
+    this->m_bool = other.getBool ();
+    this->m_type = other.getType ();
+
+    this->propagate ();
+}
+
+std::function<void ()> DynamicValue::listen (const std::function<void (const DynamicValue&)>& callback) {
+    const auto it = this->m_listeners.insert (this->m_listeners.end (), callback);
+
+    return [this, it] {
+        this->m_listeners.erase (it);
+    };
+}
+
+void DynamicValue::connect (DynamicValue* other) {
+    const auto deregisterFunction = other->listen ([this] (const DynamicValue& other) {
+        this->update (other);
+    });
+
+    this->m_connections.push_back (deregisterFunction);
+}
+
+void DynamicValue::disconnect () {
+    for (const auto& deregister : this->m_connections) {
+        deregister ();
+    }
+
+    this->m_connections.clear ();
+}
+
+void DynamicValue::propagate () const {
+    for (const auto& callback : this->m_listeners) {
+        callback(*this);
+    }
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/DynamicValue.h b/src/WallpaperEngine/Data/Model/DynamicValue.h
new file mode 100644
index 0000000..6d6f1d9
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/DynamicValue.h
@@ -0,0 +1,105 @@
+#pragma once
+
+#include <glm/glm.hpp>
+#include <string>
+#include <functional>
+
+namespace WallpaperEngine::Data::Model {
+/**
+ * Class that represents different types of dynamic values
+ */
+class DynamicValue {
+  public:
+    enum UnderlyingType {
+        Null = 0,
+        IVec4 = 1,
+        IVec3 = 2,
+        IVec2 = 3,
+        Vec4 = 4,
+        Vec3 = 5,
+        Vec2 = 6,
+        Float = 7,
+        Int = 8,
+        Boolean = 9
+    };
+
+    DynamicValue () = default;
+    explicit DynamicValue(const glm::ivec4& value);
+    explicit DynamicValue(const glm::ivec3& value);
+    explicit DynamicValue(const glm::ivec2& value);
+    explicit DynamicValue(const glm::vec4& value);
+    explicit DynamicValue(const glm::vec3& value);
+    explicit DynamicValue(const glm::vec2& value);
+    explicit DynamicValue(float value);
+    explicit DynamicValue(int value);
+    explicit DynamicValue(bool value);
+    ~DynamicValue ();
+
+    [[nodiscard]] const glm::ivec4& getIVec4 () const;
+    [[nodiscard]] const glm::ivec3& getIVec3 () const;
+    [[nodiscard]] const glm::ivec2& getIVec2 () const;
+    [[nodiscard]] const glm::vec4& getVec4 () const;
+    [[nodiscard]] const glm::vec3& getVec3 () const;
+    [[nodiscard]] const glm::vec2& getVec2 () const;
+    [[nodiscard]] const float& getFloat () const;
+    [[nodiscard]] const int& getInt () const;
+    [[nodiscard]] const bool& getBool () const;
+    [[nodiscard]] UnderlyingType getType () const;
+    [[nodiscard]] std::string toString () const;
+
+    void update (float newValue);
+    void update (int newValue);
+    void update (bool newValue);
+    void update (const glm::vec2& newValue);
+    void update (const glm::vec3& newValue);
+    void update (const glm::vec4& newValue);
+    void update (const glm::ivec2& newValue);
+    void update (const glm::ivec3& newValue);
+    void update (const glm::ivec4& newValue);
+    void update (const DynamicValue& newValue);
+
+    /**
+     * Registers the given callback to be called when the value changes
+     *
+     * @param callback
+     *
+     * @return The de-register function to call when the listener is no longer needed
+     */
+    std::function<void ()> listen (const std::function<void (const DynamicValue&)>& callback);
+    /**
+     * Connects the current instance to the given instance, updating this instance's value
+     * based on the given instance's value
+     *
+     * @param other
+     *
+     * @return The de-register function to call when the listener is no longer needed
+     */
+    void connect (DynamicValue* other);
+
+    /**
+     * Disconnects the current instance from all the connections to stop notifying
+     * new value changes
+     */
+    void disconnect ();
+
+  private:
+    /**
+     * Notifies any listeners that the value has changed
+     */
+    void propagate () const;
+
+    std::vector<std::function<void (const DynamicValue&)>> m_listeners = {};
+    std::vector<std::function<void ()>> m_connections = {};
+
+    glm::ivec4 m_ivec4 = {};
+    glm::ivec3 m_ivec3 = {};
+    glm::ivec2 m_ivec2 = {};
+    glm::vec4 m_vec4 = {};
+    glm::vec3 m_vec3 = {};
+    glm::vec2 m_vec2 = {};
+    float m_float = 0.0f;
+    int m_int = 0;
+    bool m_bool = false;
+    UnderlyingType m_type = Null;
+};
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Types.h b/src/WallpaperEngine/Data/Model/Types.h
index 2b1c101..6fff328 100644
--- a/src/WallpaperEngine/Data/Model/Types.h
+++ b/src/WallpaperEngine/Data/Model/Types.h
@@ -1,10 +1,16 @@
 #pragma once
 
+#include <map>
+#include <vector>
+#include <string>
+#include <optional>
 #include <memory>
 
 #include "WallpaperEngine/Assets/CContainer.h"
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-#include "WallpaperEngine/Core/Projects/CProperty.h"
+
+namespace WallpaperEngine::Core::Projects {
+class CProperty;
+}
 
 namespace WallpaperEngine::Data::Model {
 struct Project;
@@ -19,6 +25,7 @@ class Image;
 struct ImageEffect;
 struct ImageEffectPassOverride;
 class Particle;
+class DynamicValue;
 struct Material;
 struct MaterialPass;
 struct FBO;
@@ -33,7 +40,6 @@ using Property = WallpaperEngine::Core::Projects::CProperty;
 using PropertySharedPtr = std::shared_ptr <Property>;
 using PropertyWeakPtr = std::weak_ptr <Property>;
 using Properties = std::map <std::string, PropertySharedPtr>;
-using DynamicValue = WallpaperEngine::Core::DynamicValues::CDynamicValue;
 using DynamicValueUniquePtr = std::unique_ptr <DynamicValue>;
 using DynamicValueSharedPtr = std::shared_ptr <DynamicValue>;
 using DynamicValueWeakPtr = std::weak_ptr <DynamicValue>;
diff --git a/src/WallpaperEngine/Data/Model/UserSetting.h b/src/WallpaperEngine/Data/Model/UserSetting.h
index ce3f46b..7ef7c71 100644
--- a/src/WallpaperEngine/Data/Model/UserSetting.h
+++ b/src/WallpaperEngine/Data/Model/UserSetting.h
@@ -3,11 +3,9 @@
 #include <memory>
 #include <optional>
 
+#include "DynamicValue.h"
 #include "Types.h"
 
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-
 namespace WallpaperEngine::Data::Model {
 struct ConditionInfo {
   public:
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
index a26957e..9f2c7c7 100644
--- a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
@@ -6,6 +6,7 @@
 #include "WallpaperParser.h"
 
 #include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Core/Projects/CProperty.h"
 
 using namespace WallpaperEngine::Data::Parsers;
 
diff --git a/src/WallpaperEngine/Data/Utils/SFINAE.h b/src/WallpaperEngine/Data/Utils/SFINAE.h
new file mode 100644
index 0000000..f983fc8
--- /dev/null
+++ b/src/WallpaperEngine/Data/Utils/SFINAE.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <glm/detail/qualifier.hpp>
+#include <glm/detail/type_vec1.hpp>
+
+namespace WallpaperEngine::Data::Utils::SFINAE {
+// sfinae to detect the type for template specialization
+template <typename T>
+struct is_glm_vec : std::false_type {};
+
+template <glm::length_t L, typename S, glm::qualifier Q>
+struct is_glm_vec<glm::vec<L, S, Q>> : std::true_type {};
+
+// traits used to guess the type of the vector and it's length
+template <typename T>
+struct GlmVecTraits;
+
+template <glm::length_t L, typename T, glm::qualifier Q>
+struct GlmVecTraits<glm::vec<L, T, Q>> {
+    static constexpr int length = L;
+    using type = T;
+    static constexpr glm::qualifier qualifier = Q;
+};
+
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/CFBOProvider.h b/src/WallpaperEngine/Render/CFBOProvider.h
index 2b3d174..027ca55 100644
--- a/src/WallpaperEngine/Render/CFBOProvider.h
+++ b/src/WallpaperEngine/Render/CFBOProvider.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <glm/vec2.hpp>
+
 #include "CFBO.h"
 #include "WallpaperEngine/Data/Model/Effect.h"
 
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index 433c89f..b367381 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -727,7 +727,7 @@ void CPass::addUniform (CShaderVariable* value) {
     this->addUniform (value, value);
 }
 
-void CPass::addUniform (CShaderVariable* value, const CDynamicValue* setting) {
+void CPass::addUniform (CShaderVariable* value, const DynamicValue* setting) {
     if (value->is<CShaderVariableFloat> ()) {
         this->addUniform (value->getName (), setting->getFloat ());
     } else if (value->is<CShaderVariableInteger> ()) {
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.h b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
index b1eb6a1..28c6a4e 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.h
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
@@ -114,7 +114,7 @@ class CPass final : public Helpers::CContextAware {
     void setupAttributes ();
     void addAttribute (const std::string& name, GLint type, GLint elements, const GLuint* value);
     void addUniform (CShaderVariable* value);
-    void addUniform (CShaderVariable* value, const CDynamicValue* setting);
+    void addUniform (CShaderVariable* value, const DynamicValue* setting);
     void addUniform (const std::string& name, int value);
     void addUniform (const std::string& name, double value);
     void addUniform (const std::string& name, float value);
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.h b/src/WallpaperEngine/Render/Shaders/CShader.h
index 25e992b..10a41c8 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.h
+++ b/src/WallpaperEngine/Render/Shaders/CShader.h
@@ -6,7 +6,6 @@
 
 #include "WallpaperEngine/Assets/CContainer.h"
 #include "WallpaperEngine/Assets/ITexture.h"
-#include "WallpaperEngine/Core/Core.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
 
 #include "CShaderUnit.h"
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index 45c1989..8e88515 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -15,6 +15,8 @@
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.h"
 
+#include "WallpaperEngine/Data/Builders/VectorBuilder.h"
+
 #define SHADER_HEADER(filename) "#version 330\n" \
     "// ======================================================\n" \
     "// Processed shader " + \
@@ -47,6 +49,7 @@
 
 using namespace WallpaperEngine::Core;
 using namespace WallpaperEngine::Assets;
+using namespace WallpaperEngine::Data::Builders;
 using namespace WallpaperEngine::Render::Shaders;
 
 CShaderUnit::CShaderUnit (
@@ -322,18 +325,18 @@ void CShaderUnit::preprocessRequires () {
 
 void CShaderUnit::parseComboConfiguration (const std::string& content, int defaultValue) {
     // TODO: SUPPORT REQUIRES SO WE PROPERLY FOLLOW THE REQUIRED CHAIN
-    json data = json::parse (content);
-    const auto combo = jsonFindRequired (data, "combo", "cannot parse combo information");
+    const auto data = JSON::parse (content);
+    const auto combo = data.require <std::string> ("combo", "cannot parse combo information");
     // ignore type as it seems to be used only on the editor
     // const auto type = data.find ("type");
     const auto defvalue = data.find ("default");
 
     // check the combos
-    const auto entry = this->m_combos.find (combo->get<std::string> ());
-    const auto entryOverride = this->m_overrideCombos.find (combo->get<std::string> ());
+    const auto entry = this->m_combos.find (combo);
+    const auto entryOverride = this->m_overrideCombos.find (combo);
 
     // add the combo to the found list
-    this->m_usedCombos.emplace (*combo, true);
+    this->m_usedCombos.emplace (combo, true);
 
     // if the combo was not found in the predefined values this means that the default value in the JSON data can be
     // used so only define the ones that are not already defined
@@ -341,15 +344,15 @@ void CShaderUnit::parseComboConfiguration (const std::string& content, int defau
         // if no combo is defined just load the default settings
         if (defvalue == data.end ()) {
             // TODO: PROPERLY SUPPORT EMPTY COMBOS
-            this->m_discoveredCombos.emplace (*combo, (int) defaultValue);
+            this->m_discoveredCombos.emplace (combo, (int) defaultValue);
         } else if (defvalue->is_number_float ()) {
-            sLog.exception ("float combos are not supported in shader ", this->m_file, ". ", *combo);
+            sLog.exception ("float combos are not supported in shader ", this->m_file, ". ", combo);
         } else if (defvalue->is_number_integer ()) {
-            this->m_discoveredCombos.emplace (*combo, defvalue->get<int> ());
+            this->m_discoveredCombos.emplace (combo, defvalue->get<int> ());
         } else if (defvalue->is_string ()) {
-            sLog.exception ("string combos are not supported in shader ", this->m_file, ". ", *combo);
+            sLog.exception ("string combos are not supported in shader ", this->m_file, ". ", combo);
         } else {
-            sLog.exception ("cannot parse combo information ", *combo, ". unknown type for ", defvalue->dump ());
+            sLog.exception ("cannot parse combo information ", combo, ". unknown type for ", defvalue->dump ());
         }
     }
 }
@@ -357,45 +360,42 @@ void CShaderUnit::parseComboConfiguration (const std::string& content, int defau
 void CShaderUnit::parseParameterConfiguration (
     const std::string& type, const std::string& name, const std::string& content
 ) {
-    json data = json::parse (content);
-    const auto material = data.find ("material");
-    const auto defvalue = data.find ("default");
+    const auto data = JSON::parse (content);
+    const auto material = data.optional ("material");
+    const auto defvalue = data.optional ("default");
     // auto range = data.find ("range");
     const auto combo = data.find ("combo");
 
     // this is not a real parameter
     auto constant = this->m_constants.end ();
 
-    if (material != data.end ())
+    if (material.has_value ())
         constant = this->m_constants.find (*material);
 
-    if (constant == this->m_constants.end () && defvalue == data.end ()) {
+    if (constant == this->m_constants.end () && !defvalue.has_value ()) {
         if (type != "sampler2D")
             sLog.exception ("Cannot parse parameter data for ", name, " in shader ", this->m_file);
     }
 
     Variables::CShaderVariable* parameter = nullptr;
 
-    // TODO: SUPPORT VALUES FOR ALL THESE TYPES
-    // TODO: MAYBE EVEN CONNECT THESE TO THE CORRESPONDING PROPERTY SO THINGS ARE UPDATED AS THE ORIGIN VALUES CHANGE?
-    // TODO: MAKE USE OF PARSERS INSTEAD OF CORE
     if (type == "vec4") {
-        parameter = new Variables::CShaderVariableVector4 (WallpaperEngine::Core::aToVector4 (*defvalue));
+        parameter = new Variables::CShaderVariableVector4 (VectorBuilder::parse <glm::vec4> (defvalue->get <std::string> ()));
     } else if (type == "vec3") {
-        parameter = new Variables::CShaderVariableVector3 (WallpaperEngine::Core::aToVector3 (*defvalue));
+        parameter = new Variables::CShaderVariableVector3 (VectorBuilder::parse <glm::vec3> (*defvalue));
     } else if (type == "vec2") {
-        parameter = new Variables::CShaderVariableVector2 (WallpaperEngine::Core::aToVector2 (*defvalue));
+        parameter = new Variables::CShaderVariableVector2 (VectorBuilder::parse <glm::vec2> (*defvalue));
     } else if (type == "float") {
         if (defvalue->is_string ()) {
-            parameter = new Variables::CShaderVariableFloat (strtof32 ((defvalue->get<std::string> ()).c_str (), nullptr));
+            parameter = new Variables::CShaderVariableFloat (std::stoi (defvalue->get<std::string> ()));
         } else {
-            parameter = new Variables::CShaderVariableFloat (*defvalue);
+            parameter = new Variables::CShaderVariableFloat (defvalue->get<float> ());
         }
     } else if (type == "int") {
         if (defvalue->is_string ()) {
-            parameter = new Variables::CShaderVariableInteger (strtol((defvalue->get<std::string> ()).c_str (), nullptr, 10));
+            parameter = new Variables::CShaderVariableInteger (std::stoi(defvalue->get<std::string> ()));
         } else {
-            parameter = new Variables::CShaderVariableInteger (*defvalue);
+            parameter = new Variables::CShaderVariableInteger (defvalue->get <int> ());
         }
     } else if (type == "sampler2D" || type == "sampler2DComparison") {
         // samplers can have special requirements, check what sampler we're working with and create definitions
@@ -460,7 +460,7 @@ void CShaderUnit::parseParameterConfiguration (
             }
 
             if (isRequired && !textureSlotUsed) {
-                if (defvalue == data.end ()) {
+                if (!defvalue.has_value ()) {
                     isRequired = false;
                 } else {
                     // is the combo registered already?
@@ -473,7 +473,7 @@ void CShaderUnit::parseParameterConfiguration (
                         isRequired = false;
                         // otherwise a default value must be used
                     } else if (defvalue->is_string ()) {
-                        comboValue = strtol (defvalue->get <std::string> ().c_str (), nullptr, 10);
+                        comboValue = std::stoi (defvalue->get <std::string> ().c_str ());
                     } else if (defvalue->is_number()) {
                         comboValue = *defvalue;
                     } else {
@@ -500,7 +500,7 @@ void CShaderUnit::parseParameterConfiguration (
         return;
     }
 
-    if (material != data.end () && parameter != nullptr) {
+    if (material.has_value () && parameter != nullptr) {
         parameter->setIdentifierName (*material);
         parameter->setName (name);
 
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
index 4974f44..24f21fc 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.h
@@ -6,14 +6,14 @@
 
 #include "CGLSLContext.h"
 #include "WallpaperEngine/Assets/CContainer.h"
-#include "WallpaperEngine/Core/Core.h"
+#include "WallpaperEngine/Data/JSON.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
 #include "nlohmann/json.hpp"
 
 #include "WallpaperEngine/Data/Model/Types.h"
 
 namespace WallpaperEngine::Render::Shaders {
-using json = nlohmann::json;
+using JSON = WallpaperEngine::Data::JSON::JSON;
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Data::Model;
 
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h
index f5d09ce..ea7a637 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h
@@ -1,32 +1,17 @@
 #pragma once
 
-#include "WallpaperEngine/Core/DynamicValues/CDynamicValue.h"
+#include "WallpaperEngine/Data/Utils/TypeCaster.h"
+#include "WallpaperEngine/Data/Model/DynamicValue.h"
+#include <exception>
 #include <string>
 
 namespace WallpaperEngine::Render::Shaders::Variables {
-class CShaderVariable : public Core::DynamicValues::CDynamicValue {
+using namespace WallpaperEngine::Data::Model;
+using namespace WallpaperEngine::Data::Utils;
+
+class CShaderVariable : public DynamicValue, public TypeCaster {
   public:
-    virtual ~CShaderVariable () = default;
-
-    template <class T> [[nodiscard]] const T* as () const {
-        if (is <T> ()) {
-            return static_cast <const T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] T* as () {
-        if (is <T> ()) {
-            return static_cast <T*> (this);
-        }
-
-        throw std::bad_cast ();
-    }
-
-    template <class T> [[nodiscard]] bool is () const {
-        return typeid (*this) == typeid(T);
-    }
+    using DynamicValue::DynamicValue;
 
     [[nodiscard]] const std::string& getIdentifierName () const;
     [[nodiscard]] const std::string& getName () const;
@@ -35,7 +20,7 @@ class CShaderVariable : public Core::DynamicValues::CDynamicValue {
     void setName (const std::string& name);
 
   private:
-    std::string m_identifierName = "";
-    std::string m_name = "";
+    std::string m_identifierName;
+    std::string m_name;
 };
 } // namespace WallpaperEngine::Render::Shaders::Variables
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.cpp b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.cpp
index d171b0d..8a43168 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.cpp
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.cpp
@@ -4,13 +4,7 @@
 
 using namespace WallpaperEngine::Render::Shaders::Variables;
 
-CShaderVariableFloat::CShaderVariableFloat (float defaultValue) :
-    CShaderVariable () {
-    this->update (defaultValue);
-}
-
 CShaderVariableFloat::CShaderVariableFloat (float defaultValue, const std::string& name) :
-    CShaderVariable () {
+    CShaderVariable (defaultValue) {
     this->setName (name);
-    this->update (defaultValue);
 }
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.h b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.h
index 6a7b2ce..da64b7a 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.h
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.h
@@ -5,7 +5,8 @@
 namespace WallpaperEngine::Render::Shaders::Variables {
 class CShaderVariableFloat final : public CShaderVariable {
   public:
-    explicit CShaderVariableFloat (float defaultValue);
+    using CShaderVariable::CShaderVariable;
+
     CShaderVariableFloat (float defaultValue, const std::string& name);
 };
 } // namespace WallpaperEngine::Render::Shaders::Variables
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.cpp b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.cpp
index 3e551ba..4907d2c 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.cpp
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.cpp
@@ -4,13 +4,7 @@
 
 using namespace WallpaperEngine::Render::Shaders::Variables;
 
-CShaderVariableInteger::CShaderVariableInteger (int32_t defaultValue) :
-    CShaderVariable () {
-    this->update (defaultValue);
-}
-
-CShaderVariableInteger::CShaderVariableInteger (int32_t defaultValue, const std::string& name) :
-    CShaderVariable () {
+CShaderVariableInteger::CShaderVariableInteger (int defaultValue, const std::string& name) :
+    CShaderVariable (defaultValue) {
     this->setName (name);
-    this->update (defaultValue);
 }
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.h b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.h
index bc53dd3..17ff7ea 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.h
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.h
@@ -5,7 +5,8 @@
 namespace WallpaperEngine::Render::Shaders::Variables {
 class CShaderVariableInteger final : public CShaderVariable {
   public:
-    explicit CShaderVariableInteger (int32_t defaultValue);
-    CShaderVariableInteger (int32_t defaultValue, const std::string& name);
+    using CShaderVariable::CShaderVariable;
+
+    CShaderVariableInteger (int defaultValue, const std::string& name);
 };
 } // namespace WallpaperEngine::Render::Shaders::Variables
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.cpp b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.cpp
index 84198ec..9bf915c 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.cpp
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.cpp
@@ -4,13 +4,7 @@
 
 using namespace WallpaperEngine::Render::Shaders::Variables;
 
-CShaderVariableVector2::CShaderVariableVector2 (const glm::vec2& defaultValue) :
-    CShaderVariable () {
-    this->update (defaultValue);
-}
-
 CShaderVariableVector2::CShaderVariableVector2 (const glm::vec2& defaultValue, const std::string& name) :
-    CShaderVariable () {
+    CShaderVariable (defaultValue) {
     this->setName (name);
-    this->update (defaultValue);
 }
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.h b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.h
index b225277..396535b 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.h
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector2.h
@@ -6,7 +6,8 @@
 namespace WallpaperEngine::Render::Shaders::Variables {
 class CShaderVariableVector2 final : public CShaderVariable {
   public:
-    explicit CShaderVariableVector2 (const glm::vec2& defaultValue);
+    using CShaderVariable::CShaderVariable;
+
     CShaderVariableVector2 (const glm::vec2& defaultValue, const std::string& name);
 };
 } // namespace WallpaperEngine::Render::Shaders::Variables
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.cpp b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.cpp
index fadf009..3ae9532 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.cpp
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.cpp
@@ -2,13 +2,7 @@
 
 using namespace WallpaperEngine::Render::Shaders::Variables;
 
-CShaderVariableVector3::CShaderVariableVector3 (const glm::vec3& defaultValue) :
-    CShaderVariable () {
-    this->update (defaultValue);
-}
-
 CShaderVariableVector3::CShaderVariableVector3 (const glm::vec3& defaultValue, const std::string& name) :
-    CShaderVariable () {
+    CShaderVariable (defaultValue) {
     this->setName (name);
-    this->update (defaultValue);
 }
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.h b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.h
index 7c989c1..55ffd96 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.h
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector3.h
@@ -7,7 +7,8 @@
 namespace WallpaperEngine::Render::Shaders::Variables {
 class CShaderVariableVector3 final : public CShaderVariable {
   public:
-    explicit CShaderVariableVector3 (const glm::vec3& defaultValue);
+    using CShaderVariable::CShaderVariable;
+
     CShaderVariableVector3 (const glm::vec3& defaultValue, const std::string& name);
 };
 } // namespace WallpaperEngine::Render::Shaders::Variables
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.cpp b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.cpp
index 1b8a519..f12253c 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.cpp
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.cpp
@@ -4,13 +4,7 @@
 
 using namespace WallpaperEngine::Render::Shaders::Variables;
 
-CShaderVariableVector4::CShaderVariableVector4 (const glm::vec4& defaultValue) :
-    CShaderVariable () {
-    this->update (defaultValue);
-}
-
 CShaderVariableVector4::CShaderVariableVector4 (const glm::vec4& defaultValue, const std::string& name) :
-    CShaderVariable () {
+    CShaderVariable (defaultValue) {
     this->setName (name);
-    this->update (defaultValue);
 }
diff --git a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.h b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.h
index d1e00d5..c5d8bcd 100644
--- a/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.h
+++ b/src/WallpaperEngine/Render/Shaders/Variables/CShaderVariableVector4.h
@@ -6,7 +6,8 @@
 namespace WallpaperEngine::Render::Shaders::Variables {
 class CShaderVariableVector4 final : public CShaderVariable {
   public:
-    explicit CShaderVariableVector4 (const glm::vec4& defaultValue);
+    using CShaderVariable::CShaderVariable;
+
     CShaderVariableVector4 (const glm::vec4& defaultValue, const std::string& name);
 };
 } // namespace WallpaperEngine::Render::Shaders::Variables
diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
index 1f69d35..5541261 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
@@ -55,7 +55,6 @@ CScene::CScene (
     this->alias ("_alias_lightCookie", "_rt_shadowAtlas");
 
     // set clear color
-    // TODO: MAKE USE OF THE REFERENCE POSSIBILITIES?!
     const glm::vec3 clearColor = scene->colors.clear->value->getVec3 ();
 
     glClearColor (clearColor.r, clearColor.g, clearColor.b, 1.0f);
@@ -92,7 +91,6 @@ CScene::CScene (
     // (it renders directly to the screen, whereas here we never do that from a scene)
     //
 
-    // TODO: TAKE THIS OUT OF HERE AND INTO THE GENERAL WALLPAPER APPLICATION?!
     const auto bloomOrigin = glm::vec3 { sceneWidth / 2, sceneHeight / 2, 0.0f };
     const auto bloomSize = glm::vec2 { sceneWidth, sceneHeight };
 

From d6831ad40f1f563ed6869b57e6a6f65d863da159 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Tue, 19 Aug 2025 21:44:25 +0200
Subject: [PATCH 13/23] chore: bring back support for pass commands

---
 .../Data/Dumpers/StringPrinter.cpp            | 64 +++++++++--------
 src/WallpaperEngine/Data/Model/Effect.h       | 16 ++---
 .../Data/Parsers/EffectParser.cpp             | 25 +++----
 src/WallpaperEngine/Render/Objects/CImage.cpp | 70 ++++++++++++++-----
 src/WallpaperEngine/Render/Objects/CImage.h   |  1 +
 .../Render/Objects/Effects/CPass.cpp          |  2 +-
 .../Render/Objects/Effects/CPass.h            |  2 +-
 7 files changed, 106 insertions(+), 74 deletions(-)

diff --git a/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
index 3a52b04..462f25d 100644
--- a/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
+++ b/src/WallpaperEngine/Data/Dumpers/StringPrinter.cpp
@@ -265,39 +265,47 @@ void StringPrinter::printEffect (const Effect& effect) {
 
 void StringPrinter::printEffectPass (const EffectPass& effectPass) {
     if (effectPass.command.has_value ()) {
-        const auto& command = effectPass.command.value ();
+        this->m_out << "Command: " << (*effectPass.command == Command_Copy ? "copy" : "swap");
 
-        this->m_out << "Command: " << (command.command == Command_Copy ? "copy" : "swap");
-        this->lineEnd ();
-        this->m_out << "Source: " << command.source;
-        this->lineEnd ();
-        this->m_out << "Target: " << command.target;
-    } else {
+        if (effectPass.target.has_value () || effectPass.source.has_value ()) {
+            this->lineEnd ();
+        }
+    }
+
+    if (effectPass.target.has_value ()) {
+        this->m_out << "Target: " << effectPass.target.value ();
+
+        if (effectPass.source.has_value ()) {
+            this->lineEnd ();
+        }
+    }
+
+    if (effectPass.source.has_value ()) {
+        this->m_out << "Source: " << effectPass.source.value ();
+    }
+
+    if (!effectPass.binds.empty ()) {
         if (effectPass.target.has_value ()) {
-            this->m_out << "Target: " << effectPass.target.value ();
-        }
-
-        if (!effectPass.binds.empty ()) {
-            if (effectPass.target.has_value ()) {
-                this->lineEnd ();
-            }
-
-            this->m_out << "Binds count: " << effectPass.binds.size ();
-            this->increaseIndentation ();
-
-            for (const auto& bind : effectPass.binds) {
-                this->lineEnd ();
-                this->m_out << "Bind " << bind.first << ": " << bind.second;
-            }
-
-            this->decreaseIndentation ();
-        }
-
-        if (effectPass.target.has_value () || !effectPass.binds.empty ()) {
             this->lineEnd ();
         }
 
-        this->printMaterial (*effectPass.material);
+        this->m_out << "Binds count: " << effectPass.binds.size ();
+        this->increaseIndentation ();
+
+        for (const auto& bind : effectPass.binds) {
+            this->lineEnd ();
+            this->m_out << "Bind " << bind.first << ": " << bind.second;
+        }
+
+        this->decreaseIndentation ();
+    }
+
+    if (effectPass.target.has_value () || !effectPass.binds.empty ()) {
+        this->lineEnd ();
+    }
+
+    if (effectPass.material.has_value ()) {
+        this->printMaterial (**effectPass.material);
     }
 }
 
diff --git a/src/WallpaperEngine/Data/Model/Effect.h b/src/WallpaperEngine/Data/Model/Effect.h
index 54b76e8..217ec97 100644
--- a/src/WallpaperEngine/Data/Model/Effect.h
+++ b/src/WallpaperEngine/Data/Model/Effect.h
@@ -14,24 +14,18 @@ struct FBO {
     std::string name;
     std::string format;
     float scale;
-};
-
-struct PassCommand {
-    /** The type of command to execute */
-    PassCommandType command;
-    /** The target of the command (where to draw to) */
-    std::string target;
-    /** The source of the command (where to draw from) */
-    std::string source;
+    bool unique;
 };
 
 struct EffectPass {
     /** The material to use for this effect's pass */
-    MaterialUniquePtr material;
+    std::optional<MaterialUniquePtr> material;
     /** Texture bindings for this effect's pass */
     TextureMap binds;
     /** The command this material executes (if specified) */
-    std::optional <PassCommand> command;
+    std::optional <PassCommandType> command;
+    /** The source this material renders from (if specified) */
+    std::optional <std::string> source;
     /** The target this material renders to (if specified) */
     std::optional <std::string> target;
 };
diff --git a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
index 98709d0..7ed6ec6 100644
--- a/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/EffectParser.cpp
@@ -52,27 +52,17 @@ std::vector <EffectPassUniquePtr> EffectParser::parseEffectPasses (const JSON& i
 
     for (const auto& cur : it) {
         const auto binds = cur.optional ("bind");
-        std::optional <PassCommand> command = std::nullopt;
+        const auto command = cur.optional ("command");
+        const auto material = cur.optional ("material");
 
-        if (cur.contains ("command")) {
-            command = {
-                .command = cur.require <std::string> ("command", "Material command must have a command") == "copy"
-                               ? Command_Copy
-                               : Command_Swap,
-                .target = cur.require <std::string> ("target", "Material command must have a target"),
-                .source = cur.require <std::string> ("source", "Material command must have a source"),
-            };
-        }
+        // TODO: CAN TARGET BE SET IF MATERIAL IS SET?
 
         result.push_back (std::make_unique <EffectPass> (EffectPass {
-            .material = MaterialParser::load (project, cur.require <std::string> ("material", "Effect pass must have a material")),
+            .material = material.has_value () ? MaterialParser::load (project, *material) : std::optional<MaterialUniquePtr> {},
             .binds = binds.has_value () ? parseBinds (binds.value ()) : std::map<int, std::string> {},
-            .command = command,
-            // target is a bit special: if the material is a command this will be nullopt
-            // and the actual target will be set in the command itself, otherwise it will
-            // be set to whatever is in the json, which is not required to be present for
-            // normal materials
-            .target = command.has_value () ? std::nullopt : cur.optional <std::string> ("target"),
+            .command = command.has_value () ? (command.value () == "copy" ? Command_Copy : Command_Swap) : std::optional<PassCommandType> {},
+            .source = command.has_value () ? cur.require <std::string> ("source", "Effect command must have a source") : cur.optional <std::string> ("source"),
+            .target = command.has_value () ? cur.require <std::string> ("target", "Effect command must have a target") : cur.optional <std::string> ("target"),
         }));
     }
 
@@ -108,6 +98,7 @@ std::vector <FBOUniquePtr> EffectParser::parseFBOs (const JSON& it) {
             .name = cur.require <std::string> ("name", "FBO must have a name"),
             .format = cur.optional <std::string> ("format", "rgba8888"),
             .scale = cur.optional ("scale", 1.0f),
+            .unique = cur.optional ("unique", false),
         }));
     }
 
diff --git a/src/WallpaperEngine/Render/Objects/CImage.cpp b/src/WallpaperEngine/Render/Objects/CImage.cpp
index d0ca2b0..86c23a2 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.cpp
+++ b/src/WallpaperEngine/Render/Objects/CImage.cpp
@@ -2,7 +2,6 @@
 #include <sstream>
 
 #include "WallpaperEngine/Data/Parsers/MaterialParser.h"
-#include "WallpaperEngine/Data/Builders/UserSettingBuilder.h"
 #include "WallpaperEngine/Data/Model/Object.h"
 #include "WallpaperEngine/Data/Model/Material.h"
 
@@ -245,7 +244,6 @@ void CImage::setup () {
             new CPass (*this, std::make_shared<CFBOProvider>(this), *cur, std::nullopt, std::nullopt, std::nullopt)
         );
 
-    // TODO: MAYBE GET RID OF THE WHOLE EFFECT CLASS AND PROCESS THE EFFECTS DIRECTLY TO SIMPLIFY RENDERING CODE?
     // prepare the passes list
     if (!this->getImage ().effects.empty ()) {
         // generate the effects used by this material
@@ -265,23 +263,63 @@ void CImage::setup () {
             auto endOverride = cur->passOverrides.end ();
 
             for (; curEffect != endEffect; curEffect++) {
-                auto curPass = (*curEffect)->material->passes.begin ();
-                auto endPass = (*curEffect)->material->passes.end ();
+                if (!(*curEffect)->material.has_value ()) {
+                    if (!(*curEffect)->command.has_value ()) {
+                        sLog.error ("Pass without material and command not supported");
+                        continue;
+                    }
 
-                const auto override = curOverride != endOverride
-                    ? **curOverride
-                    : std::optional<std::reference_wrapper<const ImageEffectPassOverride>> (std::nullopt);
-                const auto target = (*curEffect)->target.has_value ()
-                    ? *(*curEffect)->target
-                    : std::optional<std::reference_wrapper<std::string>> (std::nullopt);
+                    if (!(*curEffect)->source.has_value ()) {
+                        sLog.error ("Pass without material and source not supported");
+                        continue;
+                    }
 
-                this->m_passes.push_back (
-                    new CPass (
-                        *this, fboProvider, **curPass, override, (*curEffect)->binds, target)
-                );
+                    if (!(*curEffect)->target.has_value ()) {
+                        sLog.error ("Pass without material and target not supported");
+                        continue;
+                    }
 
-                if (curOverride != endOverride) {
-                    curOverride ++;
+                    if ((*curEffect)->command != Command_Copy) {
+                        sLog.error ("Only copy command is supported for pass without material");
+                        continue;
+                    }
+
+                    const auto virtualPass = MaterialPass {
+                        .blending = "normal",
+                        .cullmode = "nocull",
+                        .depthtest = "disabled",
+                        .depthwrite = "disabled",
+                        .shader = "commands/copy",
+                        .textures = {
+                            {0, *(*curEffect)->source}
+                        },
+                        .combos = {}
+                    };
+
+                    const auto& config = this->m_virtualPassess.emplace_back (virtualPass);
+
+                    // build a pass for a copy shader
+                    this->m_passes.push_back (
+                        new CPass (*this, fboProvider, config, std::nullopt, std::nullopt, (*curEffect)->target.value ())
+                    );
+                } else {
+                    auto curPass = (*curEffect)->material.value ()->passes.begin ();
+                    auto endPass = (*curEffect)->material.value ()->passes.end ();
+
+                    const auto override =
+                        curOverride != endOverride
+                            ? **curOverride
+                            : std::optional<std::reference_wrapper<const ImageEffectPassOverride>> (std::nullopt);
+                    const auto target = (*curEffect)->target.has_value ()
+                                            ? *(*curEffect)->target
+                                            : std::optional<std::reference_wrapper<std::string>> (std::nullopt);
+
+                    this->m_passes.push_back (
+                        new CPass (*this, fboProvider, **curPass, override, (*curEffect)->binds, target));
+
+                    if (curOverride != endOverride) {
+                        curOverride++;
+                    }
                 }
             }
         }
diff --git a/src/WallpaperEngine/Render/Objects/CImage.h b/src/WallpaperEngine/Render/Objects/CImage.h
index 877a8bb..39a5c18 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.h
+++ b/src/WallpaperEngine/Render/Objects/CImage.h
@@ -85,6 +85,7 @@ class CImage final : public CObject, public CFBOProvider {
     Effects::CMaterial* m_material = nullptr;
     Effects::CMaterial* m_colorBlendMaterial = nullptr;
     std::vector<Effects::CPass*> m_passes = {};
+    std::vector<MaterialPass> m_virtualPassess = {};
 
     glm::vec4 m_pos = {};
 
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index b367381..a5443da 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -349,7 +349,7 @@ const MaterialPass& CPass::getPass () const {
     return this->m_pass;
 }
 
-const std::optional<std::reference_wrapper<std::string>> CPass::getTarget () const {
+std::optional<std::reference_wrapper<std::string>> CPass::getTarget () const {
     return this->m_target;
 }
 
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.h b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
index 28c6a4e..553617c 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.h
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
@@ -45,7 +45,7 @@ class CPass final : public Helpers::CContextAware {
     [[nodiscard]] std::shared_ptr<const CFBOProvider> getFBOProvider () const;
     [[nodiscard]] const CImage& getImage () const;
     [[nodiscard]] const MaterialPass& getPass () const;
-    [[nodiscard]] const std::optional<std::reference_wrapper<std::string>> getTarget () const;
+    [[nodiscard]] std::optional<std::reference_wrapper<std::string>> getTarget () const;
     [[nodiscard]] Render::Shaders::CShader* getShader () const;
 
   private:

From e3e377ecddea7e249db929423ca878e991ca2384 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Wed, 20 Aug 2025 00:02:42 +0200
Subject: [PATCH 14/23] chore: fix combo names not being uppercase when they
 should be

---
 .../Render/Shaders/CShaderUnit.cpp            | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index 8e88515..e9dba1a 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -541,7 +541,10 @@ const std::string& CShaderUnit::compile () {
 
     for (const auto& combo : this->m_overrideCombos) {
         if (addedCombos.find (combo.first) == addedCombos.end ()) {
-            this->m_final += DEFINE_COMBO (combo.first, combo.second);
+            std::string name;
+            std::transform (combo.first.begin (), combo.first.end (), std::back_inserter (name), ::toupper);
+
+            this->m_final += DEFINE_COMBO (name, combo.second);
         }
 
         addedCombos.emplace (combo.first, true);
@@ -549,14 +552,20 @@ const std::string& CShaderUnit::compile () {
     // now add all the combos to the source
     for (const auto& combo : this->m_combos) {
         if (addedCombos.find (combo.first) == addedCombos.end ()) {
-            this->m_final += DEFINE_COMBO (combo.first, combo.second);
+            std::string name;
+            std::transform (combo.first.begin (), combo.first.end (), std::back_inserter (name), ::toupper);
+
+            this->m_final += DEFINE_COMBO (name, combo.second);
         }
 
         addedCombos.emplace (combo.first, true);
     }
     for (const auto& combo : this->m_discoveredCombos) {
         if (addedCombos.find (combo.first) == addedCombos.end ()) {
-            this->m_final += DEFINE_COMBO (combo.first, combo.second);
+            std::string name;
+            std::transform (combo.first.begin (), combo.first.end (), std::back_inserter (name), ::toupper);
+
+            this->m_final += DEFINE_COMBO (name, combo.second);
         }
 
         addedCombos.emplace (combo.first, true);
@@ -564,14 +573,20 @@ const std::string& CShaderUnit::compile () {
     if (this->m_link != nullptr) {
         for (const auto& combo : this->m_link->getCombos ()) {
             if (addedCombos.find (combo.first) == addedCombos.end ()) {
-                this->m_final += DEFINE_COMBO (combo.first, combo.second);
+                std::string name;
+                std::transform (combo.first.begin (), combo.first.end (), std::back_inserter (name), ::toupper);
+
+                this->m_final += DEFINE_COMBO (name, combo.second);
             }
 
             addedCombos.emplace (combo.first, true);
         }
         for (const auto& combo : this->m_link->getDiscoveredCombos ()) {
             if (addedCombos.find (combo.first) == addedCombos.end ()) {
-                this->m_final += DEFINE_COMBO (combo.first, combo.second);
+                std::string name;
+                std::transform (combo.first.begin (), combo.first.end (), std::back_inserter (name), ::toupper);
+
+                this->m_final += DEFINE_COMBO (name, combo.second);
             }
 
             addedCombos.emplace (combo.first, true);

From ce51cd23fa7bc3ebc8e7cffa24db1e4eee3a9fde Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Wed, 20 Aug 2025 00:46:11 +0200
Subject: [PATCH 15/23] chore: fix default uniform values not being applied in
 the right order

---
 src/WallpaperEngine/Render/Objects/CImage.cpp        | 2 +-
 src/WallpaperEngine/Render/Objects/Effects/CPass.cpp | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/WallpaperEngine/Render/Objects/CImage.cpp b/src/WallpaperEngine/Render/Objects/CImage.cpp
index 86c23a2..a04f7c1 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.cpp
+++ b/src/WallpaperEngine/Render/Objects/CImage.cpp
@@ -89,7 +89,7 @@ CImage::CImage (Wallpapers::CScene& scene, const Image& image) :
     if (!textures.empty ()) {
         std::string textureName = textures.begin ()->second;
 
-        if (textureName.find ("_rt_") == 0) {
+        if (textureName.find ("_rt_") == 0 || textureName.find ("_alias_") == 0) {
             this->m_texture = this->getScene ().findFBO (textureName);
         } else {
             // get the first texture on the first pass (this one represents the image assigned to this object)
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index a5443da..03a0d81 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -53,7 +53,6 @@ CPass::CPass (
     m_fboProvider (std::move(fboProvider)),
     m_target (target) {
     this->setupShaders ();
-    this->setupShaderVariables ();
 }
 
 std::shared_ptr<const ITexture> CPass::resolveTexture (std::shared_ptr<const ITexture> expected, int index, std::shared_ptr<const ITexture> previous) {
@@ -471,6 +470,8 @@ void CPass::setupShaders () {
     glDeleteShader (vertexShaderID);
     glDeleteShader (fragmentShaderID);
 
+    // first setup the default values, these will be overwritten by future values
+    this->setupShaderVariables ();
     // setup uniforms
     this->setupUniforms ();
     // setup attributes too

From cf3774c48100cb5d2c56c8fef88cd31eeccf2e95 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Wed, 20 Aug 2025 01:12:28 +0200
Subject: [PATCH 16/23] chore: more fixes for visibility + camerashake can be a
 user setting

---
 src/WallpaperEngine/Data/Model/Wallpaper.h    |  2 +-
 .../Data/Parsers/WallpaperParser.cpp          |  2 +-
 src/WallpaperEngine/Render/Objects/CImage.cpp | 30 +++++++++++++++----
 3 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/src/WallpaperEngine/Data/Model/Wallpaper.h b/src/WallpaperEngine/Data/Model/Wallpaper.h
index 327fff5..ced5d13 100644
--- a/src/WallpaperEngine/Data/Model/Wallpaper.h
+++ b/src/WallpaperEngine/Data/Model/Wallpaper.h
@@ -80,7 +80,7 @@ struct SceneData {
          * Shake effect configuration
          */
         struct {
-            bool enabled;
+            UserSettingUniquePtr enabled;
             float amplitude;
             float roughness;
             float speed;
diff --git a/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp b/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
index e65b3aa..30ab449 100644
--- a/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/WallpaperParser.cpp
@@ -56,7 +56,7 @@ SceneUniquePtr WallpaperParser::parseScene (const JSON& file, Project& project)
                     .mouseInfluence = general.optional ("cameraparallaxmouseinfluence", 1.0f),
                 },
                 .shake = {
-                    .enabled = general.optional ("camerashake", false),
+                    .enabled = general.user ("camerashake", properties, false),
                     .amplitude = general.optional ("camerashakeamplitude", 0.0f),
                     .roughness = general.optional ("camerashakeroughness", 0.0f),
                     .speed = general.optional ("camerashakespeed", 0.0f),
diff --git a/src/WallpaperEngine/Render/Objects/CImage.cpp b/src/WallpaperEngine/Render/Objects/CImage.cpp
index a04f7c1..3c39e64 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.cpp
+++ b/src/WallpaperEngine/Render/Objects/CImage.cpp
@@ -230,24 +230,38 @@ CImage::CImage (Wallpapers::CScene& scene, const Image& image) :
 
 void CImage::setup () {
     // do not double-init stuff, that's bad!
-    if (this->m_initialized)
+    if (this->m_initialized) {
         return;
+    }
+
+    // TODO: SETUP RECALCULATION OF THINGS WHEN A VISIBILITY VALUE CHANGES!!
+    if (!this->m_image.visible->value->getBool ()) {
+        return;
+    }
 
     // TODO: SUPPORT PASSTHROUGH (IT'S A SHADER)
     // passthrough images without effects are bad, do not draw them
-    if (this->m_image.model->passthrough && this->m_image.effects.empty ())
+    if (this->m_image.model->passthrough && this->m_image.effects.empty ()) {
         return;
+    }
 
-    // add blendmode to the combos
-    for (const auto& cur : this->getImage ().model->material->passes)
+    // copy pass to the composite layer
+    for (const auto& cur : this->getImage ().model->material->passes) {
         this->m_passes.push_back (
-            new CPass (*this, std::make_shared<CFBOProvider>(this), *cur, std::nullopt, std::nullopt, std::nullopt)
+            new CPass (*this, std::make_shared<CFBOProvider> (this), *cur, std::nullopt, std::nullopt, std::nullopt)
         );
+    }
 
     // prepare the passes list
     if (!this->getImage ().effects.empty ()) {
         // generate the effects used by this material
         for (const auto& cur : this->m_image.effects) {
+            // do not add non-visible effects, this might need some adjustements tho as some effects might not be visible
+            // but affect the output of the image...
+            if (!cur->visible->value->getBool ()) {
+                continue;
+            }
+
             auto fboProvider = std::make_shared<CFBOProvider> (this);
 
             // create all the fbos for this effect
@@ -325,6 +339,7 @@ void CImage::setup () {
         }
     }
 
+    // extra render pass if there's any blending to be done
     if (this->m_image.colorBlendMode > 0) {
         this->m_materials.colorBlending.material = MaterialParser::load (this->getScene ().getScene ().project, "materials/util/effectpassthrough.json");
         this->m_materials.colorBlending.override = std::make_unique<ImageEffectPassOverride> (ImageEffectPassOverride {
@@ -360,8 +375,9 @@ void CImage::setup () {
     // calculate full animation time (if any)
     this->m_animationTime = 0.0f;
 
-    for (const auto& cur : this->getTexture ()->getFrames ())
+    for (const auto& cur : this->getTexture ()->getFrames ()) {
         this->m_animationTime += cur->frametime;
+    }
 
     this->setupPasses ();
     this->m_initialized = true;
@@ -379,6 +395,8 @@ void CImage::setupPasses () {
 
     for (; cur != end; ++cur) {
         // TODO: PROPERLY CHECK EFFECT'S VISIBILITY AND TAKE IT INTO ACCOUNT
+        // TODO: THIS REQUIRES ON-THE-FLY EVALUATION OF EFFECTS VISIBILITY TO FIGURE OUT
+        // TODO: WHICH ONE IS THE LAST + A FEW OTHER THINGS
         Effects::CPass* pass = *cur;
         std::shared_ptr<const CFBO> prevDrawTo = drawTo;
         GLuint spacePosition = (first) ? this->getCopySpacePosition () : this->getPassSpacePosition ();

From fae2b5e01e2a6ca39ed144cdcba336651b604690 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Wed, 20 Aug 2025 01:41:01 +0200
Subject: [PATCH 17/23] chore: parse hex colors in properties

---
 .../Core/Projects/CPropertyColor.cpp          | 24 +++++++++++++++++++
 .../Core/Projects/CPropertyCombo.cpp          | 10 ++++++--
 .../Data/Parsers/ProjectParser.cpp            | 14 ++++++++++-
 3 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp b/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
index a60ff88..045f6f9 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
+++ b/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
@@ -14,6 +14,30 @@ glm::vec3 ParseColor (std::string value) {
     }
 
     if (value.find ('.') == std::string::npos && value != "0 0 0" && value != "1 1 1") {
+        if (value.find ('#') == 0) {
+            // hex color, parse it to int color and then convert it to float
+            auto number = value.substr (1);
+
+            if (number.size () == 3) {
+                // CSS short-number, expand to the proper size
+                number = number[0] + number[0] + number[1] + number[1] + number[2] + number[2];
+            }
+
+            // remove alpha if it's present, should look into it more closely
+            if (number.size () > 6) {
+                sLog.error ("Color value has alpha channel, which is not supported");
+                number = number.substr (0, 6);
+            }
+
+            const auto color = std::stoi (number, nullptr, 16);
+
+            return {
+                (((color >> 16) & 0xFF) / 255.0),
+                (((color >> 8) & 0xFF) / 255.0),
+                (((color >> 0) & 0xFF) / 255.0)
+            };
+        }
+
         const auto intcolor = VectorBuilder::parse <glm::ivec3> (value);
 
         return {intcolor.r / 255.0, intcolor.g / 255.0, intcolor.b / 255.0};
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp b/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
index e73fd2a..2784802 100644
--- a/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
+++ b/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
@@ -19,17 +19,23 @@ std::shared_ptr<CPropertyCombo> CPropertyCombo::fromJSON (const JSON& data, std:
         if (!cur.is_object ())
             continue;
 
+        const auto valueIt = cur.require ("value", "Value is required for a property combo option");
+        auto value = valueIt.is_number () ? std::to_string (valueIt.get <int> ()) : valueIt.get <std::string> ();
+
         // check for label and value to ensure they're there
         values.push_back ({
             .label = cur.require ("label", "Label is required for a property combo option"),
-            .value = cur.require ("value", "Value is required for a property combo option")
+            .value = value
         });
     }
 
+    const auto valueIt = data.require ("value", "Value is required for a property combo");
+    auto value = valueIt.is_number () ? std::to_string (valueIt.get <int> ()) : valueIt.get <std::string> ();
+
     return std::make_shared <CPropertyCombo> (
         std::move(name),
         data.optional <std::string> ("text", ""),
-        data.require ("value", "Value is required for a property combo"),
+        value,
         values
     );
 }
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
index 9f2c7c7..6b6b325 100644
--- a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
@@ -14,15 +14,27 @@ static int backgroundId = 0;
 
 ProjectUniquePtr ProjectParser::parse (const JSON& data, ContainerUniquePtr container) {
     const auto general = data.optional ("general");
+    const auto workshopId = data.optional ("workshopid");
+    auto actualWorkshopId = std::to_string (--backgroundId);
     auto type = data.require <std::string> ("type", "Project type missing");
 
+    if (workshopId.has_value ()) {
+        if (workshopId->is_number ()) {
+            actualWorkshopId = std::to_string (workshopId->get <int> ());
+        } else if (workshopId->is_string ()) {
+            actualWorkshopId = workshopId->get <std::string> ();
+        } else {
+            sLog.error ("Invalid workshop id: ", workshopId->dump ());
+        }
+    }
+
     // lowercase for consistency
     std::transform (type.begin (), type.end (), type.begin (), tolower);
 
     auto result = std::make_unique <Project> (Project {
         .title = data.require <std::string> ("title", "Project title missing"),
         .type = parseType (type),
-        .workshopId = data.optional ("workshopid", std::to_string (--backgroundId)),
+        .workshopId = actualWorkshopId,
         .supportsAudioProcessing = general.has_value () && general.value ().optional ("supportsaudioprocessing", false),
         .properties = parseProperties (general),
         .container = std::move(container),

From f400b2abd92453d7fde2d1e757a7971002613c48 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sat, 23 Aug 2025 06:09:53 +0200
Subject: [PATCH 18/23] chore: replace old properties with ones following the
 new model

---
 CMakeLists.txt                                |  16 +-
 .../Application/CWallpaperApplication.cpp     |   7 +-
 .../Core/Projects/CProperty.cpp               |  46 ------
 src/WallpaperEngine/Core/Projects/CProperty.h |  55 -------
 .../Core/Projects/CPropertyBoolean.cpp        |  38 -----
 .../Core/Projects/CPropertyBoolean.h          |  21 ---
 .../Core/Projects/CPropertyColor.cpp          |  81 ----------
 .../Core/Projects/CPropertyColor.h            |  23 ---
 .../Core/Projects/CPropertyCombo.cpp          | 112 --------------
 .../Core/Projects/CPropertyCombo.h            |  42 ------
 .../Core/Projects/CPropertySlider.cpp         |  67 ---------
 .../Core/Projects/CPropertySlider.h           |  41 ------
 .../Core/Projects/CPropertyText.cpp           |  34 -----
 .../Core/Projects/CPropertyText.h             |  22 ---
 .../Data/Builders/UserSettingBuilder.h        |   2 +-
 .../Data/Model/DynamicValue.cpp               |   3 +
 src/WallpaperEngine/Data/Model/DynamicValue.h |   2 +-
 src/WallpaperEngine/Data/Model/Object.h       |  14 +-
 src/WallpaperEngine/Data/Model/Property.h     | 138 ++++++++++++++++++
 src/WallpaperEngine/Data/Model/Types.h        |  16 +-
 src/WallpaperEngine/Data/Model/UserSetting.h  |   2 +-
 .../Data/Parsers/ProjectParser.cpp            |   9 +-
 .../Data/Parsers/PropertyParser.cpp           |  98 +++++++++++++
 .../Data/Parsers/PropertyParser.h             |  20 +++
 .../Data/Parsers/UserSettingParser.cpp        |   6 +-
 .../Render/Objects/Effects/CPass.cpp          |   6 -
 .../Render/Objects/Effects/CPass.h            |   1 -
 .../Render/Shaders/CShader.cpp                |   1 -
 .../Render/Shaders/CShaderUnit.cpp            |   1 -
 29 files changed, 289 insertions(+), 635 deletions(-)
 delete mode 100644 src/WallpaperEngine/Core/Projects/CProperty.cpp
 delete mode 100644 src/WallpaperEngine/Core/Projects/CProperty.h
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyColor.h
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyCombo.h
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertySlider.h
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyText.cpp
 delete mode 100644 src/WallpaperEngine/Core/Projects/CPropertyText.h
 create mode 100644 src/WallpaperEngine/Data/Model/Property.h
 create mode 100644 src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
 create mode 100644 src/WallpaperEngine/Data/Parsers/PropertyParser.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 49e64a0..9f31433 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -400,19 +400,6 @@ add_executable(
     src/WallpaperEngine/WebBrowser/CWebBrowserContext.cpp
     src/WallpaperEngine/WebBrowser/CWebBrowserContext.h
 
-    src/WallpaperEngine/Core/Projects/CProperty.h
-    src/WallpaperEngine/Core/Projects/CProperty.cpp
-    src/WallpaperEngine/Core/Projects/CPropertyColor.h
-    src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
-    src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
-    src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
-    src/WallpaperEngine/Core/Projects/CPropertySlider.h
-    src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
-    src/WallpaperEngine/Core/Projects/CPropertyCombo.h
-    src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
-    src/WallpaperEngine/Core/Projects/CPropertyText.h
-    src/WallpaperEngine/Core/Projects/CPropertyText.cpp
-
     src/WallpaperEngine/Data/Model/Types.h
     src/WallpaperEngine/Data/Model/Project.h
     src/WallpaperEngine/Data/Model/Wallpaper.h
@@ -423,6 +410,7 @@ add_executable(
     src/WallpaperEngine/Data/Model/UserSetting.h
     src/WallpaperEngine/Data/Model/DynamicValue.h
     src/WallpaperEngine/Data/Model/DynamicValue.cpp
+    src/WallpaperEngine/Data/Model/Property.h
     src/WallpaperEngine/Data/Utils/TypeCaster.cpp
     src/WallpaperEngine/Data/Utils/TypeCaster.h
     src/WallpaperEngine/Data/Utils/SFINAE.h
@@ -440,6 +428,8 @@ add_executable(
     src/WallpaperEngine/Data/Parsers/ModelParser.h
     src/WallpaperEngine/Data/Parsers/ShaderConstantParser.cpp
     src/WallpaperEngine/Data/Parsers/ShaderConstantParser.h
+    src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
+    src/WallpaperEngine/Data/Parsers/PropertyParser.h
     src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
     src/WallpaperEngine/Data/Builders/VectorBuilder.cpp
     src/WallpaperEngine/Data/Builders/VectorBuilder.h
diff --git a/src/WallpaperEngine/Application/CWallpaperApplication.cpp b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
index a32ec59..cfdabc3 100644
--- a/src/WallpaperEngine/Application/CWallpaperApplication.cpp
+++ b/src/WallpaperEngine/Application/CWallpaperApplication.cpp
@@ -10,12 +10,11 @@
 #include "WallpaperEngine/Render/CRenderContext.h"
 #include "WallpaperEngine/Render/Drivers/CVideoFactories.h"
 
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-
 #include "WallpaperEngine/Data/Parsers/ProjectParser.h"
 #include "WallpaperEngine/Data/Dumpers/StringPrinter.h"
 
 #include "WallpaperEngine/Data/Model/Wallpaper.h"
+#include "WallpaperEngine/Data/Model/Property.h"
 
 #if DEMOMODE
 #include "recording.h"
@@ -227,11 +226,11 @@ void CWallpaperApplication::setupPropertiesForProject (const Project& project) {
         if (override != this->m_context.settings.general.properties.end ()) {
             sLog.out ("Applying override value for ", key);
 
-            cur->set (override->second);
+            cur->update (override->second);
         }
 
         if (this->m_context.settings.general.onlyListProperties)
-            sLog.out (cur->dump ());
+            sLog.out (cur->toString ());
     }
 }
 
diff --git a/src/WallpaperEngine/Core/Projects/CProperty.cpp b/src/WallpaperEngine/Core/Projects/CProperty.cpp
deleted file mode 100644
index 0b40e9d..0000000
--- a/src/WallpaperEngine/Core/Projects/CProperty.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "CProperty.h"
-#include "CPropertyBoolean.h"
-#include "CPropertyColor.h"
-#include "CPropertyCombo.h"
-#include "CPropertySlider.h"
-#include "CPropertyText.h"
-#include "WallpaperEngine/Logging/CLog.h"
-#include <iostream>
-#include <utility>
-
-using namespace WallpaperEngine::Core::Projects;
-
-std::shared_ptr<CProperty> CProperty::fromJSON (const JSON& data, const std::string& name) {
-    const auto type = data.require <std::string> ("type", "Project properties must have the type field");
-
-    if (type == "color")
-        return CPropertyColor::fromJSON (data, name);
-    if (type == "bool")
-        return CPropertyBoolean::fromJSON (data, name);
-    if (type == "slider")
-        return CPropertySlider::fromJSON (data, name);
-    if (type == "combo")
-        return CPropertyCombo::fromJSON (data, name);
-    if (type == "text")
-        return CPropertyText::fromJSON (data, name);
-
-    if (type != "group") {
-        // show the error and ignore this property
-        sLog.error ("Unexpected type for property: ", type);
-        sLog.error (data);
-    }
-
-    return nullptr;
-}
-
-CProperty::CProperty (std::string name, std::string text) :
-    m_name (std::move(name)),
-    m_text (std::move(text)) {}
-
-const std::string& CProperty::getName () const {
-    return this->m_name;
-}
-
-const std::string& CProperty::getText () const {
-    return this->m_text;
-}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Core/Projects/CProperty.h b/src/WallpaperEngine/Core/Projects/CProperty.h
deleted file mode 100644
index 80f49a4..0000000
--- a/src/WallpaperEngine/Core/Projects/CProperty.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#pragma once
-
-#include "WallpaperEngine/Data/Utils/TypeCaster.h"
-#include "WallpaperEngine/Data/Model/DynamicValue.h"
-#include "WallpaperEngine/Data/JSON.h"
-
-namespace WallpaperEngine::Core::Projects {
-using JSON = WallpaperEngine::Data::JSON::JSON;
-using namespace WallpaperEngine::Data::Model;
-using namespace WallpaperEngine::Data::Utils;
-/**
- * Represents a property in a background
- *
- * Properties are settings that alter how the background looks or works
- * and are configurable by the user so they can customize it to their likings
- */
-class CProperty : public DynamicValue, public TypeCaster {
-  public:
-    using UniquePtr = std::unique_ptr<CProperty>;
-    using SharedPtr = std::shared_ptr<CProperty>;
-    using WeakPtr = std::weak_ptr<CProperty>;
-
-    static std::shared_ptr<CProperty> fromJSON (const JSON& data, const std::string& name);
-
-    /**
-     * @return Representation of what the property does and the default values
-     */
-    [[nodiscard]] virtual std::string dump () const = 0;
-    /**
-     * Updates the value of the property with the one in the string
-     *
-     * @param value New value for the property
-     */
-    virtual void set (const std::string& value) = 0;
-    /**
-     * @return Name of the property
-     */
-    [[nodiscard]] const std::string& getName () const;
-    /**
-     * @return Textual type representation of this property
-     */
-    [[nodiscard]] virtual const char* getPropertyType () const = 0;
-    /**
-     * @return Text of the property
-     */
-    [[nodiscard]] const std::string& getText () const;
-
-  protected:
-    CProperty (std::string name, std::string text);
-    /** Name of the property */
-    const std::string m_name;
-    /** Description of the property for the user */
-    mutable std::string m_text;
-};
-} // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp b/src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
deleted file mode 100644
index dc1d0f6..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include <sstream>
-#include <utility>
-
-#include "CPropertyBoolean.h"
-
-using namespace WallpaperEngine::Core::Projects;
-
-std::shared_ptr<CPropertyBoolean> CPropertyBoolean::fromJSON (const JSON& data, std::string name) {
-    return std::make_shared <CPropertyBoolean> (
-        data.require ("value", "Boolean property must have a value"),
-        std::move(name),
-        data.optional <std::string> ("text", "")
-    );
-}
-
-
-void CPropertyBoolean::set (const std::string& value) {
-    this->update (value == "1" || value == "true" || value == "on");
-}
-
-std::string CPropertyBoolean::dump () const {
-    std::stringstream ss;
-
-    ss << this->m_name << " - boolean" << std::endl
-       << "\t"
-       << "Description: " << this->m_text << std::endl
-       << "\t"
-       << "Value: " << &this->getBool ();
-
-    return ss.str ();
-}
-
-const char* CPropertyBoolean::getPropertyType () const {
-    return "bool";
-}
-
-CPropertyBoolean::CPropertyBoolean (bool value, std::string name, std::string text) :
-    CProperty (std::move(name), std::move(text)) {}
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.h b/src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
deleted file mode 100644
index 72f3f85..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyBoolean.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "CProperty.h"
-
-namespace WallpaperEngine::Core::Projects {
-using JSON = WallpaperEngine::Data::JSON::JSON;
-
-/**
- * Represents a boolean property
- */
-class CPropertyBoolean final : public CProperty {
-  public:
-    CPropertyBoolean (bool value, std::string name, std::string text);
-
-    static std::shared_ptr<CPropertyBoolean> fromJSON (const JSON& data, std::string name);
-    [[nodiscard]] std::string dump () const override;
-    void set (const std::string& value) override;
-
-    [[nodiscard]] const char* getPropertyType () const override;
-};
-} // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp b/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
deleted file mode 100644
index 045f6f9..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyColor.cpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#include <sstream>
-#include <utility>
-
-#include "CPropertyColor.h"
-
-using namespace WallpaperEngine::Data::Builders;
-using namespace WallpaperEngine::Core::Projects;
-
-glm::vec3 ParseColor (std::string value) {
-    // TODO: ENSURE THIS PARSING IS ACTUALLY ACCURATE
-    if (value.find (',') != std::string::npos) {
-        // replace commas with dots so it can be parsed
-        std::replace (value.begin (), value.end (), ',', ' ');
-    }
-
-    if (value.find ('.') == std::string::npos && value != "0 0 0" && value != "1 1 1") {
-        if (value.find ('#') == 0) {
-            // hex color, parse it to int color and then convert it to float
-            auto number = value.substr (1);
-
-            if (number.size () == 3) {
-                // CSS short-number, expand to the proper size
-                number = number[0] + number[0] + number[1] + number[1] + number[2] + number[2];
-            }
-
-            // remove alpha if it's present, should look into it more closely
-            if (number.size () > 6) {
-                sLog.error ("Color value has alpha channel, which is not supported");
-                number = number.substr (0, 6);
-            }
-
-            const auto color = std::stoi (number, nullptr, 16);
-
-            return {
-                (((color >> 16) & 0xFF) / 255.0),
-                (((color >> 8) & 0xFF) / 255.0),
-                (((color >> 0) & 0xFF) / 255.0)
-            };
-        }
-
-        const auto intcolor = VectorBuilder::parse <glm::ivec3> (value);
-
-        return {intcolor.r / 255.0, intcolor.g / 255.0, intcolor.b / 255.0};
-    }
-
-    return VectorBuilder::parse <glm::vec3> (value);
-}
-
-std::shared_ptr<CPropertyColor> CPropertyColor::fromJSON (const JSON& data, std::string name) {
-    return std::make_shared <CPropertyColor> (
-        data.require ("value", "Color property must have a value"),
-        std::move(name),
-        data.optional <std::string> ("text", "")
-    );
-}
-
-void CPropertyColor::set (const std::string& value) {
-    this->update (ParseColor (std::string (value)));
-}
-
-std::string CPropertyColor::dump () const {
-    const auto color = this->getVec3 ();
-    std::stringstream ss;
-
-    ss << this->m_name << " - color" << std::endl
-       << "\t"
-       << "Description: " << this->m_text << std::endl
-       << "\t"
-       << "R: " << color.r << " G: " << color.g << " B: " << color.b;
-
-    return ss.str ();
-}
-
-const char* CPropertyColor::getPropertyType () const {
-    return "color";
-}
-
-CPropertyColor::CPropertyColor (const std::string& color, std::string name, std::string text) :
-    CProperty (std::move(name), std::move(text)) {
-    this->set (color);
-}
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyColor.h b/src/WallpaperEngine/Core/Projects/CPropertyColor.h
deleted file mode 100644
index 4718e59..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyColor.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-#include "CProperty.h"
-
-#include "WallpaperEngine/Data/JSON.h"
-
-namespace WallpaperEngine::Core::Projects {
-using JSON = WallpaperEngine::Data::JSON::JSON;
-
-/**
- * Represents a color property
- */
-class CPropertyColor final : public CProperty {
-  public:
-    CPropertyColor (const std::string& color, std::string name, std::string text);
-
-    static std::shared_ptr<CPropertyColor> fromJSON (const JSON& data, std::string name);
-    [[nodiscard]] std::string dump () const override;
-    void set (const std::string& value) override;
-
-    [[nodiscard]] const char* getPropertyType () const override;
-};
-} // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp b/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
deleted file mode 100644
index 2784802..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyCombo.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include <sstream>
-#include <utility>
-
-#include "CPropertyCombo.h"
-
-#include "WallpaperEngine/Logging/CLog.h"
-
-using namespace WallpaperEngine::Core::Projects;
-
-std::shared_ptr<CPropertyCombo> CPropertyCombo::fromJSON (const JSON& data, std::string name) {
-    std::vector<CPropertyComboValue> values;
-    const auto options = data.require ("options", "Options for a property combo is required");
-
-    if (!options.is_array ())
-        sLog.exception ("Property combo options should be an array");
-
-    for (auto& cur : options) {
-        // TODO: PROPERLY REPORT THESE ISSUES
-        if (!cur.is_object ())
-            continue;
-
-        const auto valueIt = cur.require ("value", "Value is required for a property combo option");
-        auto value = valueIt.is_number () ? std::to_string (valueIt.get <int> ()) : valueIt.get <std::string> ();
-
-        // check for label and value to ensure they're there
-        values.push_back ({
-            .label = cur.require ("label", "Label is required for a property combo option"),
-            .value = value
-        });
-    }
-
-    const auto valueIt = data.require ("value", "Value is required for a property combo");
-    auto value = valueIt.is_number () ? std::to_string (valueIt.get <int> ()) : valueIt.get <std::string> ();
-
-    return std::make_shared <CPropertyCombo> (
-        std::move(name),
-        data.optional <std::string> ("text", ""),
-        value,
-        values
-    );
-}
-
-CPropertyCombo::CPropertyCombo (
-    std::string name, std::string text, const std::string& defaultValue,
-    std::vector<CPropertyComboValue> values
-) :
-    CProperty (std::move(name), std::move(text)),
-    m_values (std::move(values)) {
-    this->set (defaultValue);
-}
-
-std::string CPropertyCombo::dump () const {
-    std::stringstream ss;
-
-    ss << this->m_name << " - combolist" << std::endl
-       << "\t"
-       << "Description: " << this->m_text << std::endl
-       << "\t"
-       << "Value: " << &this->getInt () << std::endl
-       << "\t\t"
-       << "Posible values:" << std::endl;
-
-    for (const auto& cur : this->m_values)
-        ss << "\t\t" << cur.label << " -> " << cur.value << std::endl;
-
-    return ss.str ();
-}
-
-void CPropertyCombo::set (const std::string& value) {
-    bool found = false;
-    int index = 0;
-
-    // ensure the value is present somewhere in the value list
-    for (const auto& cur : this->m_values) {
-        if (cur.value == value) {
-            found = true;
-            break;
-        }
-
-        index ++;
-    }
-
-    if (!found)
-        sLog.exception ("Assigning invalid value to property ", this->m_name);
-
-    this->update (index);
-}
-
-int CPropertyCombo::translateValueToIndex (const std::string& value) const {
-    bool found = false;
-    int index = 0;
-
-    // ensure the value is present somewhere in the value list
-    for (const auto& cur : this->m_values) {
-        if (cur.value == value) {
-            found = true;
-            break;
-        }
-
-        index ++;
-    }
-
-    if (!found) {
-        return -1;
-    }
-
-    return index;
-}
-
-const char* CPropertyCombo::getPropertyType () const {
-    return "combo";
-}
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyCombo.h b/src/WallpaperEngine/Core/Projects/CPropertyCombo.h
deleted file mode 100644
index 9d7b323..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyCombo.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#pragma once
-
-#include "CProperty.h"
-
-namespace WallpaperEngine::Core::Projects {
-using JSON = WallpaperEngine::Data::JSON::JSON;;
-
-/**
- * Represents different combo values
- */
-struct CPropertyComboValue {
-  public:
-    const std::string label;
-    const std::string value;
-};
-
-/**
- * Represents a combo property
- *
- * Combos are properties that have different values available and only one can be selected at once
- * this limits the user's possibilities, used for things like the amount of samples to use in audioprocessing
- * backgrounds
- */
-class CPropertyCombo final : public CProperty {
-  public:
-    static std::shared_ptr<CPropertyCombo> fromJSON (const JSON& data, std::string name);
-
-    CPropertyCombo (
-        std::string name, std::string text, const std::string& defaultValue,
-        std::vector<CPropertyComboValue> values);
-
-    [[nodiscard]] std::string dump () const override;
-    void set (const std::string& value) override;
-    int translateValueToIndex (const std::string& value) const;
-
-    [[nodiscard]] const char* getPropertyType () const override;
-
-  private:
-    /** List of values available to select */
-    const std::vector<CPropertyComboValue> m_values;
-};
-} // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Core/Projects/CPropertySlider.cpp b/src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
deleted file mode 100644
index f8b7d47..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertySlider.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include "CPropertySlider.h"
-#include "WallpaperEngine/Logging/CLog.h"
-#include <sstream>
-
-using namespace WallpaperEngine::Core::Projects;
-
-std::shared_ptr<CPropertySlider> CPropertySlider::fromJSON (const JSON& data, const std::string& name) {
-    const auto value = data.find ("value");
-    const auto text = data.optional <std::string> ("text", "");
-    const auto min = data.optional ("min", 0.0f);
-    const auto max = data.optional ("max", 0.0f);
-    const auto step = data.optional ("step", 0.0f);
-
-    return std::make_shared <CPropertySlider> (*value, name, text, min, max, step);
-}
-
-const float& CPropertySlider::getMinValue () const {
-    return this->m_min;
-}
-
-const float& CPropertySlider::getMaxValue () const {
-    return this->m_max;
-}
-
-const float& CPropertySlider::getStep () const {
-    return this->m_step;
-}
-
-std::string CPropertySlider::dump () const {
-    std::stringstream ss;
-
-    ss << this->m_name << " - slider" << std::endl
-       << "\t"
-       << "Description: " << this->m_text << std::endl
-       << "\t"
-       << "Value: " << &this->getFloat () << std::endl
-       << "\t"
-       << "Minimum value: " << this->m_min << std::endl
-       << "\t"
-       << "Maximum value: " << this->m_max << std::endl
-       << "\t"
-       << "Step: " << this->m_step << std::endl;
-
-    return ss.str ();
-}
-
-void CPropertySlider::set (const std::string& value) {
-    const auto newValue = strtof (value.c_str (), nullptr);
-
-    if (newValue < this->m_min || newValue > this->m_max)
-        sLog.exception ("Slider value (", newValue, ") is out of range (", this->m_min, ",", this->m_max, ")");
-
-    this->update (newValue);
-}
-
-const char* CPropertySlider::getPropertyType () const {
-    return "slider";
-}
-
-CPropertySlider::CPropertySlider (float value, const std::string& name, const std::string& text, float min,
-                                  float max, float step) :
-    CProperty (name, text),
-    m_min (min),
-    m_max (max),
-    m_step (step) {
-    this->update (value);
-}
diff --git a/src/WallpaperEngine/Core/Projects/CPropertySlider.h b/src/WallpaperEngine/Core/Projects/CPropertySlider.h
deleted file mode 100644
index bfb13f2..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertySlider.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#include "CProperty.h"
-
-namespace WallpaperEngine::Core::Projects {
-using JSON = WallpaperEngine::Data::JSON::JSON;
-
-/**
- * Represents a slider value with a minimum and maximum value
- */
-class CPropertySlider final : public CProperty {
-  public:
-    CPropertySlider (float value, const std::string& name, const std::string& text, float min, float max, float step);
-
-    static std::shared_ptr<CPropertySlider> fromJSON (const JSON& data, const std::string& name);
-    /**
-     * @return The slider's minimum value
-     */
-    [[nodiscard]] const float& getMinValue () const;
-    /**
-     * @return The slider's maximum value
-     */
-    [[nodiscard]] const float& getMaxValue () const;
-    /**
-     * @return The slider's value increment steps, only really used in the UI
-     */
-    [[nodiscard]] const float& getStep () const;
-    [[nodiscard]] std::string dump () const override;
-    void set (const std::string& value) override;
-
-    [[nodiscard]] const char* getPropertyType () const override;
-
-  private:
-    /** Minimum value */
-    const float m_min;
-    /** Maximum value */
-    const float m_max;
-    /** Increment steps for the slider in the UI */
-    const float m_step;
-};
-} // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyText.cpp b/src/WallpaperEngine/Core/Projects/CPropertyText.cpp
deleted file mode 100644
index 6e27910..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyText.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "CPropertyText.h"
-#include <sstream>
-#include <utility>
-
-using namespace WallpaperEngine::Core::Projects;
-
-std::shared_ptr<CPropertyText> CPropertyText::fromJSON (const JSON& data, std::string name) {
-    //TODO: VALIDATE THIS IS RIGHT
-    return std::make_shared <CPropertyText> (
-        std::move(name),
-        data.optional <std::string> ("text", "")
-    );
-}
-
-std::string CPropertyText::dump () const {
-    std::stringstream ss;
-
-    ss << this->m_name << " - text" << std::endl
-       << "\t"
-       << "Value: " << this->m_text;
-
-    return ss.str ();
-}
-
-void CPropertyText::set (const std::string& value) {
-    this->m_text = value;
-}
-
-const char* CPropertyText::getPropertyType () const {
-    return "text";
-}
-
-CPropertyText::CPropertyText (std::string name, std::string text) :
-    CProperty (std::move(name), std::move(text)) {}
diff --git a/src/WallpaperEngine/Core/Projects/CPropertyText.h b/src/WallpaperEngine/Core/Projects/CPropertyText.h
deleted file mode 100644
index b64e88d..0000000
--- a/src/WallpaperEngine/Core/Projects/CPropertyText.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "CProperty.h"
-
-namespace WallpaperEngine::Core::Projects {
-using JSON = WallpaperEngine::Data::JSON::JSON;
-
-/**
- * Represents a text property
- */
-class CPropertyText final : public CProperty {
-  public:
-    CPropertyText (std::string name, std::string text);
-
-    static std::shared_ptr<CPropertyText> fromJSON (const JSON& data, std::string name);
-    [[nodiscard]] std::string dump () const override;
-    void set (const std::string& value) override;
-
-    [[nodiscard]] const char* getPropertyType () const override;
-  private:
-};
-} // namespace WallpaperEngine::Core::Projects
diff --git a/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
index 82c55cc..e3d4335 100644
--- a/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
+++ b/src/WallpaperEngine/Data/Builders/UserSettingBuilder.h
@@ -13,7 +13,7 @@ class UserSettingBuilder {
 
         return std::make_unique <UserSetting> (UserSetting {
             .value = std::move (value),
-            .property = PropertyWeakPtr (),
+            .property = PropertySharedPtr (),
             .condition = std::nullopt,
         });
     }
diff --git a/src/WallpaperEngine/Data/Model/DynamicValue.cpp b/src/WallpaperEngine/Data/Model/DynamicValue.cpp
index 7450ac3..bc99a6e 100644
--- a/src/WallpaperEngine/Data/Model/DynamicValue.cpp
+++ b/src/WallpaperEngine/Data/Model/DynamicValue.cpp
@@ -271,6 +271,9 @@ void DynamicValue::connect (DynamicValue* other) {
         this->update (other);
     });
 
+    // update our value on connection
+    this->update (*other);
+
     this->m_connections.push_back (deregisterFunction);
 }
 
diff --git a/src/WallpaperEngine/Data/Model/DynamicValue.h b/src/WallpaperEngine/Data/Model/DynamicValue.h
index 6d6f1d9..7bf8ccc 100644
--- a/src/WallpaperEngine/Data/Model/DynamicValue.h
+++ b/src/WallpaperEngine/Data/Model/DynamicValue.h
@@ -45,7 +45,7 @@ class DynamicValue {
     [[nodiscard]] const int& getInt () const;
     [[nodiscard]] const bool& getBool () const;
     [[nodiscard]] UnderlyingType getType () const;
-    [[nodiscard]] std::string toString () const;
+    [[nodiscard]] virtual std::string toString () const;
 
     void update (float newValue);
     void update (int newValue);
diff --git a/src/WallpaperEngine/Data/Model/Object.h b/src/WallpaperEngine/Data/Model/Object.h
index 0dfdf8b..8e3e9b1 100644
--- a/src/WallpaperEngine/Data/Model/Object.h
+++ b/src/WallpaperEngine/Data/Model/Object.h
@@ -65,7 +65,7 @@ struct ImageEffect {
     /** Effect's name for the editor */
     std::string name;
     /** If this effect is visible or not */
-    UserSettingSharedPtr visible;
+    UserSettingUniquePtr visible;
     /** Pass overrides to apply to the effect's passes */
     std::vector <ImageEffectPassOverrideUniquePtr> passOverrides;
     /** The effect definition */
@@ -74,17 +74,17 @@ struct ImageEffect {
 
 struct ImageData {
     /** The point of origin of the image */
-    UserSettingSharedPtr origin;
+    UserSettingUniquePtr origin;
     /** The scale of the image */
-    UserSettingSharedPtr scale;
+    UserSettingUniquePtr scale;
     /** The rotation of the image */
-    UserSettingSharedPtr angles;
+    UserSettingUniquePtr angles;
     /** If the image is visible or not */
-    UserSettingSharedPtr visible;
+    UserSettingUniquePtr visible;
     /** The alpha of the image */
-    UserSettingSharedPtr alpha;
+    UserSettingUniquePtr alpha;
     /** The color of the image */
-    UserSettingSharedPtr color;
+    UserSettingUniquePtr color;
     // TODO: WRITE A COUPLE OF ENUMS FOR THIS
     /** The alignment of the image */
     std::string alignment;
diff --git a/src/WallpaperEngine/Data/Model/Property.h b/src/WallpaperEngine/Data/Model/Property.h
new file mode 100644
index 0000000..d919e9c
--- /dev/null
+++ b/src/WallpaperEngine/Data/Model/Property.h
@@ -0,0 +1,138 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <utility>
+#include "DynamicValue.h"
+#include "../Utils/TypeCaster.h"
+
+namespace WallpaperEngine::Data::Model {
+using namespace WallpaperEngine::Data::Utils;
+using namespace WallpaperEngine::Data::Builders;
+
+struct PropertyData {
+    std::string name;
+    std::string text;
+};
+
+struct SliderData {
+    float min;
+    float max;
+    float step;
+};
+
+struct ComboData {
+    std::map<std::string, std::string> values;
+};
+
+class Property : public DynamicValue, public TypeCaster, public PropertyData {
+  public:
+    explicit Property (PropertyData data) : PropertyData (std::move(data)), TypeCaster (), DynamicValue () {}
+
+    using DynamicValue::update;
+    virtual void update(const std::string& value) = 0;
+};
+
+class PropertySlider : public Property, SliderData {
+  public:
+    PropertySlider (PropertyData data, SliderData sliderData, float value) : Property (std::move(data)), SliderData (sliderData) {
+        this->update (value);
+    }
+
+    using Property::update;
+    void update(const std::string& value) override {
+        this->update (std::stof (value));
+    }
+};
+
+class PropertyBoolean : public Property {
+  public:
+    explicit PropertyBoolean (PropertyData data, bool value) : Property (std::move(data)) {
+        this->update (value);
+    }
+
+    using Property::update;
+    void update(const std::string& value) override {
+        this->update (value == "true" || value == "1");
+    }
+};
+
+class PropertyColor : public Property {
+  public:
+    explicit PropertyColor (PropertyData data, std::string value) : Property (std::move(data)) {
+        this->update (value);
+    }
+
+    using Property::update;
+    void update(const std::string& value) override {
+        auto copy = value;
+
+        // TODO: ENSURE ALL THIS PARSING IS CORRECT
+        if (copy.find (',') != std::string::npos) {
+            // replace comma separator with spaces so it's
+            std::replace (copy.begin (), copy.end (), ',', ' ');
+        }
+
+        // hex colors should be converted to int colors
+        if (copy.find ('#') == 0) {
+            auto number = copy.substr (1);
+
+            // support for css notation
+            if (number.size () == 3) {
+                number = number[0] + number[0] + number[1] + number[1] + number[2] + number[2];
+            }
+
+            // remove alpha if it's present, should look into it more closely
+            if (number.size () > 6) {
+                sLog.error ("Color value has alpha channel, which is not supported");
+                number = number.substr (0, 6);
+            }
+
+            const auto color = std::stoi (number, nullptr, 16);
+
+            // format the number as float vector
+            copy =
+                std::to_string (((color >> 16) & 0xFF) / 255.0) + " " +
+                std::to_string (((color >> 8) & 0xFF) / 255.0) + " " +
+                std::to_string ((color & 0xFF) / 255.0);
+        } else if (copy.find ('.') == std::string::npos) {
+            // integer vector, convert it to float vector
+            const auto intcolor = VectorBuilder::parse <glm::ivec3> (copy);
+
+            copy =
+                std::to_string (intcolor.r / 255.0) + " " +
+                std::to_string (intcolor.g / 255.0) + " " +
+                std::to_string (intcolor.b / 255.0);
+        }
+
+        // finally parse the string as a float vector
+        this->update (VectorBuilder::parse <glm::vec3> (copy));
+    }
+};
+
+class PropertyCombo : public Property, ComboData {
+  public:
+    PropertyCombo (PropertyData data, ComboData comboData, std::string value) : Property (std::move(data)), ComboData (std::move(comboData)) {
+        this->update (value);
+    }
+
+    using Property::update;
+    void update(const std::string& value) override {
+        this->update (std::stoi (value));
+    }
+};
+
+class PropertyText : public Property {
+  public:
+    explicit PropertyText (PropertyData data) : Property (std::move(data)) {}
+
+    using Property::update;
+    void update(const std::string& value) override {
+        throw std::runtime_error ("PropertyText::update() is not implemented");
+    }
+
+    [[nodiscard]] std::string toString () const override {
+        return this->text;
+    }
+};
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Model/Types.h b/src/WallpaperEngine/Data/Model/Types.h
index 6fff328..4d4e374 100644
--- a/src/WallpaperEngine/Data/Model/Types.h
+++ b/src/WallpaperEngine/Data/Model/Types.h
@@ -8,10 +8,6 @@
 
 #include "WallpaperEngine/Assets/CContainer.h"
 
-namespace WallpaperEngine::Core::Projects {
-class CProperty;
-}
-
 namespace WallpaperEngine::Data::Model {
 struct Project;
 class Wallpaper;
@@ -26,6 +22,12 @@ struct ImageEffect;
 struct ImageEffectPassOverride;
 class Particle;
 class DynamicValue;
+class Property;
+class PropertySlider;
+class PropertyBoolean;
+class PropertyCombo;
+class PropertyText;
+class PropertyColor;
 struct Material;
 struct MaterialPass;
 struct FBO;
@@ -36,16 +38,10 @@ struct ModelStruct;
 // TODO: REMOVE ONCE THESE ARE RENAMED AND MOVED
 using Container = WallpaperEngine::Assets::CContainer;
 
-using Property = WallpaperEngine::Core::Projects::CProperty;
 using PropertySharedPtr = std::shared_ptr <Property>;
-using PropertyWeakPtr = std::weak_ptr <Property>;
 using Properties = std::map <std::string, PropertySharedPtr>;
 using DynamicValueUniquePtr = std::unique_ptr <DynamicValue>;
-using DynamicValueSharedPtr = std::shared_ptr <DynamicValue>;
-using DynamicValueWeakPtr = std::weak_ptr <DynamicValue>;
-using UserSettingSharedPtr = std::shared_ptr <UserSetting>;
 using UserSettingUniquePtr = std::unique_ptr <UserSetting>;
-using UserSettingWeakPtr = std::weak_ptr <UserSetting>;
 // TODO: UP TO THIS POINT
 
 using ShaderConstantMap = std::map <std::string, UserSettingUniquePtr>;
diff --git a/src/WallpaperEngine/Data/Model/UserSetting.h b/src/WallpaperEngine/Data/Model/UserSetting.h
index 7ef7c71..8ad1c9c 100644
--- a/src/WallpaperEngine/Data/Model/UserSetting.h
+++ b/src/WallpaperEngine/Data/Model/UserSetting.h
@@ -22,7 +22,7 @@ struct UserSetting {
      */
     DynamicValueUniquePtr value;
     /** The property this setting takes the value from (if specified) */
-    PropertyWeakPtr property;
+    PropertySharedPtr property;
     /** Condition required for this setting, this should be possible to run in JS' V8 */
     std::optional <ConditionInfo> condition;
     /** TODO: Value might come from a script and not have conditions, implement this later */
diff --git a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
index 6b6b325..8ccc31f 100644
--- a/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/ProjectParser.cpp
@@ -5,8 +5,8 @@
 
 #include "WallpaperParser.h"
 
+#include "PropertyParser.h"
 #include "WallpaperEngine/Data/Model/Wallpaper.h"
-#include "WallpaperEngine/Core/Projects/CProperty.h"
 
 using namespace WallpaperEngine::Data::Parsers;
 
@@ -70,18 +70,15 @@ Properties ProjectParser::parseProperties (const std::optional <JSON>& data) {
 
     Properties result = {};
 
-    // TODO: CHANGE THIS ONCE THE PROPERTIES PARSING IS HANDLED IN THE NEW TYPES
-    //  THESE ARE COMPLEX TYPES THAT INCLUDE SOME RUNTIME INFO THAT ISN'T EXPLICITLY DATA
-    //  SO THIS WILL NEED A RETHINK IN THE FUTURE
     for (const auto& cur : properties.value ().items ()) {
-        const auto& property = Property::fromJSON (cur.value (), cur.key ());
+        const auto& property = PropertyParser::parse (cur.value (), cur.key ());
 
         // ignore properties that failed, these are generally groups
         if (property == nullptr) {
             continue;
         }
 
-        result.emplace (property->getName (), property);
+        result.emplace (cur.key (), property);
     }
 
     return result;
diff --git a/src/WallpaperEngine/Data/Parsers/PropertyParser.cpp b/src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
new file mode 100644
index 0000000..93f1247
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
@@ -0,0 +1,98 @@
+#include "PropertyParser.h"
+#include "../Model/Property.h"
+
+using namespace WallpaperEngine::Data::Parsers;
+using namespace WallpaperEngine::Data::Model;
+
+PropertySharedPtr PropertyParser::parse (const JSON& it, std::string name) {
+    const auto type = it.require <std::string> ("type", "Property type is required");
+
+    if (type == "color") {
+        return parseColor (it, name);
+    }
+    if (type == "bool") {
+        return parseBoolean (it, name);
+    }
+    if (type == "slider") {
+        return parseSlider (it, name);
+    }
+    if (type == "combo") {
+        return parseCombo (it, name);
+    }
+    if (type == "text") {
+        return parseText (it, name);
+    }
+
+    if (type != "group") {
+        // show the error and ignore this property
+        sLog.error ("Unexpected type for property: ", type);
+        sLog.error (it.dump ());
+    }
+
+    return nullptr;
+}
+
+
+PropertySharedPtr PropertyParser::parseCombo (const JSON& it, std::string name) {
+    std::map <std::string, std::string> optionsMap = {};
+
+    const auto options = it.require ("options", "Combo property must have options");
+
+    if (!options.is_array ()) {
+        sLog.exception ("Property combo options should be an array");
+    }
+
+    for (auto& cur : options) {
+        if (!cur.is_object ()) {
+            continue;
+        }
+
+        const auto value = cur.require ("value", "Combo option must have a value");
+
+        optionsMap.emplace (
+            cur.require ("label", "Combo option must have a label"),
+            value.is_number () ? std::to_string (value.get <int> ()) : value.get <std::string> ()
+        );
+    }
+
+    const auto value = it.require ("value", "Combo property must have a value");
+
+    return std::make_shared <PropertyCombo> (PropertyData {
+        .name = name,
+        .text = it.optional <std::string> ("text", ""),
+    }, ComboData {
+        .values = optionsMap
+    }, value.is_number () ? std::to_string (value.get <int> ()) : value.get <std::string> ());
+}
+
+PropertySharedPtr PropertyParser::parseColor (const JSON& it, std::string name) {
+    return std::make_shared <PropertyColor> (PropertyData {
+        .name = name,
+        .text = it.optional <std::string> ("text", ""),
+    }, it.require ("value", "Property must have a value"));
+}
+
+PropertySharedPtr PropertyParser::parseBoolean (const JSON& it, std::string name) {
+    return std::make_shared <PropertyBoolean> (PropertyData {
+        .name = name,
+        .text = it.optional <std::string> ("text", ""),
+    }, it.require ("value", "Property must have a value"));
+}
+
+PropertySharedPtr PropertyParser::parseSlider (const JSON& it, std::string name) {
+    return std::make_shared <PropertySlider> (PropertyData {
+        .name = name,
+        .text = it.optional <std::string> ("text", ""),
+    }, SliderData {
+        .min = it.optional ("min", 0.0f),
+        .max = it.optional ("max", 0.0f),
+        .step = it.optional ("step", 0.0f),
+    }, it.require ("value", "Property must have a value"));
+}
+
+PropertySharedPtr PropertyParser::parseText (const JSON& it, std::string name) {
+    return std::make_shared <PropertyText> (PropertyData {
+        .name = name,
+        .text = it.optional <std::string> ("text", ""),
+    });
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/PropertyParser.h b/src/WallpaperEngine/Data/Parsers/PropertyParser.h
new file mode 100644
index 0000000..5dd2e83
--- /dev/null
+++ b/src/WallpaperEngine/Data/Parsers/PropertyParser.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "WallpaperEngine/Data/JSON.h"
+
+namespace WallpaperEngine::Data::Parsers {
+using JSON = WallpaperEngine::Data::JSON::JSON;
+using namespace WallpaperEngine::Data::Model;
+
+class PropertyParser {
+  public:
+    static PropertySharedPtr parse (const JSON& it, std::string name);
+
+  private:
+    static PropertySharedPtr parseCombo (const JSON& it, std::string name);
+    static PropertySharedPtr parseColor (const JSON& it, std::string name);
+    static PropertySharedPtr parseBoolean (const JSON& it, std::string name);
+    static PropertySharedPtr parseSlider (const JSON& it, std::string name);
+    static PropertySharedPtr parseText (const JSON& it, std::string name);
+};
+}
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp b/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
index 9d7224a..9fe7016 100644
--- a/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/UserSettingParser.cpp
@@ -1,13 +1,14 @@
 #include "UserSettingParser.h"
 
 #include "WallpaperEngine/Data/Model/UserSetting.h"
+#include "WallpaperEngine/Data/Model/Property.h"
 
 using namespace WallpaperEngine::Data::Parsers;
 using namespace WallpaperEngine::Data::Builders;
 
 UserSettingUniquePtr UserSettingParser::parse (const json& data, const Properties& properties) {
     DynamicValueUniquePtr value = std::make_unique <DynamicValue> ();
-    PropertyWeakPtr property;
+    PropertySharedPtr property;
     std::optional<ConditionInfo> condition;
     auto valueIt = data;
     std::string content = data.dump ();
@@ -64,6 +65,9 @@ UserSettingUniquePtr UserSettingParser::parse (const json& data, const Propertie
         value->update (valueIt.get <float> ());
     } else if (valueIt.is_boolean ()) {
         value->update (valueIt.get <bool> ());
+    } else if (valueIt.is_null () && property != nullptr) {
+        // null values are directly connected to the property
+        value->connect (property.get());
     } else {
         sLog.exception ("Unsupported user setting type ", valueIt.type_name ());
     }
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
index 03a0d81..7f3cfba 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.cpp
@@ -10,12 +10,6 @@
 #include "WallpaperEngine/Render/Objects/CImage.h"
 #include "WallpaperEngine/Render/CFBO.h"
 
-#include "WallpaperEngine/Core/Projects/CProperty.h"
-#include "WallpaperEngine/Core/Projects/CPropertyColor.h"
-#include "WallpaperEngine/Core/Projects/CPropertyCombo.h"
-#include "WallpaperEngine/Core/Projects/CPropertySlider.h"
-#include "WallpaperEngine/Core/Projects/CPropertyBoolean.h"
-
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariable.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariableFloat.h"
 #include "WallpaperEngine/Render/Shaders/Variables/CShaderVariableInteger.h"
diff --git a/src/WallpaperEngine/Render/Objects/Effects/CPass.h b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
index 553617c..a4a6efc 100644
--- a/src/WallpaperEngine/Render/Objects/Effects/CPass.h
+++ b/src/WallpaperEngine/Render/Objects/Effects/CPass.h
@@ -17,7 +17,6 @@ class CImage;
 namespace WallpaperEngine::Render::Objects::Effects {
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Render::Shaders::Variables;
-using namespace WallpaperEngine::Core::Projects;
 using namespace WallpaperEngine::Data::Model;
 
 class CPass final : public Helpers::CContextAware {
diff --git a/src/WallpaperEngine/Render/Shaders/CShader.cpp b/src/WallpaperEngine/Render/Shaders/CShader.cpp
index 947b9fd..75e7fbe 100644
--- a/src/WallpaperEngine/Render/Shaders/CShader.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShader.cpp
@@ -10,7 +10,6 @@
 
 #include "CGLSLContext.h"
 
-using namespace WallpaperEngine::Core;
 using namespace WallpaperEngine::Assets;
 
 namespace WallpaperEngine::Render::Shaders {
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index e9dba1a..c0b4f85 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -47,7 +47,6 @@
     "#define varying out\n"
 #define DEFINE_COMBO(name, value) "#define " + name + " " + std::to_string (value) + "\n";
 
-using namespace WallpaperEngine::Core;
 using namespace WallpaperEngine::Assets;
 using namespace WallpaperEngine::Data::Builders;
 using namespace WallpaperEngine::Render::Shaders;

From af02d82ea9a7ee2df8c1baffcfcff5c031d020dd Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sat, 23 Aug 2025 06:12:19 +0200
Subject: [PATCH 19/23] chore: remove annoying debug message that's not needed
 anymore

---
 src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index c0b4f85..78e8f4c 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -410,10 +410,6 @@ void CShaderUnit::parseParameterConfiguration (
         // TODO: BETTER CONVERSION HERE
         size_t index = value - '0';
 
-        if (combo != data.end () && paintDefaultColor != data.end () && combo->get <std::string> () == "MASK" && this->m_file.find ("water")) {
-            sLog.debug("mask defaultcolor!");
-        }
-
         if (combo != data.end ()) {
             // TODO: CLEANUP HOW THIS IS DETERMINED FIRST
             // if the texture exists (and is not null), add to the combo

From fc865499fcf19d27803e1db40a8163ec5d274b77 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sat, 23 Aug 2025 06:17:32 +0200
Subject: [PATCH 20/23] chore: remove some debug messages that are not useful
 anymore

---
 .../Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp    | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp b/src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp
index 915af85..9205a29 100644
--- a/src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp
+++ b/src/WallpaperEngine/Audio/Drivers/Recorders/CPulseAudioPlaybackRecorder.cpp
@@ -16,7 +16,7 @@ void pa_stream_notify_cb (pa_stream* stream, void* /*userdata*/) {
     switch (pa_stream_get_state (stream)) {
         case PA_STREAM_FAILED: sLog.error ("Cannot open stream for capture. Audio processing is disabled"); break;
         case PA_STREAM_READY: sLog.debug ("Capture stream ready"); break;
-        default: sLog.debug("pa_stream_get_state unknown result"); break;
+        default: break;
     }
 }
 
@@ -145,7 +145,6 @@ void pa_context_notify_cb (pa_context* ctx, void* userdata) {
             sLog.error ("PulseAudio context initialization failed. Audio processing is disabled");
             break;
         default:
-            sLog.debug ("pa_context_get_state unknown result");
             break;
     }
 }

From 9c62125a1f742bcb7cc3645c45fbfb829043bc5a Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sat, 23 Aug 2025 17:42:01 +0200
Subject: [PATCH 21/23] chore: add parsing of usertextures

---
 src/WallpaperEngine/Data/Model/Material.h          |  2 ++
 src/WallpaperEngine/Data/Model/Property.h          | 14 ++++++++++++++
 .../Data/Parsers/MaterialParser.cpp                |  6 ++++--
 .../Data/Parsers/PropertyParser.cpp                | 10 ++++++++++
 src/WallpaperEngine/Data/Parsers/PropertyParser.h  |  1 +
 src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp |  1 +
 6 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/src/WallpaperEngine/Data/Model/Material.h b/src/WallpaperEngine/Data/Model/Material.h
index 1b6f698..339d977 100644
--- a/src/WallpaperEngine/Data/Model/Material.h
+++ b/src/WallpaperEngine/Data/Model/Material.h
@@ -22,6 +22,8 @@ struct MaterialPass {
     std::string shader;
     /** List of textures defined for this pass */
     TextureMap textures;
+    /** List of user textures defined for this pass */
+    TextureMap usertextures;
     /** The combos and their values to pass onto the shader */
     ComboMap combos;
 };
diff --git a/src/WallpaperEngine/Data/Model/Property.h b/src/WallpaperEngine/Data/Model/Property.h
index d919e9c..de17ebf 100644
--- a/src/WallpaperEngine/Data/Model/Property.h
+++ b/src/WallpaperEngine/Data/Model/Property.h
@@ -135,4 +135,18 @@ class PropertyText : public Property {
         return this->text;
     }
 };
+
+class PropertySceneTexture : public Property {
+  public:
+    explicit PropertySceneTexture (PropertyData data, std::string value) : Property (std::move(data)) {
+        this->update (value);
+    }
+
+    void update(const std::string& value) override {
+        this->m_value = value;
+    }
+
+  private:
+    std::string m_value;
+};
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
index edc2d3f..ab9e5ea 100644
--- a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
@@ -35,6 +35,7 @@ std::vector <MaterialPassUniquePtr> MaterialParser::parsePasses (const JSON& it,
 
 MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, Project& project) {
     const auto textures = it.optional ("textures");
+    const auto usertextures = it.optional ("usertextures");
     const auto combos = it.optional ("combos");
     const auto constants = it.optional ("constants");
 
@@ -45,8 +46,9 @@ MaterialPassUniquePtr MaterialParser::parsePass (const JSON& it, Project& projec
         .depthtest = it.optional ("depthtest", std::string ("disabled")),
         .depthwrite = it.optional ("depthwrite", std::string ("disabled")),
         .shader = it.require <std::string> ("shader", "Material pass must have a shader"),
-        .textures = textures.has_value () ? parseTextures (*textures) : std::map <int, std::string> {},
-        .combos = combos.has_value () ? parseCombos (*combos) : std::map <std::string, int> {},
+        .textures = textures.has_value () ? parseTextures (*textures) : TextureMap {},
+        .usertextures = usertextures.has_value () ? parseTextures (*usertextures) : TextureMap {},
+        .combos = combos.has_value () ? parseCombos (*combos) : ComboMap {},
     });
 }
 
diff --git a/src/WallpaperEngine/Data/Parsers/PropertyParser.cpp b/src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
index 93f1247..aeacae4 100644
--- a/src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/PropertyParser.cpp
@@ -22,6 +22,9 @@ PropertySharedPtr PropertyParser::parse (const JSON& it, std::string name) {
     if (type == "text") {
         return parseText (it, name);
     }
+    if (type == "scenetexture") {
+        return parseSceneTexture (it, name);
+    }
 
     if (type != "group") {
         // show the error and ignore this property
@@ -95,4 +98,11 @@ PropertySharedPtr PropertyParser::parseText (const JSON& it, std::string name) {
         .name = name,
         .text = it.optional <std::string> ("text", ""),
     });
+}
+
+PropertySharedPtr PropertyParser::parseSceneTexture (const JSON& it, std::string name) {
+    return std::make_shared <PropertySceneTexture> (PropertyData {
+        .name = name,
+        .text = it.optional <std::string> ("text", ""),
+    }, it.require ("value", "Property must have a value"));
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Data/Parsers/PropertyParser.h b/src/WallpaperEngine/Data/Parsers/PropertyParser.h
index 5dd2e83..99383ad 100644
--- a/src/WallpaperEngine/Data/Parsers/PropertyParser.h
+++ b/src/WallpaperEngine/Data/Parsers/PropertyParser.h
@@ -16,5 +16,6 @@ class PropertyParser {
     static PropertySharedPtr parseBoolean (const JSON& it, std::string name);
     static PropertySharedPtr parseSlider (const JSON& it, std::string name);
     static PropertySharedPtr parseText (const JSON& it, std::string name);
+    static PropertySharedPtr parseSceneTexture (const JSON& it, std::string name);
 };
 }
\ No newline at end of file
diff --git a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
index 78e8f4c..9db5623 100644
--- a/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
+++ b/src/WallpaperEngine/Render/Shaders/CShaderUnit.cpp
@@ -409,6 +409,7 @@ void CShaderUnit::parseParameterConfiguration (
         // now convert it to integer
         // TODO: BETTER CONVERSION HERE
         size_t index = value - '0';
+        // TODO: SUPPORT USER TEXTURES!!
 
         if (combo != data.end ()) {
             // TODO: CLEANUP HOW THIS IS DETERMINED FIRST

From d6bcd62d1a941b8807cd437d5443e7e49b387abe Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sun, 31 Aug 2025 14:51:32 +0200
Subject: [PATCH 22/23] fix: visibility wasn't entirely right, move dependant
 elements up the render chain

---
 src/WallpaperEngine/Render/Objects/CImage.cpp | 29 +++++-----
 .../Render/Wallpapers/CScene.cpp              | 54 ++++++++++++++++---
 .../Render/Wallpapers/CScene.h                |  1 +
 3 files changed, 59 insertions(+), 25 deletions(-)

diff --git a/src/WallpaperEngine/Render/Objects/CImage.cpp b/src/WallpaperEngine/Render/Objects/CImage.cpp
index 3c39e64..6b4cedd 100644
--- a/src/WallpaperEngine/Render/Objects/CImage.cpp
+++ b/src/WallpaperEngine/Render/Objects/CImage.cpp
@@ -234,11 +234,7 @@ void CImage::setup () {
         return;
     }
 
-    // TODO: SETUP RECALCULATION OF THINGS WHEN A VISIBILITY VALUE CHANGES!!
-    if (!this->m_image.visible->value->getBool ()) {
-        return;
-    }
-
+    // TODO: CHECK ORDER OF THINGS, 2419444134'S ID 27 DEPENDS ON 104'S COMPOSITE_A WHEN OUR LAST RENDER IS ON COMPOSITE_B
     // TODO: SUPPORT PASSTHROUGH (IT'S A SHADER)
     // passthrough images without effects are bad, do not draw them
     if (this->m_image.model->passthrough && this->m_image.effects.empty ()) {
@@ -317,19 +313,18 @@ void CImage::setup () {
                         new CPass (*this, fboProvider, config, std::nullopt, std::nullopt, (*curEffect)->target.value ())
                     );
                 } else {
-                    auto curPass = (*curEffect)->material.value ()->passes.begin ();
-                    auto endPass = (*curEffect)->material.value ()->passes.end ();
+                    for (auto& pass : (*curEffect)->material.value ()->passes) {
+                        const auto override =
+                            curOverride != endOverride
+                                ? **curOverride
+                                : std::optional<std::reference_wrapper<const ImageEffectPassOverride>> (std::nullopt);
+                        const auto target = (*curEffect)->target.has_value ()
+                                                ? *(*curEffect)->target
+                                                : std::optional<std::reference_wrapper<std::string>> (std::nullopt);
 
-                    const auto override =
-                        curOverride != endOverride
-                            ? **curOverride
-                            : std::optional<std::reference_wrapper<const ImageEffectPassOverride>> (std::nullopt);
-                    const auto target = (*curEffect)->target.has_value ()
-                                            ? *(*curEffect)->target
-                                            : std::optional<std::reference_wrapper<std::string>> (std::nullopt);
-
-                    this->m_passes.push_back (
-                        new CPass (*this, fboProvider, **curPass, override, (*curEffect)->binds, target));
+                        this->m_passes.push_back (
+                            new CPass (*this, fboProvider, *pass, override, (*curEffect)->binds, target));
+                    }
 
                     if (curOverride != endOverride) {
                         curOverride++;
diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
index 5541261..0e73350 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.cpp
@@ -64,14 +64,8 @@ CScene::CScene (
         this->createObject (*object);
 
     // copy over objects by render order
-    for (const auto& cur : scene->objects) {
-        auto obj = this->m_objects.find (cur->id);
-
-        // ignores not created objects like particle systems
-        if (obj == this->m_objects.end ())
-            continue;
-
-        this->m_objectsByRenderOrder.emplace_back (obj->second);
+    for (const auto& object : scene->objects) {
+        this->addObjectToRenderOrder (*object);
     }
 
     // create extra framebuffers for the bloom effect
@@ -203,6 +197,50 @@ Render::CObject* CScene::createObject (const Object& object) {
     return renderObject;
 }
 
+void CScene::addObjectToRenderOrder (const Object& object) {
+    auto obj = this->m_objects.find (object.id);
+
+    // ignores not created objects like particle systems
+    if (obj == this->m_objects.end ())
+        return;
+
+    // take into account any dependency first
+    for (const auto& dep : object.dependencies) {
+        // self-dependency is possible
+        if (dep == object.id) {
+            continue;
+        }
+
+        // add the dependency to the list if it's created
+        auto depIt = std::find_if (
+            this->getScene ().objects.begin (),
+            this->getScene ().objects.end (),
+            [&dep] (const auto& o) {
+                return o->id == dep;
+            }
+        );
+
+        if (depIt != this->getScene ().objects.end ()) {
+            this->addObjectToRenderOrder (**depIt);
+        } else {
+            sLog.error ("Cannot find dependency ", dep, " for object ", object.id);
+        }
+    }
+
+    // ensure we're added only once to the render list
+    const auto renderIt = std::find_if (
+        this->m_objectsByRenderOrder.begin (),
+        this->m_objectsByRenderOrder.end (),
+        [&object] (const auto& o) {
+            return o->getId () == object.id;
+        }
+    );
+
+    if (renderIt == this->m_objectsByRenderOrder.end ()) {
+        this->m_objectsByRenderOrder.emplace_back (obj->second);
+    }
+}
+
 CCamera& CScene::getCamera () const {
     return *this->m_camera;
 }
diff --git a/src/WallpaperEngine/Render/Wallpapers/CScene.h b/src/WallpaperEngine/Render/Wallpapers/CScene.h
index 5519bde..e52dfe7 100644
--- a/src/WallpaperEngine/Render/Wallpapers/CScene.h
+++ b/src/WallpaperEngine/Render/Wallpapers/CScene.h
@@ -40,6 +40,7 @@ class CScene final : public CWallpaper {
 
   private:
     Render::CObject* createObject (const Object& object);
+    void addObjectToRenderOrder (const Object& object);
 
     std::unique_ptr<CCamera> m_camera;
     ObjectUniquePtr m_bloomObjectData;

From fd0f142517c91a69aa3039af4f34c6a5c5795567 Mon Sep 17 00:00:00 2001
From: Almamu <wpengine@alma.mu>
Date: Sun, 31 Aug 2025 15:05:52 +0200
Subject: [PATCH 23/23] chore: detect non-string textures and fix null
 terminator on custom shaders

---
 src/WallpaperEngine/Assets/CVirtualContainer.cpp    | 4 ++--
 src/WallpaperEngine/Data/Parsers/MaterialParser.cpp | 7 ++++++-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/WallpaperEngine/Assets/CVirtualContainer.cpp b/src/WallpaperEngine/Assets/CVirtualContainer.cpp
index c68ce32..d244e95 100644
--- a/src/WallpaperEngine/Assets/CVirtualContainer.cpp
+++ b/src/WallpaperEngine/Assets/CVirtualContainer.cpp
@@ -10,10 +10,10 @@ void CVirtualContainer::add (const std::filesystem::path& filename, const std::s
 }
 
 void CVirtualContainer::add (const std::filesystem::path& filename, const std::string& contents) {
-    size_t length = contents.length () + 1;
+    // do not copy the null terminator
+    size_t length = contents.length ();
     std::shared_ptr<uint8_t[]> copy = std::shared_ptr<uint8_t[]> (new uint8_t [length]);
 
-    // copy the text AND the \0
     memcpy (copy.get(), contents.c_str (), length);
 
     // finally add to the container
diff --git a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
index ab9e5ea..9714c73 100644
--- a/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
+++ b/src/WallpaperEngine/Data/Parsers/MaterialParser.cpp
@@ -63,7 +63,12 @@ std::map <int, std::string> MaterialParser::parseTextures (const JSON& it) {
 
     for (const auto& cur : it) {
         if (!cur.is_null ()) {
-            result.emplace (index, cur);
+            if (!cur.is_string ()) {
+                sLog.error ("Detected a non-string texture, most likely a special value: ", cur.dump ());
+                result.emplace (index, "");
+            } else {
+                result.emplace (index, cur);
+            }
         }
 
         index++;