diff --git a/cmake/GenerateShaderResources.cmake b/cmake/GenerateShaderResources.cmake
new file mode 100644
index 000000000..74b90ccdc
--- /dev/null
+++ b/cmake/GenerateShaderResources.cmake
@@ -0,0 +1,20 @@
+macro(GENERATE_SHADER_RESOURCES _output_file)
+    string(REPLACE ";" "\\;" SHADER_FILES_ARG "${ARGN}")
+    add_custom_command(OUTPUT
+            "${_output_file}"
+
+            COMMAND ${CMAKE_COMMAND}
+
+            ARGS
+            -D "SHADER_FILES=${SHADER_FILES_ARG}"
+            -D "OUTPUT_FILE=${_output_file}"
+            -P "${PROJECTM_SOURCE_DIR}/cmake/GenerateShaderResourcesScript.cmake"
+
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            DEPENDS # Watch scripts and shader files for changes
+            ${PROJECTM_SOURCE_DIR}/cmake/ShaderResources.hpp.in
+            ${PROJECTM_SOURCE_DIR}/cmake/GenerateShaderResources.cmake
+            ${PROJECTM_SOURCE_DIR}/cmake/GenerateShaderResourcesScript.cmake
+            ${ARGN}
+            )
+endmacro()
diff --git a/src/libprojectM/Renderer/GenerateBuiltInTransitionsResources.cmake b/cmake/GenerateShaderResourcesScript.cmake
similarity index 62%
rename from src/libprojectM/Renderer/GenerateBuiltInTransitionsResources.cmake
rename to cmake/GenerateShaderResourcesScript.cmake
index 208a884d2..3bba3ea60 100644
--- a/src/libprojectM/Renderer/GenerateBuiltInTransitionsResources.cmake
+++ b/cmake/GenerateShaderResourcesScript.cmake
@@ -1,9 +1,14 @@
-cmake_minimum_required(VERSION 3.20 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.21 FATAL_ERROR)
 
 # Run as custom command in script mode if any shader file has changed.
 # Recreates the BuiltInTransitionsResources.hpp file accordingly.
 
 set(STATIC_SHADER_CONTENTS "")
+
+# Windows fix: the backslash is needed to escape the list in the script argument on UNIX shells,
+# but Windows keeps it and passes it on to CMake, breaking its use as a list separator.
+string(REPLACE "\\;" ";" SHADER_FILES "${SHADER_FILES}")
+
 foreach(shader_file IN LISTS SHADER_FILES)
     cmake_path(GET shader_file FILENAME _shader_name)
     cmake_path(GET shader_file EXTENSION _shader_type)
@@ -16,4 +21,4 @@ foreach(shader_file IN LISTS SHADER_FILES)
 
 endforeach()
 
-configure_file(BuiltInTransitionsResources.hpp.in ${OUTPUT_DIR}/BuiltInTransitionsResources.hpp @ONLY)
+configure_file(${CMAKE_CURRENT_LIST_DIR}/ShaderResources.hpp.in "${OUTPUT_FILE}" @ONLY)
diff --git a/src/libprojectM/Renderer/BuiltInTransitionsResources.hpp.in b/cmake/ShaderResources.hpp.in
similarity index 100%
rename from src/libprojectM/Renderer/BuiltInTransitionsResources.hpp.in
rename to cmake/ShaderResources.hpp.in
diff --git a/src/api/CMakeLists.txt b/src/api/CMakeLists.txt
index 656f1529c..1674d9aa6 100644
--- a/src/api/CMakeLists.txt
+++ b/src/api/CMakeLists.txt
@@ -5,10 +5,14 @@ target_sources(projectM_api
         "${PROJECTM_EXPORT_HEADER}"
         include/projectM-4/audio.h
         include/projectM-4/callbacks.h
+        include/projectM-4/core.h
         include/projectM-4/debug.h
         include/projectM-4/memory.h
         include/projectM-4/projectM.h
+        include/projectM-4/render_opengl.h
+        include/projectM-4/touch.h
         include/projectM-4/types.h
+        include/projectM-4/user_sprites.h
         )
 
 set_target_properties(projectM_api PROPERTIES
diff --git a/src/api/include/projectM-4/projectM.h b/src/api/include/projectM-4/projectM.h
index ba4f70a79..2e93d7b5c 100644
--- a/src/api/include/projectM-4/projectM.h
+++ b/src/api/include/projectM-4/projectM.h
@@ -34,3 +34,4 @@
 #include "projectM-4/render_opengl.h"
 #include "projectM-4/touch.h"
 #include "projectM-4/version.h"
+#include "projectM-4/user_sprites.h"
diff --git a/src/api/include/projectM-4/user_sprites.h b/src/api/include/projectM-4/user_sprites.h
new file mode 100644
index 000000000..e777f5916
--- /dev/null
+++ b/src/api/include/projectM-4/user_sprites.h
@@ -0,0 +1,128 @@
+/**
+ * @file user_sprites.h
+ * @copyright 2003-2024 projectM Team
+ * @brief Types and enumerations used in the other API headers.
+ * @since 4.2.0
+ *
+ * projectM -- Milkdrop-esque visualisation SDK
+ * Copyright (C)2003-2024 projectM Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ * See 'LICENSE.txt' included within this release
+ *
+ */
+
+#pragma once
+
+#include "projectM-4/types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Loads and displays a new sprite.
+ *
+ * Currently, these sprite types are supported:
+ * <ul>
+ * <li><tt>milkdrop</tt>: Original Milkdrop user sprite syntax. Pass the contents of an <tt>imgNN</tt> section in
+ * the <tt>code</tt> argument.</li>
+ * </ul>
+ *
+ * Unsupported types and loading errors will result in failure, and no sprite will be added or replaced.
+ *
+ * @important The same OpenGL context used to create the projectM instance @a must be active when calling this method!
+ * @param instance The projectM instance handle.
+ * @param type The case-insensitive type name of the sprite to be displayed. See description for supported values.
+ * @param code The type-specific sprite code, e.g. the contents of an <tt>imgNN</tt> section from a Milkdrop user
+ *             sprite INI file.
+ * @return A non-zero identifier if the sprite was successfully created, or zero if the type was
+ *         unrecognized or the code couldn't be parsed.
+ * @since 4.2.0
+ */
+PROJECTM_EXPORT uint32_t projectm_sprite_create(projectm_handle instance,
+                                                 const char* type,
+                                                 const char* code);
+
+/**
+ * @brief Destroys a single sprite.
+ *
+ * If there is no active sprite with the given ID, this method is a no-op.
+ *
+ * @param instance The projectM instance handle.
+ * @param sprite_id The ID of the sprite as returned by <tt>projectm_sprite_create()</tt>.
+ * @since 4.2.0
+ */
+PROJECTM_EXPORT void projectm_sprite_destroy(projectm_handle instance, uint32_t sprite_id);
+
+/**
+ * @brief Destroys all active sprites.
+ * @param instance The projectM instance handle.
+ * @since 4.2.0
+ */
+PROJECTM_EXPORT void projectm_sprite_destroy_all(projectm_handle instance);
+
+/**
+ * @brief Returns the number of currently active sprites.
+ *
+ * @note Sprites may destroy themselves after a frame has been rendered, and projectM can also
+ *       remove a sprite if a new one is added and the sprite limit was already reached.
+ *       Keep this in mind when calling <tt>projectm_sprite_get_sprite_ids()</tt> - ideally,
+ *       call <tt>projectm_sprite_get_sprite_count()</tt> @a immediately before allocating the
+ *       ID list.
+ * @param instance The projectM instance handle.
+ * @return The current number of sprites being rendered.
+ * @since 4.2.0
+ */
+PROJECTM_EXPORT uint32_t projectm_sprite_get_sprite_count(projectm_handle instance);
+
+/**
+ * @brief Returns the number of currently active sprites.
+ *
+ * Identifiers are ordered by sprite age, with the oldest sprite first and the newest last.
+ *
+ * @param instance The projectM instance handle.
+ * @param sprite_ids A pointer to an already-allocated list which will receive the sprite IDs.
+ *                   Call <tt>projectm_sprite_get_sprite_count()</tt> to get the required length
+ *                   or allocate a list with the current sprite limit as its size and init all entries
+ *                   to zero.
+ * @since 4.2.0
+ */
+PROJECTM_EXPORT void projectm_sprite_get_sprite_ids(projectm_handle instance, uint32_t* sprite_ids);
+
+/**
+ * @brief Sets the limit of concurrently displayed sprites.
+ *
+ * Once the limit is exceeded, the oldest sprite will be destroyed in order to display a new one.
+ *
+ * @param instance The projectM instance handle.
+ * @param max_sprites Maximum number of sprites to be displayed at once. Defaults to 16.
+ * @since 4.2.0
+ */
+PROJECTM_EXPORT void projectm_sprite_set_max_sprites(projectm_handle instance,
+                                                      uint32_t max_sprites);
+
+/**
+ * @brief Returns the currently set limit of concurrently displayed sprites.
+ *
+ * @param instance The projectM instance handle.
+ * @return The current maximum number of sprites to be displayed at once.
+ * @since 4.2.0
+ */
+PROJECTM_EXPORT uint32_t projectm_sprite_get_max_sprites(projectm_handle instance);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
diff --git a/src/libprojectM/CMakeLists.txt b/src/libprojectM/CMakeLists.txt
index 134850496..f05808f4a 100644
--- a/src/libprojectM/CMakeLists.txt
+++ b/src/libprojectM/CMakeLists.txt
@@ -9,6 +9,7 @@ add_compile_definitions(
 add_subdirectory(Audio)
 add_subdirectory(MilkdropPreset)
 add_subdirectory(Renderer)
+add_subdirectory(UserSprites)
 
 add_library(projectM_main OBJECT
         "${PROJECTM_EXPORT_HEADER}"
@@ -17,6 +18,8 @@ add_library(projectM_main OBJECT
         PresetFactory.hpp
         PresetFactoryManager.cpp
         PresetFactoryManager.hpp
+        PresetFileParser.cpp
+        PresetFileParser.hpp
         ProjectM.cpp
         ProjectM.hpp
         ProjectMCWrapper.cpp
@@ -63,6 +66,7 @@ add_library(projectM
         $<TARGET_OBJECTS:Audio>
         $<TARGET_OBJECTS:MilkdropPreset>
         $<TARGET_OBJECTS:Renderer>
+        $<TARGET_OBJECTS:UserSprites>
         $<TARGET_OBJECTS:hlslparser>
         $<TARGET_OBJECTS:SOIL2>
         $<TARGET_OBJECTS:projectM_main>
diff --git a/src/libprojectM/MilkdropPreset/BlurTexture.cpp b/src/libprojectM/MilkdropPreset/BlurTexture.cpp
index daa1033d2..6cc33660a 100644
--- a/src/libprojectM/MilkdropPreset/BlurTexture.cpp
+++ b/src/libprojectM/MilkdropPreset/BlurTexture.cpp
@@ -1,9 +1,12 @@
 #include "BlurTexture.hpp"
 
 #include "PerFrameContext.hpp"
+#include "PresetState.hpp"
 
 #include "MilkdropStaticShaders.hpp"
 
+#include "Renderer/ShaderCache.hpp"
+
 #include <array>
 
 namespace libprojectM {
@@ -12,14 +15,6 @@ namespace MilkdropPreset {
 BlurTexture::BlurTexture()
     : m_blurSampler(std::make_shared<Renderer::Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR))
 {
-    auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
-
-    // Compile shader sources
-    m_blur1Shader.CompileProgram(staticShaders->GetBlurVertexShader(),
-                                 staticShaders->GetBlur1FragmentShader());
-    m_blur2Shader.CompileProgram(staticShaders->GetBlurVertexShader(),
-                                 staticShaders->GetBlur2FragmentShader());
-
     m_blurFramebuffer.CreateColorAttachment(0, 0);
 
     // Initialize Blur VAO/VBO with a single fullscreen quad.
@@ -65,6 +60,33 @@ BlurTexture::~BlurTexture()
     glDeleteVertexArrays(1, &m_vaoBlur);
 }
 
+void BlurTexture::Initialize(const Renderer::RenderContext& renderContext)
+{
+    auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
+
+    // Load/compile shader sources
+    auto blur1Shader = renderContext.shaderCache->Get("milkdrop_blur1");
+    if (!blur1Shader)
+    {
+        blur1Shader = std::make_shared<Renderer::Shader>();
+        blur1Shader->CompileProgram(staticShaders->GetBlurVertexShader(),
+                                    staticShaders->GetBlur1FragmentShader());
+        renderContext.shaderCache->Insert("milkdrop_blur1", blur1Shader);
+    }
+
+    auto blur2Shader = renderContext.shaderCache->Get("milkdrop_blur2");
+    if (!blur2Shader)
+    {
+        blur2Shader = std::make_shared<Renderer::Shader>();
+        blur2Shader->CompileProgram(staticShaders->GetBlurVertexShader(),
+                                    staticShaders->GetBlur2FragmentShader());
+        renderContext.shaderCache->Insert("milkdrop_blur2", blur2Shader);
+    }
+
+    m_blur1Shader = blur1Shader;
+    m_blur2Shader = blur2Shader;
+}
+
 void BlurTexture::SetRequiredBlurLevel(BlurTexture::BlurLevel level)
 {
     m_blurLevel = std::max(level, m_blurLevel);
@@ -152,15 +174,20 @@ void BlurTexture::Update(const Renderer::Texture& sourceTexture, const PerFrameC
         }
 
         // set pixel shader
-        Renderer::Shader* blurShader;
+        std::shared_ptr<Renderer::Shader> blurShader;
         if ((pass % 2) == 0)
         {
-            blurShader = &m_blur1Shader;
+            blurShader = m_blur1Shader.lock();
         }
         else
         {
-            blurShader = &m_blur2Shader;
+            blurShader = m_blur2Shader.lock();
+        }
+        if (!blurShader)
+        {
+            return;
         }
+
         blurShader->Bind();
         blurShader->SetUniformInt("texture_sampler", 0);
 
@@ -205,10 +232,10 @@ void BlurTexture::Update(const Renderer::Texture& sourceTexture, const PerFrameC
             //float4 _c2; // d1..d4
             //float4 _c3; // scale, bias, w_div, 0
             //-------------------------------------
-            m_blur1Shader.SetUniformFloat4("_c0", {srcWidth, srcHeight, 1.0f / srcWidth, 1.0f / srcHeight});
-            m_blur1Shader.SetUniformFloat4("_c1", {w1, w2, w3, w4});
-            m_blur1Shader.SetUniformFloat4("_c2", {d1, d2, d3, d4});
-            m_blur1Shader.SetUniformFloat4("_c3", {scaleNow, biasNow, w_div, 0.0});
+            blurShader->SetUniformFloat4("_c0", {srcWidth, srcHeight, 1.0f / srcWidth, 1.0f / srcHeight});
+            blurShader->SetUniformFloat4("_c1", {w1, w2, w3, w4});
+            blurShader->SetUniformFloat4("_c2", {d1, d2, d3, d4});
+            blurShader->SetUniformFloat4("_c3", {scaleNow, biasNow, w_div, 0.0});
         }
         else
         {
@@ -224,19 +251,19 @@ void BlurTexture::Update(const Renderer::Texture& sourceTexture, const PerFrameC
             //float4 _c5; // w1,w2,d1,d2
             //float4 _c6; // w_div, edge_darken_c1, edge_darken_c2, edge_darken_c3
             //-------------------------------------
-            m_blur2Shader.SetUniformFloat4("_c0", {srcWidth, srcHeight, 1.0f / srcWidth, 1.0f / srcHeight});
-            m_blur2Shader.SetUniformFloat4("_c5", {w1, w2, d1, d2});
+            blurShader->SetUniformFloat4("_c0", {srcWidth, srcHeight, 1.0f / srcWidth, 1.0f / srcHeight});
+            blurShader->SetUniformFloat4("_c5", {w1, w2, d1, d2});
             // note: only do this first time; if you do it many times,
             // then the super-blurred levels will have big black lines along the top & left sides.
             if (pass == 1)
             {
                 // Darken edges
-                m_blur2Shader.SetUniformFloat4("_c6", {w_div, (1 - blur1EdgeDarken), blur1EdgeDarken, 5.0f});
+                blurShader->SetUniformFloat4("_c6", {w_div, (1 - blur1EdgeDarken), blur1EdgeDarken, 5.0f});
             }
             else
             {
                 // Don't darken
-                m_blur2Shader.SetUniformFloat4("_c6", {w_div, 1.0f, 0.0f, 5.0f});
+                blurShader->SetUniformFloat4("_c6", {w_div, 1.0f, 0.0f, 5.0f});
             }
         }
 
diff --git a/src/libprojectM/MilkdropPreset/BlurTexture.hpp b/src/libprojectM/MilkdropPreset/BlurTexture.hpp
index 2f6a7998e..edf63660e 100644
--- a/src/libprojectM/MilkdropPreset/BlurTexture.hpp
+++ b/src/libprojectM/MilkdropPreset/BlurTexture.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <Renderer/Framebuffer.hpp>
+#include <Renderer/RenderContext.hpp>
 #include <Renderer/Shader.hpp>
 #include <Renderer/TextureSamplerDescriptor.hpp>
 
@@ -49,6 +50,12 @@ class BlurTexture
      */
     ~BlurTexture();
 
+    /**
+     * @brief Initializes the blur texture.
+     * @param renderContext
+     */
+    void Initialize(const Renderer::RenderContext& renderContext);
+
     /**
      * @brief Sets the minimum required blur level.
      * If the current level isn't high enough, it'll be increased.
@@ -101,8 +108,8 @@ class BlurTexture
     GLuint m_vboBlur; //!< Vertex buffer object for the fullscreen blur quad.
     GLuint m_vaoBlur; //!< Vertex array object for the fullscreen blur quad.
 
-    Renderer::Shader m_blur1Shader; //!< The shader used on the first blur pass.
-    Renderer::Shader m_blur2Shader; //!< The shader used for subsequent blur passes after the initial pass.
+    std::weak_ptr<Renderer::Shader> m_blur1Shader; //!< The shader used on the first blur pass.
+    std::weak_ptr<Renderer::Shader> m_blur2Shader; //!< The shader used for subsequent blur passes after the initial pass.
 
     int m_sourceTextureWidth{};  //!< Width of the source texture used to create the blur textures.
     int m_sourceTextureHeight{}; //!< Height of the source texture used to create the blur textures.
diff --git a/src/libprojectM/MilkdropPreset/Border.cpp b/src/libprojectM/MilkdropPreset/Border.cpp
index 57b34c7cf..2cebe2a54 100644
--- a/src/libprojectM/MilkdropPreset/Border.cpp
+++ b/src/libprojectM/MilkdropPreset/Border.cpp
@@ -33,8 +33,9 @@ void Border::Draw(const PerFrameContext& presetPerFrameContext)
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    m_presetState.untexturedShader.Bind();
-    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+    auto shader = m_presetState.untexturedShader.lock();
+    shader->Bind();
+    shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
     std::array<Point, 4> vertices{};
     for (int border = 0; border < 2; border++)
diff --git a/src/libprojectM/MilkdropPreset/CMakeLists.txt b/src/libprojectM/MilkdropPreset/CMakeLists.txt
index 8dfb147ad..6f54abf4f 100644
--- a/src/libprojectM/MilkdropPreset/CMakeLists.txt
+++ b/src/libprojectM/MilkdropPreset/CMakeLists.txt
@@ -75,8 +75,6 @@ add_library(MilkdropPreset OBJECT
         PerPixelContext.hpp
         PerPixelMesh.cpp
         PerPixelMesh.hpp
-        PresetFileParser.cpp
-        PresetFileParser.hpp
         PresetState.cpp
         PresetState.hpp
         ShapePerFrameContext.cpp
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.cpp b/src/libprojectM/MilkdropPreset/CustomShape.cpp
index d88a1e946..9eaef3784 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.cpp
@@ -72,7 +72,7 @@ void CustomShape::InitVertexAttrib()
     glBufferData(GL_ARRAY_BUFFER, sizeof(Point) * vertexData.size(), vertexData.data(), GL_STREAM_DRAW);
 }
 
-void CustomShape::Initialize(PresetFileParser& parsedFile, int index)
+void CustomShape::Initialize(::libprojectM::PresetFileParser& parsedFile, int index)
 {
     std::string const shapecodePrefix = "shapecode_" + std::to_string(index) + "_";
 
@@ -192,9 +192,10 @@ void CustomShape::Draw()
 
         if (static_cast<int>(*m_perFrameContext.textured) != 0)
         {
-            m_presetState.texturedShader.Bind();
-            m_presetState.texturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
-            m_presetState.texturedShader.SetUniformInt("texture_sampler", 0);
+            auto shader = m_presetState.texturedShader.lock();
+            shader->Bind();
+            shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+            shader->SetUniformInt("texture_sampler", 0);
 
             // Textured shape, either main texture or texture from "image" key
             auto textureAspectY = m_presetState.renderContext.aspectY;
@@ -208,7 +209,7 @@ void CustomShape::Draw()
                 auto desc = m_presetState.renderContext.textureManager->GetTexture(m_image);
                 if (!desc.Empty())
                 {
-                    desc.Bind(0, m_presetState.texturedShader);
+                    desc.Bind(0, *shader);
                     textureAspectY = 1.0f;
                 }
                 else
@@ -251,8 +252,9 @@ void CustomShape::Draw()
 
             glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(TexturedPoint) * (sides + 2), vertexData.data());
 
-            m_presetState.untexturedShader.Bind();
-            m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+            auto shader = m_presetState.untexturedShader.lock();
+            shader->Bind();
+            shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
             glBindVertexArray(m_vaoIdUntextured);
             glDrawArrays(GL_TRIANGLE_FAN, 0, sides + 2);
@@ -269,8 +271,9 @@ void CustomShape::Draw()
                 points[i].y = vertexData[i + 1].y;
             }
 
-            m_presetState.untexturedShader.Bind();
-            m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+            auto shader = m_presetState.untexturedShader.lock();
+            shader->Bind();
+            shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
             glVertexAttrib4f(1,
                              static_cast<float>(*m_perFrameContext.border_r),
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.hpp b/src/libprojectM/MilkdropPreset/CustomShape.hpp
index 5ecb23eb0..ea59d34e4 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.hpp
@@ -33,7 +33,7 @@ class CustomShape : public Renderer::RenderItem
      * @param parsedFile The file parser with the preset data.
      * @param index The waveform index.
      */
-    void Initialize(PresetFileParser& parsedFile, int index);
+    void Initialize(::libprojectM::PresetFileParser& parsedFile, int index);
 
     /**
      * @brief Compiles all code blocks and runs the init expression.
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
index d9d0937f6..9f046d533 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
@@ -36,7 +36,7 @@ void CustomWaveform::InitVertexAttrib()
     glBufferData(GL_ARRAY_BUFFER, sizeof(ColoredPoint) * vertexData.size(), vertexData.data(), GL_STREAM_DRAW);
 }
 
-void CustomWaveform::Initialize(PresetFileParser& parsedFile, int index)
+void CustomWaveform::Initialize(::libprojectM::PresetFileParser& parsedFile, int index)
 {
     std::string const wavecodePrefix = "wavecode_" + std::to_string(index) + "_";
     std::string const wavePrefix = "wave_" + std::to_string(index) + "_";
@@ -182,8 +182,9 @@ void CustomWaveform::Draw(const PerFrameContext& presetPerFrameContext)
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     }
 
-    m_presetState.untexturedShader.Bind();
-    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+    auto shader = m_presetState.untexturedShader.lock();
+    shader->Bind();
+    shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
     auto iterations = (m_drawThick && !m_useDots) ? 4 : 1;
 
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
index 363c27345..31d2bfae0 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
@@ -8,10 +8,11 @@
 #include <vector>
 
 namespace libprojectM {
-namespace MilkdropPreset {
 
 class PresetFileParser;
 
+namespace MilkdropPreset {
+
 class CustomWaveform : public Renderer::RenderItem
 {
 public:
@@ -32,7 +33,7 @@ class CustomWaveform : public Renderer::RenderItem
      * @param parsedFile The file parser with the preset data.
      * @param index The waveform index.
      */
-    void Initialize(PresetFileParser& parsedFile, int index);
+    void Initialize(::libprojectM::PresetFileParser& parsedFile, int index);
 
     /**
      * @brief Compiles all code blocks and runs the init expression.
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
index 5e5efac74..64899b324 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
@@ -44,8 +44,9 @@ void DarkenCenter::Draw()
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    m_presetState.untexturedShader.Bind();
-    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+    auto shader = m_presetState.untexturedShader.lock();
+    shader->Bind();
+    shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
     glDrawArrays(GL_TRIANGLE_FAN, 0, 6);
 
diff --git a/src/libprojectM/MilkdropPreset/Filters.cpp b/src/libprojectM/MilkdropPreset/Filters.cpp
index 9c70904a1..472a0e70b 100644
--- a/src/libprojectM/MilkdropPreset/Filters.cpp
+++ b/src/libprojectM/MilkdropPreset/Filters.cpp
@@ -29,8 +29,9 @@ void Filters::Draw()
 
     glEnable(GL_BLEND);
 
-    m_presetState.untexturedShader.Bind();
-    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+    auto shader = m_presetState.untexturedShader.lock();
+    shader->Bind();
+    shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
     glBindVertexArray(m_vaoID);
     glVertexAttrib4f(1, 1.0, 1.0, 1.0, 1.0);
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
index d2c3e5473..110489a80 100755
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
@@ -59,6 +59,8 @@ void MilkdropPreset::Initialize(const Renderer::RenderContext& renderContext)
 {
     assert(renderContext.textureManager);
     m_state.renderContext = renderContext;
+    m_state.blurTexture.Initialize(renderContext);
+    m_state.LoadShaders();
 
     // Initialize variables and code now we have a proper render state.
     CompileCodeAndRunInitExpressions();
@@ -143,8 +145,6 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     }
     m_border.Draw(m_perFrameContext);
 
-    // Todo: Song title anim would go here
-
     // y-flip the image for final compositing again
     m_flipTexture.Draw(m_framebuffer.GetColorAttachmentTexture(m_currentFrameBuffer, 0), nullptr, true, false);
     m_state.mainTexture = m_flipTexture.Texture();
@@ -155,8 +155,6 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
 
     m_finalComposite.Draw(m_state, m_perFrameContext);
 
-    // ToDo: Draw user sprites (can have evaluated code)
-
     if (!m_finalComposite.HasCompositeShader())
     {
         // Flip texture again in "previous" framebuffer as old-school effects are still upside down.
@@ -183,6 +181,14 @@ void MilkdropPreset::DrawInitialImage(const std::shared_ptr<Renderer::Texture>&
     m_flipTexture.Draw(image, m_framebuffer, m_previousFrameBuffer);
 }
 
+void MilkdropPreset::BindFramebuffer()
+{
+    if (m_framebuffer.Width() > 0 && m_framebuffer.Height() > 0)
+    {
+        m_framebuffer.BindDraw(m_previousFrameBuffer);
+    }
+}
+
 void MilkdropPreset::PerFrameUpdate()
 {
     m_perFrameContext.LoadStateVariables(m_state);
@@ -205,7 +211,7 @@ void MilkdropPreset::Load(const std::string& pathname)
 
     SetFilename(ParseFilename(pathname));
 
-    PresetFileParser parser;
+    ::libprojectM::PresetFileParser parser;
 
     if (!parser.Read(pathname))
     {
@@ -224,7 +230,7 @@ void MilkdropPreset::Load(std::istream& stream)
     std::cerr << "[Preset] Loading preset from stream." << std::endl;
 #endif
 
-    PresetFileParser parser;
+    ::libprojectM::PresetFileParser parser;
 
     if (!parser.Read(stream))
     {
@@ -237,7 +243,7 @@ void MilkdropPreset::Load(std::istream& stream)
     InitializePreset(parser);
 }
 
-void MilkdropPreset::InitializePreset(PresetFileParser& parsedFile)
+void MilkdropPreset::InitializePreset(::libprojectM::PresetFileParser& parsedFile)
 {
     // Create the offscreen rendering surfaces.
     m_motionVectorUVMap = std::make_shared<Renderer::TextureAttachment>(GL_RG16F, GL_RG, GL_FLOAT, 0, 0);
@@ -314,5 +320,6 @@ auto MilkdropPreset::ParseFilename(const std::string& filename) -> std::string
     return filename.substr(start + 1, filename.length());
 }
 
+
 } // namespace MilkdropPreset
 } // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
index cd55339a9..06fa470bb 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
@@ -45,10 +45,11 @@
 #include <string>
 
 namespace libprojectM {
+class PresetFileParser;
+
 namespace MilkdropPreset {
 
 class Factory;
-class PresetFileParser;
 
 class MilkdropPreset : public ::libprojectM::Preset
 {
@@ -86,6 +87,8 @@ class MilkdropPreset : public ::libprojectM::Preset
 
     void DrawInitialImage(const std::shared_ptr<Renderer::Texture>& image, const Renderer::RenderContext& renderContext) override;
 
+    void BindFramebuffer() override;
+
 private:
     void PerFrameUpdate();
 
@@ -93,7 +96,7 @@ class MilkdropPreset : public ::libprojectM::Preset
 
     void Load(std::istream& stream);
 
-    void InitializePreset(PresetFileParser& parsedFile);
+    void InitializePreset(::libprojectM::PresetFileParser& parsedFile);
 
     void CompileCodeAndRunInitExpressions();
 
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.cpp b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
index cf165cbd9..3ec34e17e 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.cpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
@@ -2,6 +2,7 @@
 
 #include "MilkdropStaticShaders.hpp"
 
+#include <Renderer/ShaderCache.hpp>
 #include <Renderer/TextureManager.hpp>
 
 namespace libprojectM {
@@ -11,9 +12,6 @@ MotionVectors::MotionVectors(PresetState& presetState)
     : RenderItem()
     , m_presetState(presetState)
 {
-    auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
-    m_motionVectorShader.CompileProgram(staticShaders->GetPresetMotionVectorsVertexShader(),
-                                        staticShaders->GetUntexturedDrawFragmentShader());
     RenderItem::Init();
 }
 
@@ -89,12 +87,13 @@ void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shar
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
-    m_motionVectorShader.Bind();
-    m_motionVectorShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
-    m_motionVectorShader.SetUniformFloat("length_multiplier", static_cast<float>(*presetPerFrameContext.mv_l));
-    m_motionVectorShader.SetUniformFloat("minimum_length", minimumLength);
+    auto shader = GetShader();
+    shader->Bind();
+    shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+    shader->SetUniformFloat("length_multiplier", static_cast<float>(*presetPerFrameContext.mv_l));
+    shader->SetUniformFloat("minimum_length", minimumLength);
 
-    m_motionVectorShader.SetUniformInt("warp_coordinates", 0);
+    shader->SetUniformInt("warp_coordinates", 0);
 
     motionTexture->Bind(0, m_sampler);
 
@@ -162,5 +161,29 @@ void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shar
     glDisable(GL_BLEND);
 }
 
+std::shared_ptr<Renderer::Shader> MotionVectors::GetShader()
+{
+    auto shader = m_motionVectorShader.lock();
+    if (!shader)
+    {
+        shader = m_presetState.renderContext.shaderCache->Get("milkdrop_motion_vectors");
+    }
+    if (!shader)
+    {
+        // First use, compile and cache.
+        auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
+
+        shader = std::make_shared<Renderer::Shader>();
+        shader->CompileProgram(staticShaders->GetPresetMotionVectorsVertexShader(),
+                               staticShaders->GetUntexturedDrawFragmentShader());
+
+        m_presetState.renderContext.shaderCache->Insert("milkdrop_motion_vectors", shader);
+    }
+
+    m_motionVectorShader = shader;
+
+    return shader;
+}
+
 } // namespace MilkdropPreset
 } // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.hpp b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
index 6ceb940df..4782e03ad 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.hpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
@@ -36,16 +36,17 @@ class MotionVectors : public Renderer::RenderItem
     void Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<Renderer::Texture> motionTexture);
 
 private:
-    struct MotionVectorVertex
-    {
+    struct MotionVectorVertex {
         float x{};
         float y{};
         int32_t index{};
     };
 
+    std::shared_ptr<Renderer::Shader> GetShader();
+
     PresetState& m_presetState; //!< The global preset state.
 
-    Renderer::Shader m_motionVectorShader; //!< The motion vector shader, calculates the trace positions in the GPU.
+    std::weak_ptr<Renderer::Shader> m_motionVectorShader;                                                           //!< The motion vector shader, calculates the trace positions in the GPU.
     std::shared_ptr<Renderer::Sampler> m_sampler{std::make_shared<Renderer::Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR)}; //!< The texture sampler.
 
     int m_lastVertexCount{}; //!< Number of vertices drawn in the previous draw call.
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
index 8f0f49a2f..5ad57c28d 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
@@ -6,6 +6,8 @@
 #include "PerPixelContext.hpp"
 #include "PresetState.hpp"
 
+#include "Renderer/ShaderCache.hpp"
+
 #include <algorithm>
 #include <cmath>
 
@@ -22,10 +24,6 @@ PerPixelMesh::PerPixelMesh()
     : RenderItem()
 {
     RenderItem::Init();
-
-    auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
-    m_perPixelMeshShader.CompileProgram(staticShaders->GetPresetWarpVertexShader(),
-                                        staticShaders->GetPresetWarpFragmentShader());
 }
 
 void PerPixelMesh::InitVertexAttrib()
@@ -80,7 +78,7 @@ void PerPixelMesh::LoadWarpShader(const PresetState& presetState)
 #ifdef MILKDROP_PRESET_DEBUG
                 std::cerr << "[Warp Shader] Error loading warp shader code:" << ex.message() << std::endl;
 #else
-                (void)ex; // silence unused parameter warning
+                (void) ex; // silence unused parameter warning
 #endif
                 m_warpShader.reset();
             }
@@ -104,7 +102,7 @@ void PerPixelMesh::CompileWarpShader(PresetState& presetState)
 #ifdef MILKDROP_PRESET_DEBUG
             std::cerr << "[Warp Shader] Error compiling warp shader code:" << ex.message() << std::endl;
 #else
-            (void)ex; // silence unused parameter warning
+            (void) ex; // silence unused parameter warning
 #endif
             m_warpShader.reset();
         }
@@ -321,18 +319,19 @@ void PerPixelMesh::WarpedBlit(const PresetState& presetState,
 
     if (!m_warpShader)
     {
-        m_perPixelMeshShader.Bind();
-        m_perPixelMeshShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
-        m_perPixelMeshShader.SetUniformInt("texture_sampler", 0);
-        m_perPixelMeshShader.SetUniformFloat4("aspect", {presetState.renderContext.aspectX,
-                                                         presetState.renderContext.aspectY,
-                                                         presetState.renderContext.invAspectX,
-                                                         presetState.renderContext.invAspectY});
-        m_perPixelMeshShader.SetUniformFloat("warpTime", warpTime);
-        m_perPixelMeshShader.SetUniformFloat("warpScaleInverse", warpScaleInverse);
-        m_perPixelMeshShader.SetUniformFloat4("warpFactors", warpFactors);
-        m_perPixelMeshShader.SetUniformFloat2("texelOffset", texelOffsets);
-        m_perPixelMeshShader.SetUniformFloat("decay", decay);
+        auto perPixelMeshShader = GetDefaultWarpShader(presetState);
+        perPixelMeshShader->Bind();
+        perPixelMeshShader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+        perPixelMeshShader->SetUniformInt("texture_sampler", 0);
+        perPixelMeshShader->SetUniformFloat4("aspect", {presetState.renderContext.aspectX,
+                                                        presetState.renderContext.aspectY,
+                                                        presetState.renderContext.invAspectX,
+                                                        presetState.renderContext.invAspectY});
+        perPixelMeshShader->SetUniformFloat("warpTime", warpTime);
+        perPixelMeshShader->SetUniformFloat("warpScaleInverse", warpScaleInverse);
+        perPixelMeshShader->SetUniformFloat4("warpFactors", warpFactors);
+        perPixelMeshShader->SetUniformFloat2("texelOffset", texelOffsets);
+        perPixelMeshShader->SetUniformFloat("decay", decay);
     }
     else
     {
@@ -399,5 +398,31 @@ void PerPixelMesh::WarpedBlit(const PresetState& presetState,
     Renderer::Shader::Unbind();
 }
 
+auto PerPixelMesh::GetDefaultWarpShader(const PresetState& presetState) -> std::shared_ptr<Renderer::Shader>
+{
+    auto perPixelMeshShader = m_perPixelMeshShader.lock();
+    if (perPixelMeshShader)
+    {
+        return perPixelMeshShader;
+    }
+
+    perPixelMeshShader = presetState.renderContext.shaderCache->Get("milkdrop_default_warp_shader");
+    if (perPixelMeshShader)
+    {
+        return perPixelMeshShader;
+    }
+
+    auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
+
+    perPixelMeshShader = std::make_shared<Renderer::Shader>();
+    perPixelMeshShader->CompileProgram(staticShaders->GetPresetWarpVertexShader(),
+                                       staticShaders->GetPresetWarpFragmentShader());
+
+    presetState.renderContext.shaderCache->Insert("milkdrop_default_warp_shader", perPixelMeshShader);
+    m_perPixelMeshShader = perPixelMeshShader;
+
+    return perPixelMeshShader;
+}
+
 } // namespace MilkdropPreset
 } // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
index 6dcef4299..98576d30a 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
@@ -111,6 +111,13 @@ class PerPixelMesh : public Renderer::RenderItem
      */
     void WarpedBlit(const PresetState& presetState, const PerFrameContext& perFrameContext);
 
+    /**
+     * @brief Creates or retrieves the default warp shader.
+     * @param presetState The preset state to retrieve the rendering context from.
+     * @return A shared pointer to the default warp shader instance.
+     */
+    auto GetDefaultWarpShader(const PresetState& presetState) -> std::shared_ptr<Renderer::Shader>;
+
     int m_gridSizeX{}; //!< Warp mesh X resolution.
     int m_gridSizeY{}; //!< Warp mesh Y resolution.
 
@@ -122,8 +129,8 @@ class PerPixelMesh : public Renderer::RenderItem
     std::vector<int> m_listIndices; //!< List of vertex indices to render.
     VertexList m_drawVertices;      //!< Temp data buffer for the vertices to be drawn.
 
-    Renderer::Shader m_perPixelMeshShader;                            //!< Special shader which calculates the per-pixel UV coordinates.
-    std::unique_ptr<MilkdropShader> m_warpShader;           //!< The warp shader. Either preset-defined or a default shader.
+    std::weak_ptr<Renderer::Shader> m_perPixelMeshShader;             //!< Special shader which calculates the per-pixel UV coordinates.
+    std::unique_ptr<MilkdropShader> m_warpShader;                     //!< The warp shader. Either preset-defined or a default shader.
     Renderer::Sampler m_perPixelSampler{GL_CLAMP_TO_EDGE, GL_LINEAR}; //!< The main texture sampler.
 };
 
diff --git a/src/libprojectM/MilkdropPreset/PresetState.cpp b/src/libprojectM/MilkdropPreset/PresetState.cpp
index 7ff872a55..1838269cd 100644
--- a/src/libprojectM/MilkdropPreset/PresetState.cpp
+++ b/src/libprojectM/MilkdropPreset/PresetState.cpp
@@ -3,6 +3,8 @@
 #include "MilkdropStaticShaders.hpp"
 #include "PresetFileParser.hpp"
 
+#include "Renderer/ShaderCache.hpp"
+
 #include <glm/gtc/matrix_transform.hpp>
 
 #include <random>
@@ -16,12 +18,6 @@ const glm::mat4 PresetState::orthogonalProjectionFlipped = glm::ortho(-1.0f, 1.0
 PresetState::PresetState()
     : globalMemory(projectm_eval_memory_buffer_create())
 {
-    auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
-    untexturedShader.CompileProgram(staticShaders->GetUntexturedDrawVertexShader(),
-                                    staticShaders->GetUntexturedDrawFragmentShader());
-    texturedShader.CompileProgram(staticShaders->GetTexturedDrawVertexShader(),
-                                  staticShaders->GetTexturedDrawFragmentShader());
-
     std::random_device randomDevice;
     std::mt19937 randomGenerator(randomDevice());
     std::uniform_int_distribution<> distrib(0, std::numeric_limits<int>::max());
@@ -37,7 +33,7 @@ PresetState::~PresetState()
     projectm_eval_memory_buffer_destroy(globalMemory);
 }
 
-void PresetState::Initialize(PresetFileParser& parsedFile)
+void PresetState::Initialize(::libprojectM::PresetFileParser& parsedFile)
 {
 
     // General:
@@ -164,5 +160,30 @@ void PresetState::Initialize(PresetFileParser& parsedFile)
     compositeShader = parsedFile.GetCode("comp_");
 }
 
+void PresetState::LoadShaders()
+{
+    auto staticShaders = libprojectM::MilkdropPreset::MilkdropStaticShaders::Get();
+
+    auto untexturedShaderShared = renderContext.shaderCache->Get("milkdrop_generic_untextured");
+    if (!untexturedShaderShared)
+    {
+        untexturedShaderShared = std::make_shared<Renderer::Shader>();
+        untexturedShaderShared->CompileProgram(staticShaders->GetUntexturedDrawVertexShader(),
+                                        staticShaders->GetUntexturedDrawFragmentShader());
+        renderContext.shaderCache->Insert("milkdrop_generic_untextured", untexturedShaderShared);
+    }
+    untexturedShader = untexturedShaderShared;
+
+    auto texturedShaderShared = renderContext.shaderCache->Get("milkdrop_generic_textured");
+    if (!texturedShaderShared)
+    {
+        texturedShaderShared = std::make_shared<Renderer::Shader>();
+        texturedShaderShared->CompileProgram(staticShaders->GetTexturedDrawVertexShader(),
+                                      staticShaders->GetTexturedDrawFragmentShader());
+        renderContext.shaderCache->Insert("milkdrop_generic_textured", texturedShaderShared);
+    }
+    texturedShader = texturedShaderShared;
+}
+
 } // namespace MilkdropPreset
 } // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PresetState.hpp b/src/libprojectM/MilkdropPreset/PresetState.hpp
index 921b46d79..68fef489d 100644
--- a/src/libprojectM/MilkdropPreset/PresetState.hpp
+++ b/src/libprojectM/MilkdropPreset/PresetState.hpp
@@ -20,10 +20,12 @@
 #include <string>
 
 namespace libprojectM {
-namespace MilkdropPreset {
 
 class PresetFileParser;
 
+namespace MilkdropPreset {
+
+
 using BlendableFloat = float; //!< Currently a placeholder to mark blendable values.
 
 /**
@@ -43,7 +45,13 @@ class PresetState
      * @brief Loads the initial values and code from the preset file.
      * @param parsedFile The file parser with the preset data.
      */
-    void Initialize(PresetFileParser& parsedFile);
+    void Initialize(::libprojectM::PresetFileParser& parsedFile);
+
+    /**
+     * @brief Loads or compiles the generic shaders.
+     * Call after setting renderContext.
+     */
+    void LoadShaders();
 
     BlendableFloat gammaAdj{2.0f};
     BlendableFloat videoEchoZoom{2.0f};
@@ -147,8 +155,8 @@ class PresetState
     std::string warpShader;      //!< Warp shader code.
     std::string compositeShader; //!< Composite shader code.
 
-    Renderer::Shader untexturedShader; //!< Shader used to draw untextured primitives, e.g. waveforms.
-    Renderer::Shader texturedShader;   //!< Shader used to draw textured primitives, e.g. textured shapes and the warp mesh.
+    std::weak_ptr<Renderer::Shader> untexturedShader; //!< Shader used to draw untextured primitives, e.g. waveforms.
+    std::weak_ptr<Renderer::Shader> texturedShader;   //!< Shader used to draw textured primitives, e.g. textured shapes and the warp mesh.
 
     std::weak_ptr<Renderer::Texture> mainTexture; //!< A weak reference to the main texture in the preset framebuffer.
     BlurTexture blurTexture;                      //!< The blur textures used in this preset. Contents depend on the shader code using GetBlurX().
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.cpp b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
index bf7d4af97..9bf9ae4f2 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.cpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
@@ -68,9 +68,10 @@ void VideoEcho::Draw()
         m_vertices[i].a = 1.0f;
     }
 
-    m_presetState.texturedShader.Bind();
-    m_presetState.texturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
-    m_presetState.texturedShader.SetUniformInt("texture_sampler", 0);
+    auto shader = m_presetState.texturedShader.lock();
+    shader->Bind();
+    shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+    shader->SetUniformInt("texture_sampler", 0);
 
     auto mainTexture = m_presetState.mainTexture.lock();
     if (mainTexture)
diff --git a/src/libprojectM/MilkdropPreset/Waveform.cpp b/src/libprojectM/MilkdropPreset/Waveform.cpp
index 80e09e406..ce4351784 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.cpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.cpp
@@ -54,8 +54,9 @@ void Waveform::Draw(const PerFrameContext& presetPerFrameContext)
 #endif
     glLineWidth(1);
 
-    m_presetState.untexturedShader.Bind();
-    m_presetState.untexturedShader.SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
+    auto shader = m_presetState.untexturedShader.lock();
+    shader->Bind();
+    shader->SetUniformMat4x4("vertex_transformation", PresetState::orthogonalProjection);
 
     glBindVertexArray(m_vaoID);
     glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
diff --git a/src/libprojectM/Preset.hpp b/src/libprojectM/Preset.hpp
index ba06a14d9..c96b1bf7f 100644
--- a/src/libprojectM/Preset.hpp
+++ b/src/libprojectM/Preset.hpp
@@ -47,6 +47,19 @@ class Preset
     virtual void DrawInitialImage(const std::shared_ptr<Renderer::Texture>& image,
                                   const Renderer::RenderContext& renderContext) = 0;
 
+    /**
+     * @brief Bind the preset's internal framebuffer.
+     * This framebuffer contains the image passed on to the next frame, onto which warp effects etc.
+     * are then applied. Has no effect if the framebuffer isn't initialized yet, e.g. before drawing
+     * the first frame.
+     *
+     * Can be used to draw anything on top of the preset's image, "burning in" additional shapes,
+     * images or text. Depending on the preset, it's not guaranteed though that the image actually
+     * is used in the next frame, or completely painted over. That said, the effect varies between
+     * presets.
+     */
+    virtual void BindFramebuffer() = 0;
+
     inline void SetFilename(const std::string& filename)
     {
         m_filename = filename;
diff --git a/src/libprojectM/MilkdropPreset/PresetFileParser.cpp b/src/libprojectM/PresetFileParser.cpp
similarity index 78%
rename from src/libprojectM/MilkdropPreset/PresetFileParser.cpp
rename to src/libprojectM/PresetFileParser.cpp
index 5a88d9915..a48edea77 100644
--- a/src/libprojectM/MilkdropPreset/PresetFileParser.cpp
+++ b/src/libprojectM/PresetFileParser.cpp
@@ -2,12 +2,10 @@
 
 #include <algorithm>
 #include <fstream>
-#include <functional>
 #include <sstream>
 #include <vector>
 
 namespace libprojectM {
-namespace MilkdropPreset {
 
 auto PresetFileParser::Read(const std::string& presetFile) -> bool
 {
@@ -77,14 +75,16 @@ auto PresetFileParser::Read(std::istream& presetStream) -> bool
 
 auto PresetFileParser::GetCode(const std::string& keyPrefix) const -> std::string
 {
+    auto lowerKey = ToLower(keyPrefix);
+
     std::stringstream code;                        //!< The parsed code
-    std::string key(keyPrefix.length() + 5, '\0'); //!< Allocate a string that can hold up to 5 digits.
+    std::string key(lowerKey.length() + 5, '\0'); //!< Allocate a string that can hold up to 5 digits.
 
-    key.replace(0, keyPrefix.length(), keyPrefix);
+    key.replace(0, lowerKey.length(), lowerKey);
 
     for (int index{1}; index <= 99999; ++index)
     {
-        key.replace(keyPrefix.length(), 5, std::to_string(index));
+        key.replace(lowerKey.length(), 5, std::to_string(index));
         if (m_presetValues.find(key) == m_presetValues.end())
         {
             break;
@@ -107,11 +107,12 @@ auto PresetFileParser::GetCode(const std::string& keyPrefix) const -> std::strin
 
 auto PresetFileParser::GetInt(const std::string& key, int defaultValue) -> int
 {
-    if (m_presetValues.find(key) != m_presetValues.end())
+    auto lowerKey = ToLower(key);
+    if (m_presetValues.find(lowerKey) != m_presetValues.end())
     {
         try
         {
-            return std::stoi(m_presetValues.at(key));
+            return std::stoi(m_presetValues.at(lowerKey));
         }
         catch (std::logic_error&)
         {
@@ -123,11 +124,12 @@ auto PresetFileParser::GetInt(const std::string& key, int defaultValue) -> int
 
 auto PresetFileParser::GetFloat(const std::string& key, float defaultValue) -> float
 {
-    if (m_presetValues.find(key) != m_presetValues.end())
+    auto lowerKey = ToLower(key);
+    if (m_presetValues.find(lowerKey) != m_presetValues.end())
     {
         try
         {
-            return std::stof(m_presetValues.at(key));
+            return std::stof(m_presetValues.at(lowerKey));
         }
         catch (std::logic_error&)
         {
@@ -144,9 +146,10 @@ auto PresetFileParser::GetBool(const std::string& key, bool defaultValue) -> boo
 
 auto PresetFileParser::GetString(const std::string& key, const std::string& defaultValue) -> std::string
 {
-    if (m_presetValues.find(key) != m_presetValues.end())
+    auto lowerKey = ToLower(key);
+    if (m_presetValues.find(lowerKey) != m_presetValues.end())
     {
-        return m_presetValues.at(key);
+        return m_presetValues.at(lowerKey);
     }
 
     return defaultValue;
@@ -168,7 +171,8 @@ void PresetFileParser::ParseLine(const std::string& line)
         return;
     }
 
-    std::string varName(line.begin(), line.begin() + varNameDelimiterPos);
+    // Convert key to lower case, as INI functions are not case-sensitive.
+    std::string varName(ToLower(std::string(line.begin(), line.begin() + varNameDelimiterPos)));
     std::string value(line.begin() + varNameDelimiterPos + 1, line.end());
 
     // Only add first occurrence to mimic Milkdrop behaviour
@@ -178,5 +182,13 @@ void PresetFileParser::ParseLine(const std::string& line)
     }
 }
 
-} // namespace MilkdropPreset
+auto PresetFileParser::ToLower(std::string str) -> std::string
+{
+    std::transform(str.begin(), str.end(), str.begin(),
+                   [](unsigned char c){ return std::tolower(c); }
+    );
+
+    return str;
+}
+
 } // namespace libprojectM
diff --git a/src/libprojectM/MilkdropPreset/PresetFileParser.hpp b/src/libprojectM/PresetFileParser.hpp
similarity index 95%
rename from src/libprojectM/MilkdropPreset/PresetFileParser.hpp
rename to src/libprojectM/PresetFileParser.hpp
index cd2e00659..8f2a3afc7 100644
--- a/src/libprojectM/MilkdropPreset/PresetFileParser.hpp
+++ b/src/libprojectM/PresetFileParser.hpp
@@ -4,7 +4,6 @@
 #include <string>
 
 namespace libprojectM {
-namespace MilkdropPreset {
 
 /**
  * @brief Milkdrop preset file parser
@@ -118,8 +117,15 @@ class PresetFileParser
     void ParseLine(const std::string& line);
 
 private:
+    /**
+     * @brief Converts the string to lower-case.
+     * Only letters A-Z are converted to a-z by default.
+     * @param str The original string.
+     * @return The lower-case string.
+     */
+    static auto ToLower(std::string str) -> std::string;
+
     ValueMap m_presetValues; //!< Map with preset keys and their value.
 };
 
-} // namespace MilkdropPreset
 } // namespace libprojectM
diff --git a/src/libprojectM/ProjectM.cpp b/src/libprojectM/ProjectM.cpp
index 37e5f41a5..495c5d4b7 100644
--- a/src/libprojectM/ProjectM.cpp
+++ b/src/libprojectM/ProjectM.cpp
@@ -30,8 +30,11 @@
 #include <Renderer/CopyTexture.hpp>
 #include <Renderer/PresetTransition.hpp>
 #include <Renderer/TextureManager.hpp>
+#include <Renderer/ShaderCache.hpp>
 #include <Renderer/TransitionShaderManager.hpp>
 
+#include <UserSprites/SpriteManager.hpp>
+
 namespace libprojectM {
 
 ProjectM::ProjectM()
@@ -177,6 +180,9 @@ void ProjectM::RenderFrame(uint32_t targetFramebufferObject /*= 0*/)
         m_textureCopier->Draw(m_activePreset->OutputTexture(), false, false);
     }
 
+    // Draw user sprites
+    m_spriteManager->Draw(audioData, renderContext, targetFramebufferObject, { m_activePreset, m_transitioningPreset });
+
     m_frameCount++;
     m_previousFrameVolume = audioData.vol;
 }
@@ -194,11 +200,14 @@ void ProjectM::Initialize()
     /** Initialise per-pixel matrix calculations */
     /** We need to initialise this before the builtin param db otherwise bass/mid etc won't bind correctly */
     m_textureManager = std::make_unique<Renderer::TextureManager>(m_textureSearchPaths);
+    m_shaderCache = std::make_unique<Renderer::ShaderCache>();
 
     m_transitionShaderManager = std::make_unique<Renderer::TransitionShaderManager>();
 
     m_textureCopier = std::make_unique<Renderer::CopyTexture>();
 
+    m_spriteManager = std::make_unique<UserSprites::SpriteManager>();
+
     m_presetFactoryManager->initialize();
 
     /* Set the seed to the current time in seconds */
@@ -268,6 +277,41 @@ auto ProjectM::WindowHeight() -> int
     return m_windowHeight;
 }
 
+auto ProjectM::AddUserSprite(const std::string& type, const std::string& spriteData) -> uint32_t
+{
+    return m_spriteManager->Spawn(type, spriteData, GetRenderContext());
+}
+
+void ProjectM::DestroyUserSprite(uint32_t spriteIdentifier)
+{
+    m_spriteManager->Destroy(spriteIdentifier);
+}
+
+void ProjectM::DestroyAllUserSprites()
+{
+    m_spriteManager->DestroyAll();
+}
+
+auto ProjectM::UserSpriteCount() const -> uint32_t
+{
+    return m_spriteManager->ActiveSpriteCount();
+}
+
+void ProjectM::SetUserSpriteLimit(uint32_t maxSprites)
+{
+    m_spriteManager->SpriteSlots(maxSprites);
+}
+
+auto ProjectM::UserSpriteLimit() const -> uint32_t
+{
+    return m_spriteManager->SpriteSlots();
+}
+
+auto ProjectM::UserSpriteIdentifiers() const -> std::vector<uint32_t>
+{
+    return m_spriteManager->ActiveSpriteIdentifiers();
+}
+
 void ProjectM::SetPresetLocked(bool locked)
 {
     // ToDo: Add a preset switch timer separate from the display timer and reset to 0 when
@@ -452,6 +496,16 @@ auto ProjectM::GetRenderContext() -> Renderer::RenderContext
     ctx.perPixelMeshX = static_cast<int>(m_meshX);
     ctx.perPixelMeshY = static_cast<int>(m_meshY);
     ctx.textureManager = m_textureManager.get();
+    ctx.shaderCache = m_shaderCache.get();
+
+    if (m_transition)
+    {
+        ctx.blendProgress = m_transition->Progress(ctx.time);
+    }
+    else
+    {
+        ctx.blendProgress = 0.0;
+    }
 
     return ctx;
 }
diff --git a/src/libprojectM/ProjectM.hpp b/src/libprojectM/ProjectM.hpp
index d57b9bf47..a718d500a 100644
--- a/src/libprojectM/ProjectM.hpp
+++ b/src/libprojectM/ProjectM.hpp
@@ -27,6 +27,7 @@
 #include <Audio/PCM.hpp>
 
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -37,9 +38,14 @@ class CopyTexture;
 class PresetTransition;
 class Renderer;
 class TextureManager;
+class ShaderCache;
 class TransitionShaderManager;
 } // namespace Renderer
 
+namespace UserSprites {
+class SpriteManager;
+} // namespace UserSprites
+
 class Preset;
 class PresetFactoryManager;
 class TimeKeeper;
@@ -191,6 +197,51 @@ class PROJECTM_EXPORT ProjectM
 
     auto WindowHeight() -> int;
 
+    /**
+     * @brief Creates a new user sprite.
+     * @param type The type of the sprite to create.
+     * @param spriteData The type-dependent sprite data.
+     * @return A unique, non-zero sprite identifier if the sprite was created successfully,
+     *         or zero if any error occurred or the sprite limit was reached.
+     */
+    auto AddUserSprite(const std::string& type, const std::string& spriteData) -> uint32_t;
+
+    /**
+     * @brief Destroys a single sprite using its identifier.
+     * @param spriteIdentifier The identifier of the sprite to destroy.
+     */
+    void DestroyUserSprite(uint32_t spriteIdentifier);
+
+    /**
+     * @brief Destroys all active user sprites.
+     */
+    void DestroyAllUserSprites();
+
+    /**
+     * @brief Returns the current user sprite count.
+     * @return The number of currently active user sprites.
+     */
+    auto UserSpriteCount() const -> uint32_t;
+
+    /**
+     * @brief Sets a new limit for user sprites.
+     * Any sprites above the new limit will be removed in order, oldest first.
+     * @param maxSprites The new sprite limit. 0 disables sprites, 16 is the default.
+     */
+    void SetUserSpriteLimit(uint32_t maxSprites);
+
+    /**
+     * @brief Returns the current user sprite display limit.
+     * @return The current user sprite limit.
+     */
+    auto UserSpriteLimit() const -> uint32_t;
+
+    /**
+     * @brief Returns a list of identifiers for all active user sprites.
+     * @return A list of all active user sprite identifiers, ordered by age (oldest first).
+     */
+    auto UserSpriteIdentifiers() const -> std::vector<uint32_t>;
+
 private:
     void Initialize();
 
@@ -200,11 +251,11 @@ class PROJECTM_EXPORT ProjectM
 
     auto GetRenderContext() -> Renderer::RenderContext;
 
-    uint32_t m_meshX{32};              //!< Per-point mesh horizontal resolution.
-    uint32_t m_meshY{24};              //!< Per-point mesh vertical resolution.
-    uint32_t m_targetFps{35};          //!< Target frames per second.
-    uint32_t m_windowWidth{0};            //!< EvaluateFrameData window width. If 0, nothing is rendered.
-    uint32_t m_windowHeight{0};           //!< EvaluateFrameData window height. If 0, nothing is rendered.
+    uint32_t m_meshX{32};            //!< Per-point mesh horizontal resolution.
+    uint32_t m_meshY{24};            //!< Per-point mesh vertical resolution.
+    uint32_t m_targetFps{35};        //!< Target frames per second.
+    uint32_t m_windowWidth{0};       //!< EvaluateFrameData window width. If 0, nothing is rendered.
+    uint32_t m_windowHeight{0};      //!< EvaluateFrameData window height. If 0, nothing is rendered.
     double m_presetDuration{30.0};   //!< Preset duration in seconds.
     double m_softCutDuration{3.0};   //!< Soft cut transition time.
     double m_hardCutDuration{20.0};  //!< Time after which a hard cut can happen at the earliest.
@@ -227,12 +278,14 @@ class PROJECTM_EXPORT ProjectM
 
     Audio::PCM m_audioStorage;                                                    //!< Audio data buffer and analyzer instance.
     std::unique_ptr<Renderer::TextureManager> m_textureManager;                   //!< The texture manager.
+    std::unique_ptr<Renderer::ShaderCache> m_shaderCache;                         //!< The global shader cache.
     std::unique_ptr<Renderer::TransitionShaderManager> m_transitionShaderManager; //!< The transition shader manager.
     std::unique_ptr<Renderer::CopyTexture> m_textureCopier;                       //!< Class that copies textures 1:1 to another texture or framebuffer.
     std::unique_ptr<Preset> m_activePreset;                                       //!< Currently loaded preset.
     std::unique_ptr<Preset> m_transitioningPreset;                                //!< Destination preset when smooth preset switching.
     std::unique_ptr<Renderer::PresetTransition> m_transition;                     //!< Transition effect used for blending.
     std::unique_ptr<TimeKeeper> m_timeKeeper;                                     //!< Keeps the different timers used to render and switch presets.
+    std::unique_ptr<UserSprites::SpriteManager> m_spriteManager;                  //!< Manages all types of user sprites.
 };
 
 } // namespace libprojectM
diff --git a/src/libprojectM/ProjectMCWrapper.cpp b/src/libprojectM/ProjectMCWrapper.cpp
index 15b7745d3..5119314cf 100644
--- a/src/libprojectM/ProjectMCWrapper.cpp
+++ b/src/libprojectM/ProjectMCWrapper.cpp
@@ -5,9 +5,9 @@
 #include <Audio/AudioConstants.hpp>
 
 #include <cstring>
-#include <sstream>
-#include <projectM-4/render_opengl.h>
 #include <projectM-4/parameters.h>
+#include <projectM-4/render_opengl.h>
+#include <sstream>
 
 
 namespace libprojectM {
@@ -26,7 +26,7 @@ void projectMWrapper::PresetSwitchFailedEvent(const std::string& presetFilename,
     if (m_presetSwitchFailedEventCallback)
     {
         m_presetSwitchFailedEventCallback(presetFilename.c_str(),
-                                         failureMessage.c_str(), m_presetSwitchFailedEventUserData);
+                                          failureMessage.c_str(), m_presetSwitchFailedEventUserData);
     }
 }
 
@@ -395,4 +395,58 @@ auto projectm_pcm_add_uint8(projectm_handle instance, const uint8_t* samples, un
 auto projectm_write_debug_image_on_next_frame(projectm_handle, const char*) -> void
 {
     // UNIMPLEMENTED
+}
+
+uint32_t projectm_sprite_create(projectm_handle instance, const char* type, const char* code)
+{
+    auto* projectMInstance = handle_to_instance(instance);
+
+    return projectMInstance->AddUserSprite(type, code);
+}
+
+void projectm_sprite_destroy(projectm_handle instance, uint32_t sprite_id)
+{
+    auto* projectMInstance = handle_to_instance(instance);
+
+    projectMInstance->DestroyUserSprite(sprite_id);
+}
+
+void projectm_sprite_destroy_all(projectm_handle instance)
+{
+    auto* projectMInstance = handle_to_instance(instance);
+
+    projectMInstance->DestroyAllUserSprites();
+}
+
+uint32_t projectm_sprite_get_sprite_count(projectm_handle instance)
+{
+    auto* projectMInstance = handle_to_instance(instance);
+
+    return projectMInstance->UserSpriteCount();
+}
+
+void projectm_sprite_get_sprite_ids(projectm_handle instance, uint32_t* sprite_ids)
+{
+    auto* projectMInstance = handle_to_instance(instance);
+
+    auto spriteIdList = projectMInstance->UserSpriteIdentifiers();
+    for (const auto& spriteId : spriteIdList)
+    {
+        *sprite_ids = spriteId;
+        sprite_ids++;
+    }
+}
+
+void projectm_sprite_set_max_sprites(projectm_handle instance, uint32_t max_sprites)
+{
+    auto* projectMInstance = handle_to_instance(instance);
+
+    projectMInstance->SetUserSpriteLimit(max_sprites);
+}
+
+uint32_t projectm_sprite_get_max_sprites(projectm_handle instance)
+{
+    auto* projectMInstance = handle_to_instance(instance);
+
+    return projectMInstance->UserSpriteLimit();
 }
\ No newline at end of file
diff --git a/src/libprojectM/Renderer/CMakeLists.txt b/src/libprojectM/Renderer/CMakeLists.txt
index 672c02660..b98c04968 100644
--- a/src/libprojectM/Renderer/CMakeLists.txt
+++ b/src/libprojectM/Renderer/CMakeLists.txt
@@ -10,27 +10,13 @@ set(TRANSITION_SHADER_FILES
         TransitionShaders/TransitionShaderMainGlsl330.frag
         )
 
-string(REPLACE ";" "\\;" TRANSITION_SHADER_FILES_ARG "${TRANSITION_SHADER_FILES}")
-add_custom_command(OUTPUT
-        ${CMAKE_CURRENT_BINARY_DIR}/BuiltInTransitionsResources.hpp
-
-        COMMAND ${CMAKE_COMMAND}
-
-        ARGS
-        -D SHADER_FILES="${TRANSITION_SHADER_FILES_ARG}"
-        -D OUTPUT_DIR=${CMAKE_CURRENT_BINARY_DIR}
-        -P ${CMAKE_CURRENT_SOURCE_DIR}/GenerateBuiltInTransitionsResources.cmake
-
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        DEPENDS # Files watched for changes:
+include(GenerateShaderResources)
+generate_shader_resources(${CMAKE_CURRENT_BINARY_DIR}/BuiltInTransitionsResources.hpp
         ${TRANSITION_SHADER_FILES}
-        BuiltInTransitionsResources.hpp.in
-        GenerateBuiltInTransitionsResources.cmake
         )
 
 add_library(Renderer OBJECT
         ${CMAKE_CURRENT_BINARY_DIR}/BuiltInTransitionsResources.hpp
-        BuiltInTransitionsResources.hpp.in
         CopyTexture.cpp
         CopyTexture.hpp
         FileScanner.cpp
@@ -49,6 +35,8 @@ add_library(Renderer OBJECT
         Sampler.hpp
         Shader.cpp
         Shader.hpp
+        ShaderCache.cpp
+        ShaderCache.hpp
         Texture.cpp
         Texture.hpp
         TextureAttachment.cpp
diff --git a/src/libprojectM/Renderer/PresetTransition.cpp b/src/libprojectM/Renderer/PresetTransition.cpp
index 023638541..b486f329e 100644
--- a/src/libprojectM/Renderer/PresetTransition.cpp
+++ b/src/libprojectM/Renderer/PresetTransition.cpp
@@ -2,6 +2,7 @@
 
 #include "TextureManager.hpp"
 
+#include <algorithm>
 #include <array>
 #include <cmath>
 #include <cstddef>
@@ -40,6 +41,11 @@ auto PresetTransition::IsDone(double currentFrameTime) const -> bool
     return m_durationSeconds <= 0.0 || secondsSinceStart >= m_durationSeconds;
 }
 
+auto PresetTransition::Progress(double currentFrameTime) const -> double
+{
+    return std::min(std::max((currentFrameTime - m_transitionStartTime) / m_durationSeconds, 0.0), 1.0);
+}
+
 void PresetTransition::Draw(const Preset& oldPreset,
                             const Preset& newPreset,
                             const RenderContext& context,
diff --git a/src/libprojectM/Renderer/PresetTransition.hpp b/src/libprojectM/Renderer/PresetTransition.hpp
index f88780756..cdd6ac1e6 100644
--- a/src/libprojectM/Renderer/PresetTransition.hpp
+++ b/src/libprojectM/Renderer/PresetTransition.hpp
@@ -40,6 +40,13 @@ class PresetTransition : public RenderItem
      */
     auto IsDone(double currentFrameTime) const -> bool;
 
+    /**
+     * @brief Returns the current linear blending progress according to the given frame time.
+     * @param currentFrameTime The time in seconds since start of the current frame.
+     * @return The linear blending progress from 0.0 to 1.0.
+     */
+    auto Progress(double currentFrameTime) const -> double;
+
     /**
      * @brief Updates the transition variables and renders the shader quad to the current FBO.
      * @param oldPreset A reference to the old (fading out) preset.
diff --git a/src/libprojectM/Renderer/RenderContext.hpp b/src/libprojectM/Renderer/RenderContext.hpp
index a5a1f9c6e..895a36b85 100644
--- a/src/libprojectM/Renderer/RenderContext.hpp
+++ b/src/libprojectM/Renderer/RenderContext.hpp
@@ -7,6 +7,7 @@
 namespace libprojectM {
 namespace Renderer {
 
+class ShaderCache;
 class TextureManager;
 
 /**
@@ -15,21 +16,23 @@ class TextureManager;
 class RenderContext
 {
 public:
-    float time{0.0f};      //!< Time since the preset started, in seconds.
-    int frame{0};          //!< Frames rendered so far.
-    float fps{0.0f};       //!< Frames per second.
-    float progress{0.0f};  //!< Preset progress.
-    int viewportSizeX{0};  //!< Horizontal viewport size in pixels
-    int viewportSizeY{0};  //!< Vertical viewport size in pixels
-    float aspectX{1.0};    //!< X aspect ratio.
-    float aspectY{1.0};    //!< Y aspect ratio.
-    float invAspectX{1.0}; //!< Inverse X aspect ratio.
-    float invAspectY{1.0}; //!< Inverse Y aspect ratio.
+    float time{0.0f};          //!< Time since the preset started, in seconds.
+    int frame{0};              //!< Frames rendered so far.
+    float fps{0.0f};           //!< Frames per second.
+    float progress{0.0f};      //!< Preset progress.
+    float blendProgress{0.0f}; //!< Preset transition/blending progress.
+    int viewportSizeX{0};      //!< Horizontal viewport size in pixels
+    int viewportSizeY{0};      //!< Vertical viewport size in pixels
+    float aspectX{1.0};        //!< X aspect ratio.
+    float aspectY{1.0};        //!< Y aspect ratio.
+    float invAspectX{1.0};     //!< Inverse X aspect ratio.
+    float invAspectY{1.0};     //!< Inverse Y aspect ratio.
 
     int perPixelMeshX{64}; //!< Per-pixel/per-vertex mesh X resolution.
     int perPixelMeshY{48}; //!< Per-pixel/per-vertex mesh Y resolution.
 
     TextureManager* textureManager{nullptr}; //!< Holds all loaded textures for shader access.
+    ShaderCache* shaderCache{nullptr}; //!< The shader chace of this projectM instance.
 };
 
 } // namespace Renderer
diff --git a/src/libprojectM/Renderer/ShaderCache.cpp b/src/libprojectM/Renderer/ShaderCache.cpp
new file mode 100644
index 000000000..16b1851eb
--- /dev/null
+++ b/src/libprojectM/Renderer/ShaderCache.cpp
@@ -0,0 +1,34 @@
+#include "ShaderCache.hpp"
+
+#include <utility>
+
+namespace libprojectM {
+namespace Renderer {
+
+void ShaderCache::Insert(const std::string& key, const std::shared_ptr<Shader>& shader)
+{
+    m_cachedShaders.emplace(key, shader);
+}
+
+void ShaderCache::Insert(const std::string& key, std::shared_ptr<Shader>&& shader)
+{
+    m_cachedShaders.emplace(key, std::move(shader));
+}
+
+void ShaderCache::Remove(const std::string& key)
+{
+    m_cachedShaders.erase(key);
+}
+
+auto ShaderCache::Get(const std::string& key) const -> std::shared_ptr<Shader>
+{
+    if (m_cachedShaders.find(key) != m_cachedShaders.end())
+    {
+        return m_cachedShaders.at(key);
+    }
+
+    return {};
+}
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/ShaderCache.hpp b/src/libprojectM/Renderer/ShaderCache.hpp
new file mode 100644
index 000000000..ca056672f
--- /dev/null
+++ b/src/libprojectM/Renderer/ShaderCache.hpp
@@ -0,0 +1,62 @@
+#pragma once
+
+#include "Renderer/Shader.hpp"
+
+#include <map>
+#include <memory>
+#include <string>
+
+namespace libprojectM {
+namespace Renderer {
+
+/**
+ * @brief Instance shader cache.
+ *
+ * Used to store shaders which only need to be compiled once per projectM instance.
+ * Removes the need for the previously used static shader provider, and reduces
+ * shader recompilation times.
+ *
+ * Shaders are accessed by arbitrary strings as keys.
+ *
+ * All cached shader programs will be properly deleted when the projectM instance is destroyed.
+ * Classes storing a reference to a cached shader should ideally use an std::weak_ptr to do so.
+ */
+class ShaderCache
+{
+public:
+    /**
+     * @brief Adds a new shader to the cache.
+     * If the shader already exists, the existing cache entry it NOT replaced.
+     * @param key The key to store the shader with.
+     * @param shader A shared pointer to the shader program to be cached.
+     */
+    void Insert(const std::string& key, const std::shared_ptr<Shader>& shader);
+
+    /**
+     * @brief Adds a new shader to the cache.
+     * If the shader already exists, the existing cache entry it NOT replaced.
+     * @param key The key to store the shader with.
+     * @param shader A shared pointer to the shader program to be cached.
+     */
+    void Insert(const std::string& key, std::shared_ptr<Shader>&& shader);
+
+    /**
+     * @brief Removes a shader from the cache.
+     * If the key does not exist in the cache, this function will not do anything.
+     * @param key The key of the sahder to be removed.
+     */
+    void Remove(const std::string& key);
+
+    /**
+     * @brief Returns a cached shader.
+     * @param key the key of the cached shader to be returned.
+     * @return A shared pointer to the cached shader program, or nullptr if the key wasn't found.
+     */
+    auto Get(const std::string& key) const -> std::shared_ptr<Shader>;
+
+private:
+    std::map<std::string, std::shared_ptr<Shader>> m_cachedShaders;
+};
+
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/CMakeLists.txt b/src/libprojectM/UserSprites/CMakeLists.txt
new file mode 100644
index 000000000..cdd4e0894
--- /dev/null
+++ b/src/libprojectM/UserSprites/CMakeLists.txt
@@ -0,0 +1,38 @@
+set(SPRITE_SHADER_FILES
+        Shaders/MilkdropSpriteFragmentGlsl330.frag
+        Shaders/MilkdropSpriteVertexGlsl330.vert
+        )
+
+include(GenerateShaderResources)
+generate_shader_resources(${CMAKE_CURRENT_BINARY_DIR}/SpriteShaders.hpp
+        ${SPRITE_SHADER_FILES}
+        )
+
+add_library(UserSprites OBJECT
+        ${CMAKE_CURRENT_BINARY_DIR}/SpriteShaders.hpp
+        Factory.cpp
+        Factory.hpp
+        MilkdropSprite.cpp
+        MilkdropSprite.hpp
+        Sprite.hpp
+        SpriteException.hpp
+        SpriteManager.cpp
+        SpriteManager.hpp
+        )
+
+target_include_directories(UserSprites
+        PRIVATE
+        "${CMAKE_CURRENT_SOURCE_DIR}/.."
+        PUBLIC
+        "${CMAKE_CURRENT_SOURCE_DIR}"
+        "${CMAKE_CURRENT_BINARY_DIR}"
+        )
+
+target_link_libraries(UserSprites
+        PRIVATE
+        projectM::Eval
+        libprojectM::API # For export header
+        PUBLIC
+        GLM::GLM
+        ${PROJECTM_OPENGL_LIBRARIES}
+        )
diff --git a/src/libprojectM/UserSprites/Factory.cpp b/src/libprojectM/UserSprites/Factory.cpp
new file mode 100644
index 000000000..fde94a2bf
--- /dev/null
+++ b/src/libprojectM/UserSprites/Factory.cpp
@@ -0,0 +1,24 @@
+#include "UserSprites/Factory.hpp"
+
+#include "UserSprites/MilkdropSprite.hpp"
+
+#include <Utils.hpp>
+
+namespace libprojectM {
+namespace UserSprites {
+
+auto Factory::CreateSprite(const std::string& type) -> Sprite::Ptr
+{
+    const auto lowerCaseType = Utils::ToLower(type);
+
+    if (lowerCaseType == "milkdrop")
+    {
+        return std::make_unique<MilkdropSprite>();
+    }
+
+    return {};
+}
+
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/Factory.hpp b/src/libprojectM/UserSprites/Factory.hpp
new file mode 100644
index 000000000..276a584db
--- /dev/null
+++ b/src/libprojectM/UserSprites/Factory.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "UserSprites/Sprite.hpp"
+
+#include <memory>
+#include <string>
+
+namespace libprojectM {
+namespace UserSprites {
+
+class Factory
+{
+public:
+    Factory() = delete;
+
+    static auto CreateSprite(const std::string& type) -> Sprite::Ptr;
+};
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.cpp b/src/libprojectM/UserSprites/MilkdropSprite.cpp
new file mode 100644
index 000000000..4fbfbf239
--- /dev/null
+++ b/src/libprojectM/UserSprites/MilkdropSprite.cpp
@@ -0,0 +1,430 @@
+#include "UserSprites/MilkdropSprite.hpp"
+
+#include "SpriteShaders.hpp"
+
+#include <Preset.hpp>
+#include <PresetFileParser.hpp>
+
+#include <Renderer/ShaderCache.hpp>
+#include <Renderer/TextureManager.hpp>
+
+#include <Utils.hpp>
+
+#include <cassert>
+#include <cmath>
+#include <cstdlib>
+#include <locale>
+#include <sstream>
+#include <string>
+
+#define REG_VAR(var) \
+    var = projectm_eval_context_register_variable(spriteCodeContext, #var);
+
+namespace libprojectM {
+namespace UserSprites {
+
+MilkdropSprite::MilkdropSprite()
+{
+    RenderItem::Init();
+}
+
+void MilkdropSprite::InitVertexAttrib()
+{
+    glEnableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, x))); // Position
+    // Color (index 1) is passed as a 4-float constant vertex attribute.
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, u))); // Texture coordinate
+}
+
+void MilkdropSprite::Init(const std::string& spriteData, const Renderer::RenderContext& renderContext)
+{
+    PresetFileParser parser;
+    std::stringstream spriteDataStream(spriteData);
+    if (!parser.Read(spriteDataStream))
+    {
+        throw SpriteException("Error reading sprite data.");
+    }
+
+    // Load/compile shader
+    auto spriteShader = renderContext.shaderCache->Get("milkdrop_user_sprite");
+    if (!spriteShader)
+    {
+        // ToDo: Better handle this in the shader class to reduce duplicate code.
+#ifdef USE_GLES
+        // GLES also requires a precision specifier for variables and 3D samplers
+        constexpr char versionHeader[] = "#version 300 es\n\nprecision mediump float;\nprecision mediump sampler3D;\n";
+#else
+        constexpr char versionHeader[] = "#version 330\n\n";
+#endif
+
+        spriteShader = std::make_shared<Renderer::Shader>();
+        spriteShader->CompileProgram(static_cast<const char*>(versionHeader) + kMilkdropSpriteVertexGlsl330,
+                                     static_cast<const char*>(versionHeader) + kMilkdropSpriteFragmentGlsl330);
+        renderContext.shaderCache->Insert("milkdrop_user_sprite", spriteShader);
+    }
+
+    m_spriteShader = spriteShader;
+
+    // We ignore the color key value here because OpenGL doesn't support those (DirectX has a specific texture
+    // render state for this, which replaces the given color value with transparent texels).
+    // Since sprites are user-supplied, we can just make blend mode 4 based on the texture's alpha channel,
+    // which gives way better results and users can easily convert any image to PNG.
+
+    // Load and compile code
+    auto initCode = parser.GetCode("init_");
+    m_codeContext.RunInitCode(initCode, renderContext);
+
+    auto perFrameCode = parser.GetCode("code_");
+    if (!perFrameCode.empty())
+    {
+        m_codeContext.perFrameCodeHandle = projectm_eval_code_compile(m_codeContext.spriteCodeContext, perFrameCode.c_str());
+        if (!m_codeContext.perFrameCodeHandle)
+        {
+            int errorLine{};
+            int errorColumn{};
+            auto* errorMessage = projectm_eval_get_error(m_codeContext.spriteCodeContext, &errorLine, &errorColumn);
+
+            throw SpriteException("Error compiling sprite per-frame code:" + std::string(errorMessage) + " (Line " + std::to_string(errorLine) + ", column " + std::to_string(errorColumn) + ")");
+        }
+    }
+
+    auto imageName = Utils::ToLower(parser.GetString("img", ""));
+
+    // Store texture as a shared_ptr to make sure TextureManager doesn't delete it.
+    std::locale const loc;
+    if (imageName.length() >= 6 &&
+        imageName.substr(0, 4) == "rand" && std::isdigit(imageName.at(4), loc) && std::isdigit(imageName.at(5), loc))
+    {
+        m_texture = renderContext.textureManager->GetRandomTexture(imageName).Texture();
+    }
+    else
+    {
+        m_texture = renderContext.textureManager->GetTexture(imageName).Texture();
+    }
+}
+
+void MilkdropSprite::Draw(const Audio::FrameAudioData& audioData,
+                          const Renderer::RenderContext& renderContext,
+                          uint32_t outputFramebufferObject,
+                          PresetList presets)
+{
+    auto spriteShader = m_spriteShader.lock();
+    assert(spriteShader.get());
+
+    m_codeContext.RunPerFrameCode(audioData, renderContext);
+
+    m_spriteDone = *m_codeContext.done != 0.0;
+    bool burnIn = *m_codeContext.burn != 0.0;
+
+    Quad vertices{};
+
+    // Get values from expression code and clamp them where necessary.
+    float x = std::min(1000.0f, std::max(-1000.0f, static_cast<float>(*m_codeContext.x) * 2.0f - 1.0f));
+    float y = std::min(1000.0f, std::max(-1000.0f, static_cast<float>(*m_codeContext.y) * 2.0f - 1.0f));
+    float sx = std::min(1000.0f, std::max(-1000.0f, static_cast<float>(*m_codeContext.sx)));
+    float sy = std::min(1000.0f, std::max(-1000.0f, static_cast<float>(*m_codeContext.sy)));
+    float rot = static_cast<float>(*m_codeContext.rot);
+    int flipx = (*m_codeContext.flipx == 0.0) ? 0 : 1; // Comparing float to 0.0 isn't actually a good idea...
+    int flipy = (*m_codeContext.flipy == 0.0) ? 0 : 1;
+    float repeatx = std::min(100.0f, std::max(0.01f, static_cast<float>(*m_codeContext.repeatx)));
+    float repeaty = std::min(100.0f, std::max(0.01f, static_cast<float>(*m_codeContext.repeaty)));
+
+    int blendMode = std::min(4, std::max(0, (static_cast<int>(*m_codeContext.blendmode))));
+    float r = std::min(1.0f, std::max(0.0f, (static_cast<float>(*m_codeContext.r))));
+    float g = std::min(1.0f, std::max(0.0f, (static_cast<float>(*m_codeContext.g))));
+    float b = std::min(1.0f, std::max(0.0f, (static_cast<float>(*m_codeContext.b))));
+    float a = std::min(1.0f, std::max(0.0f, (static_cast<float>(*m_codeContext.a))));
+
+    // ToDo: Move all translations to vertex shader
+    vertices[0 + flipx].x = -sx;
+    vertices[1 - flipx].x = sx;
+    vertices[2 + flipx].x = -sx;
+    vertices[3 - flipx].x = sx;
+    vertices[0 + flipy * 2].y = -sy;
+    vertices[1 + flipy * 2].y = -sy;
+    vertices[2 - flipy * 2].y = sy;
+    vertices[3 - flipy * 2].y = sy;
+
+    // First aspect ratio: adjust for non-1:1 images
+    {
+        auto aspect = m_texture->Height() / static_cast<float>(m_texture->Width());
+
+        if (aspect < 1.0f)
+        {
+            // Landscape image
+            for (auto& vertex : vertices)
+            {
+                vertex.y *= aspect;
+            }
+        }
+        else
+        {
+            // Portrait image
+            for (auto& vertex : vertices)
+            {
+                vertex.x /= aspect;
+            }
+        }
+    }
+
+    // 2D rotation
+    {
+        auto cos_rot = std::cos(rot);
+        auto sin_rot = std::sin(rot);
+
+        for (auto& vertex : vertices)
+        {
+            float rotX = vertex.x * cos_rot - vertex.y * sin_rot;
+            float rotY = vertex.x * sin_rot + vertex.y * cos_rot;
+            vertex.x = rotX;
+            vertex.y = rotY;
+        }
+    }
+
+    // Translation
+    for (auto& vertex : vertices)
+    {
+        vertex.x += x;
+        vertex.y += y;
+    }
+
+    // Second aspect ratio: normalize to width of screen
+    {
+        float aspect = renderContext.viewportSizeX / static_cast<float>(renderContext.viewportSizeY);
+
+        if (aspect > 1.0)
+        {
+            for (auto& vertex : vertices)
+            {
+                vertex.y *= aspect;
+            }
+        }
+        else
+        {
+            for (auto& vertex : vertices)
+            {
+                vertex.x /= aspect;
+            }
+        }
+    }
+
+    // Third aspect ratio: adjust for burn-in
+    // -> Not required in projectM, as we always render at viewport size, not a fixed 4:3 ratio
+
+    // Set u,v coords
+    {
+        float dtu = 0.5f;
+        float dtv = 0.5f;
+
+        vertices[0].u = -dtu;
+        vertices[1].u = dtu;
+        vertices[2].u = -dtu;
+        vertices[3].u = dtu;
+        vertices[0].v = -dtv;
+        vertices[1].v = -dtv;
+        vertices[2].v = dtv;
+        vertices[3].v = dtv;
+
+        for (auto& vertex : vertices)
+        {
+            vertex.u = (vertex.u - 0.0f) * repeatx + 0.5f;
+            vertex.v = (vertex.v - 0.0f) * repeaty + 0.5f;
+        }
+    }
+
+    spriteShader->Bind();
+
+    spriteShader->SetUniformInt("blend_mode", blendMode);
+    spriteShader->SetUniformInt("texture_sampler", 0);
+
+    m_texture->Bind(0);
+    m_sampler.Bind(0);
+
+    glBindVertexArray(m_vaoID);
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices.data(), GL_DYNAMIC_DRAW);
+
+    glVertexAttrib4f(1, r, g, b, a);
+
+    switch (blendMode)
+    {
+        case 0:
+        default:
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            break;
+        case 1:
+            glDisable(GL_BLEND);
+            break;
+        case 2:
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_ONE, GL_ONE);
+            break;
+        case 3:
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
+            break;
+        case 4:
+            // Milkdrop actually changed color keying to using texture alpha. The color key is ignored.
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            break;
+    }
+
+    // Draw to current output buffer
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+    if (burnIn)
+    {
+        // Also draw into all active preset main textures for next-frame burn-in effect
+        for (const auto preset : presets)
+        {
+            if (!preset.get())
+            {
+                continue;
+            }
+
+            preset.get()->BindFramebuffer();
+            glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+        }
+
+        // Reset to original FBO
+        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, static_cast<GLuint>(outputFramebufferObject));
+    }
+
+    glDisable(GL_BLEND);
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
+    m_texture->Unbind(0);
+    Renderer::Shader::Unbind();
+}
+
+auto MilkdropSprite::Done() const -> bool
+{
+    return m_spriteDone;
+}
+
+MilkdropSprite::CodeContext::CodeContext()
+    : spriteCodeContext(projectm_eval_context_create(nullptr, nullptr))
+{
+}
+
+MilkdropSprite::CodeContext::~CodeContext()
+{
+    projectm_eval_context_destroy(spriteCodeContext);
+
+    spriteCodeContext = nullptr;
+    perFrameCodeHandle = nullptr;
+}
+
+void MilkdropSprite::CodeContext::RegisterBuiltinVariables()
+{
+    projectm_eval_context_reset_variables(spriteCodeContext);
+
+    // Input variables
+    REG_VAR(time);
+    REG_VAR(frame);
+    REG_VAR(fps);
+    REG_VAR(progress);
+    REG_VAR(bass);
+    REG_VAR(mid);
+    REG_VAR(treb);
+    REG_VAR(bass_att);
+    REG_VAR(mid_att);
+    REG_VAR(treb_att);
+
+    // Output variables
+    REG_VAR(done);
+    REG_VAR(burn);
+    REG_VAR(x);
+    REG_VAR(y);
+    REG_VAR(sx);
+    REG_VAR(sy);
+    REG_VAR(rot);
+    REG_VAR(flipx);
+    REG_VAR(flipy);
+    REG_VAR(repeatx);
+    REG_VAR(repeaty);
+    REG_VAR(blendmode);
+    REG_VAR(r);
+    REG_VAR(g);
+    REG_VAR(b);
+    REG_VAR(a);
+}
+
+void MilkdropSprite::CodeContext::RunInitCode(const std::string& initCode, const Renderer::RenderContext& renderContext)
+{
+    RegisterBuiltinVariables();
+
+    // Set default values of output variables:
+    // (by not setting these every frame, we allow the values to persist from frame-to-frame.)
+    *x = 0.5;
+    *y = 0.5;
+    *sx = 1.0;
+    *sy = 1.0;
+    *repeatx = 1.0;
+    *repeaty = 1.0;
+    *rot = 0.0;
+    *flipx = 0.0;
+    *flipy = 0.0;
+    *r = 1.0;
+    *g = 1.0;
+    *b = 1.0;
+    *a = 1.0;
+    *blendmode = 0.0;
+    *done = 0.0;
+    *burn = 1.0;
+
+    if (initCode.empty())
+    {
+        return;
+    }
+
+    // Only time and frame values are passed to the init code.
+    *time = renderContext.time;
+    *frame = renderContext.frame;
+
+    auto* initCodeHandle = projectm_eval_code_compile(spriteCodeContext, initCode.c_str());
+    if (initCodeHandle == nullptr)
+    {
+        int errorLine{};
+        int errorColumn{};
+        const auto* errorMessage = projectm_eval_get_error(spriteCodeContext, &errorLine, &errorColumn);
+
+        throw SpriteException("Error compiling sprite init code:" + std::string(errorMessage) + " (Line " + std::to_string(errorLine) + ", column " + std::to_string(errorColumn) + ")");
+    }
+
+    projectm_eval_code_execute(initCodeHandle);
+    projectm_eval_code_destroy(initCodeHandle);
+}
+
+void MilkdropSprite::CodeContext::RunPerFrameCode(const Audio::FrameAudioData& audioData, const Renderer::RenderContext& renderContext)
+{
+    // If there's no per-frame code, e.g. with static sprites, just skip it.
+    if (perFrameCodeHandle == nullptr)
+    {
+        return;
+    }
+
+    // Fill in input variables
+    *time = renderContext.time;
+    *frame = renderContext.frame;
+    *fps = renderContext.fps;
+    *progress = renderContext.blendProgress;
+    *bass = audioData.bass;
+    *mid = audioData.mid;
+    *treb = audioData.treb;
+    *bass_att = audioData.bassAtt;
+    *mid_att = audioData.midAtt;
+    *treb_att = audioData.trebAtt;
+
+    // Run the code
+    projectm_eval_code_execute(perFrameCodeHandle);
+}
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.hpp b/src/libprojectM/UserSprites/MilkdropSprite.hpp
new file mode 100644
index 000000000..21cd14e91
--- /dev/null
+++ b/src/libprojectM/UserSprites/MilkdropSprite.hpp
@@ -0,0 +1,107 @@
+#pragma once
+
+#include "UserSprites/Sprite.hpp"
+
+#include <Renderer/Texture.hpp>
+#include <Renderer/TextureSamplerDescriptor.hpp>
+
+#include <projectm-eval.h>
+
+namespace libprojectM {
+namespace UserSprites {
+
+class MilkdropSprite : public Sprite
+{
+public:
+    MilkdropSprite();
+
+    ~MilkdropSprite() override = default;
+
+    void InitVertexAttrib() override;
+
+    void Init(const std::string& spriteData, const Renderer::RenderContext& renderContext) override;
+
+    void Draw(const Audio::FrameAudioData& audioData,
+              const Renderer::RenderContext& renderContext,
+              uint32_t outputFramebufferObject,
+              PresetList presets) override;
+
+    auto Done() const-> bool override;
+
+private:
+    using Quad = std::array<TexturedPoint, 4>;
+
+    /**
+     * @brief Context for the init and per-frame code.
+     */
+    struct CodeContext
+    {
+        CodeContext();
+
+        ~CodeContext();
+
+        /**
+         * @brief Registers the state variables in the expression evaluator context.
+         */
+        void RegisterBuiltinVariables();
+
+        /**
+         * @brief Compiles and runs the init code of the sprite once, if any.
+         * Also sets up a the default values of the output variables.
+         * @param initCode The initialization code.
+         */
+        void RunInitCode(const std::string& initCode, const Renderer::RenderContext& renderContext);
+
+        /**
+         * @brief Runs the per-frame update code for the sprite.
+         * @param audioData The frame audio data structure.
+         * @param renderContext The frame rendering context data.
+         */
+        void RunPerFrameCode(const Audio::FrameAudioData& audioData,
+                             const Renderer::RenderContext& renderContext);
+
+        projectm_eval_context* spriteCodeContext{nullptr}; //!< The code runtime context, holds memory buffers and variables.
+        projectm_eval_code* perFrameCodeHandle{nullptr};     //!< The compiled per-frame code handle.
+
+        // Input variables
+        PRJM_EVAL_F* time{}; //!< Time passed since program start. Also available in init code.
+        PRJM_EVAL_F* frame{}; //!< Total frames rendered so far. Also available in init code.
+        PRJM_EVAL_F* fps{}; //!< Current (or, if not available, target) frames per second value.
+        PRJM_EVAL_F* progress{}; //!< Preset blending progress (only if blending).
+        PRJM_EVAL_F* bass{}; //!< Bass frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
+        PRJM_EVAL_F* mid{}; //!< Middle frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
+        PRJM_EVAL_F* treb{}; //!< Treble frequency loudness, median of 1.0, range of ~0.7 to ~1.3 in most cases.
+        PRJM_EVAL_F* bass_att{}; //!< More attenuated/smoothed value of bass.
+        PRJM_EVAL_F* mid_att{}; //!< More attenuated/smoothed value of mid.
+        PRJM_EVAL_F* treb_att{}; //!< More attenuated/smoothed value of treb.
+
+        // Output variables
+        PRJM_EVAL_F* done{}; //!< If this becomes non-zero, the sprite is deleted. Default: 0.0
+        PRJM_EVAL_F* burn{}; //!< If non-zero, the sprite will be "burned" into currently rendered presets when done is also true, effectively "dissolving" the sprite in the preset. Default: 1.0
+        PRJM_EVAL_F* x{}; //!< Sprite x position (position of the image center). Range from -1000 to 1000. Default: 0.5
+        PRJM_EVAL_F* y{}; //!< Sprite y position (position of the image center). Range from -1000 to 1000. Default: 0.5
+        PRJM_EVAL_F* sx{}; //!< Sprite x scaling factor. Range from -1000 to 1000. Default: 1.0
+        PRJM_EVAL_F* sy{}; //!< Sprite y scaling factor. Range from -1000 to 1000. Default: 1.0
+        PRJM_EVAL_F* rot{}; //!< Sprite rotation in radians (2*PI equals one full rotation). Default: 0.0
+        PRJM_EVAL_F* flipx{}; //!< If flag is non-zero, the sprite is flipped on the x axis. Default: 0.0
+        PRJM_EVAL_F* flipy{}; //!< If flag is non-zero, the sprite is flipped on the y axis. Default: 0.0
+        PRJM_EVAL_F* repeatx{}; //!< Repeat count of the image on the sprite quad on the x axis. Fractional values allowed. Range from 0.01 to 100.0. Default: 1.0
+        PRJM_EVAL_F* repeaty{}; //!< Repeat count of the image on the sprite quad on the y axis. Fractional values allowed. Range from 0.01 to 100.0. Default: 1.0
+        PRJM_EVAL_F* blendmode{}; //!< Image blending mode. 0 = Alpha blending (default), 1 = Decal mode (no transparency), 2 = Additive blending, 3 = Source color blending, 4 = Color key blending. Default: 0
+        PRJM_EVAL_F* r{}; //!< Modulation color used in some blending modes. Default: 1.0
+        PRJM_EVAL_F* g{}; //!< Modulation color used in some blending modes. Default: 1.0
+        PRJM_EVAL_F* b{}; //!< Modulation color used in some blending modes. Default: 1.0
+        PRJM_EVAL_F* a{}; //!< Modulation color used in some blending modes. Default: 1.0
+
+    };
+
+    CodeContext m_codeContext; //!< Sprite init and per-frame code.
+    std::shared_ptr<Renderer::Texture> m_texture; //!< The sprite image, loaded via a name like other textures in Milkdrop presets.
+    Renderer::Sampler m_sampler{GL_REPEAT, GL_LINEAR}; //!< Texture sampler settings
+    std::weak_ptr<Renderer::Shader> m_spriteShader; //!< The shader used to draw the user sprite.
+    bool m_spriteDone{false}; //!< If true, the sprite will be removed from the list.
+
+};
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/Shaders/MilkdropSpriteFragmentGlsl330.frag b/src/libprojectM/UserSprites/Shaders/MilkdropSpriteFragmentGlsl330.frag
new file mode 100644
index 000000000..ae2541634
--- /dev/null
+++ b/src/libprojectM/UserSprites/Shaders/MilkdropSpriteFragmentGlsl330.frag
@@ -0,0 +1,68 @@
+precision mediump float;
+
+in vec4 fragment_color;
+in vec2 fragment_texture;
+
+uniform sampler2D texture_sampler;
+
+uniform int blend_mode;
+
+out vec4 color;
+
+void main() {
+    // Comments contain the original code equivalents used in Milkdrop and a short explanation
+    // on what each mode does.
+    switch (blend_mode)
+    {
+        case 0:
+        // lpDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TEXTURE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
+        // lpDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
+        // for (k=0; k<4; k++) v3[k].Diffuse = D3DCOLOR_RGBA_01(r,g,b,a);
+
+        // Vertex diffuse color is modulated/multiplied with texture diffuse color.
+        // Texture stage state in D3D is equivalent to only use vertex diffuse alpha and ignoring texture alpha
+        color = vec4(fragment_color.rgb * texture(texture_sampler, fragment_texture.st).rgb, fragment_color.a);
+        break;
+
+        case 1:
+        // for (k=0; k<4; k++) v3[k].Diffuse = D3DCOLOR_RGBA_01(r*a,g*a,b*a,1);
+
+        // Vertex and texture diffuse colors are multiplied/modulated and then scaled by vertex alpha.
+        // Texture alpha is ignored (full opacity).
+        color = vec4((fragment_color.rgb * texture(texture_sampler, fragment_texture.st).rgb) * fragment_color.a, 1.0);
+        break;
+
+        case 2:
+        // for (k=0; k<4; k++) v3[k].Diffuse = D3DCOLOR_RGBA_01(r*a,g*a,b*a,1);
+
+        // Vertex and texture diffuse colors are multiplied/modulated and then scaled by vertex alpha.
+        // Texture alpha is ignored (full opacity).
+        color = vec4((fragment_color.rgb * texture(texture_sampler, fragment_texture.st).rgb) * fragment_color.a, 1.0);
+        break;
+
+        case 3:
+        // for (k=0; k<4; k++) v3[k].Diffuse = D3DCOLOR_RGBA_01(1,1,1,1);
+
+        // Vertex color is ignored, only use texture diffuse color.
+        // Vertex and texture alpha is also ignored in this mode.
+        color = vec4(texture(texture_sampler, fragment_texture.st).rgb, 1.0);
+        break;
+
+        case 4:
+        // lpDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TEXTURE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
+        // lpDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TEXTURE);
+        // for (k=0; k<4; k++) v3[k].Diffuse = D3DCOLOR_RGBA_01(r,g,b,a);
+
+        // Vertex diffuse color is modulated/multiplied with texture diffuse color.
+        // Texture stage state in D3D is equivalent to multiply (AKA modulate) vertex diffuse alpha with texture alpha.
+        color = fragment_color * texture(texture_sampler, fragment_texture.st);
+        break;
+    }
+}
diff --git a/src/libprojectM/UserSprites/Shaders/MilkdropSpriteVertexGlsl330.vert b/src/libprojectM/UserSprites/Shaders/MilkdropSpriteVertexGlsl330.vert
new file mode 100644
index 000000000..ece1133bf
--- /dev/null
+++ b/src/libprojectM/UserSprites/Shaders/MilkdropSpriteVertexGlsl330.vert
@@ -0,0 +1,14 @@
+precision mediump float;
+
+layout(location = 0) in vec2 vertex_position;
+layout(location = 1) in vec4 vertex_color;
+layout(location = 2) in vec2 vertex_texture;
+
+out vec4 fragment_color;
+out vec2 fragment_texture;
+
+void main(){
+    gl_Position = vec4(vertex_position, 0.0, 1.0);
+    fragment_color = vertex_color;
+    fragment_texture = vertex_texture;
+}
diff --git a/src/libprojectM/UserSprites/Sprite.hpp b/src/libprojectM/UserSprites/Sprite.hpp
new file mode 100644
index 000000000..e70e1a7a2
--- /dev/null
+++ b/src/libprojectM/UserSprites/Sprite.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "UserSprites/SpriteException.hpp"
+
+#include <Preset.hpp>
+
+#include <Audio/FrameAudioData.hpp>
+
+#include <Renderer/RenderContext.hpp>
+#include <Renderer/RenderItem.hpp>
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace libprojectM {
+namespace UserSprites {
+
+class Sprite : public Renderer::RenderItem
+{
+public:
+    using Ptr = std::unique_ptr<Sprite>;
+    using PresetList = std::vector<std::reference_wrapper<const std::unique_ptr<Preset>>>;
+
+    /**
+     * @brief Initializes the sprite instance for rendering.
+     * @param spriteData The data for the sprite type.
+     * @param renderContext The current frame's rendering context.
+     */
+    virtual void Init(const std::string& spriteData, const Renderer::RenderContext& renderContext) = 0;
+
+    /**
+     * @brief Draws the sprite onto the current framebuffer.
+     * @param audioData The frame audio data structure.
+     * @param renderContext The current frame's rendering context.
+     * @param outputFramebufferObject Framebuffer object the sprite will be rendered to.
+     * @param presets The active preset, plus eventually the transitioning one. Used for the burn-in effect.
+     */
+    virtual void Draw(const Audio::FrameAudioData& audioData,
+                      const Renderer::RenderContext& renderContext,
+                      uint32_t outputFramebufferObject,
+                      PresetList presets) = 0;
+
+    /**
+     * @brief Returns if the sprite has finished rendering and should be deleted.
+     * @return true if the sprite should be deleted, false if not.
+     */
+    virtual auto Done() const -> bool = 0;
+};
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/SpriteException.hpp b/src/libprojectM/UserSprites/SpriteException.hpp
new file mode 100644
index 000000000..ef05498dd
--- /dev/null
+++ b/src/libprojectM/UserSprites/SpriteException.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <string>
+#include <exception>
+
+namespace libprojectM {
+namespace UserSprites {
+
+/**
+ * @brief Exception for sprite loading errors.
+ */
+class SpriteException : public std::exception
+{
+public:
+    inline SpriteException(std::string message)
+        : m_message(std::move(message))
+    {
+    }
+
+    virtual ~SpriteException() = default;
+
+    const std::string& message() const
+    {
+        return m_message;
+    }
+
+private:
+    std::string m_message;
+};
+
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/SpriteManager.cpp b/src/libprojectM/UserSprites/SpriteManager.cpp
new file mode 100644
index 000000000..d8aef4d8c
--- /dev/null
+++ b/src/libprojectM/UserSprites/SpriteManager.cpp
@@ -0,0 +1,144 @@
+#include "UserSprites/SpriteManager.hpp"
+
+#include "UserSprites/Factory.hpp"
+
+#include <Renderer/Shader.hpp>
+
+#include <algorithm>
+
+namespace libprojectM {
+namespace UserSprites {
+
+auto SpriteManager::Spawn(const std::string& type,
+                          const std::string& spriteData,
+                          const Renderer::RenderContext& renderContext) -> uint32_t
+{
+    // If user set the limit to zero, don't bother.
+    if (m_spriteSlots == 0)
+    {
+        return 0;
+    }
+
+    auto sprite = Factory::CreateSprite(type);
+
+    if (!sprite)
+    {
+        return 0;
+    }
+
+    try
+    {
+        sprite->Init(spriteData, renderContext);
+    }
+    catch (SpriteException& ex)
+    {
+        return 0;
+    }
+    catch (Renderer::ShaderException& ex)
+    {
+        return 0;
+    }
+    catch (...)
+    {
+        return 0;
+    }
+
+    auto spriteIdentifier = GetLowestFreeIdentifier();
+
+    // Already at max sprites, destroy the oldest sprite to make room.
+    if (m_sprites.size() == m_spriteSlots)
+    {
+        Destroy(m_sprites.front().first);
+    }
+
+    m_sprites.emplace_back(spriteIdentifier, std::move(sprite));
+    m_spriteIdentifiers.insert(spriteIdentifier);
+
+    return spriteIdentifier;
+}
+
+void SpriteManager::Draw(const Audio::FrameAudioData& audioData,
+                         const Renderer::RenderContext& renderContext,
+                         uint32_t outputFramebufferObject,
+                         Sprite::PresetList presets)
+{
+    for (auto& idAndSprite : m_sprites) {
+        idAndSprite.second->Draw(audioData, renderContext, outputFramebufferObject, presets);
+
+        if (idAndSprite.second->Done())
+        {
+            Destroy(idAndSprite.first);
+        }
+    }
+}
+
+void SpriteManager::Destroy(SpriteIdentifier spriteIdentifier)
+{
+    if (m_spriteIdentifiers.find(spriteIdentifier) == m_spriteIdentifiers.end())
+    {
+        return;
+    }
+
+    m_spriteIdentifiers.erase(spriteIdentifier);
+    m_sprites.remove_if([spriteIdentifier](const auto& idAndSprite) {
+        return idAndSprite.first == spriteIdentifier;
+    });
+}
+
+void SpriteManager::DestroyAll()
+{
+    m_spriteIdentifiers.clear();
+    m_sprites.clear();
+}
+
+auto SpriteManager::ActiveSpriteCount() const -> uint32_t
+{
+    return m_sprites.size();
+}
+
+auto SpriteManager::ActiveSpriteIdentifiers() const -> std::vector<SpriteIdentifier>
+{
+    std::vector<SpriteIdentifier> identifierList;
+    for (auto& idAndSprite : m_sprites) {
+        identifierList.emplace_back(idAndSprite.first);
+    }
+
+    return identifierList;
+}
+
+void SpriteManager::SpriteSlots(uint32_t slots)
+{
+    m_spriteSlots = slots;
+
+    // Remove excess sprites if limit was lowered
+    while (m_sprites.size() > slots)
+    {
+        m_spriteIdentifiers.erase(m_sprites.front().first);
+        m_sprites.pop_front();
+    }
+}
+
+auto SpriteManager::SpriteSlots() const -> uint32_t
+{
+    return m_spriteSlots;
+}
+
+auto SpriteManager::GetLowestFreeIdentifier() -> SpriteIdentifier
+{
+    SpriteIdentifier lowestId = 0;
+
+    for (const auto& spriteId : m_spriteIdentifiers)
+    {
+        if (spriteId > lowestId + 1)
+        {
+            return lowestId + 1;
+        }
+
+        lowestId = spriteId;
+    }
+
+    return lowestId + 1;
+}
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/src/libprojectM/UserSprites/SpriteManager.hpp b/src/libprojectM/UserSprites/SpriteManager.hpp
new file mode 100644
index 000000000..6ad391cd4
--- /dev/null
+++ b/src/libprojectM/UserSprites/SpriteManager.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include "UserSprites/Sprite.hpp"
+
+#include <Renderer/RenderContext.hpp>
+
+#include <cstdint>
+#include <list>
+#include <set>
+#include <utility>
+#include <vector>
+
+namespace libprojectM {
+namespace UserSprites {
+
+class SpriteManager
+{
+public:
+    using SpriteIdentifier = uint32_t;
+
+    /**
+     * @brief Spawns a new sprite.
+     * @param type The type name of the sprite.
+     * @param spriteData The sprite code/data, depending on the type.
+     * @return A unique, non-zero identifier if the sprite was successfully spawned, or zero if an error occurred.
+     */
+    auto Spawn(const std::string& type,
+               const std::string& spriteData,
+               const Renderer::RenderContext& renderContext) -> SpriteIdentifier;
+
+    /**
+     * @brief Draws all active sprites.
+     * @param audioData The frame audio data structure.
+     * @param renderContext The current frame's rendering context.
+     * @param outputFramebufferObject Framebuffer object the sprite will be rendered to.
+     * @param presets The active preset, plus eventually the transitioning one. Used for the burn-in effect.
+     */
+    void Draw(const Audio::FrameAudioData& audioData,
+              const Renderer::RenderContext& renderContext,
+              uint32_t outputFramebufferObject,
+              Sprite::PresetList presets);
+
+    /**
+     * @brief Destroys a single active sprite.
+     *
+     * If spriteIdentifier is invalid, no action will be taken.
+     *
+     * @param spriteIdentifier The identifier of the sprite to destroy.
+     */
+    void Destroy(SpriteIdentifier spriteIdentifier);
+
+    /**
+     * @brief Destroys all active sprites.
+     *
+     * Sprites will be removed when drawing the next frame.
+     */
+    void DestroyAll();
+
+    /**
+     * @brief Returns the current number of active sprites.
+     * @return The current number of active sprites.
+     */
+    auto ActiveSpriteCount() const -> uint32_t;
+
+    /**
+     * @brief Returns a set of identifiers for all active sprites.
+     * @return A vector with the identifiers of all active sprites.
+     */
+    auto ActiveSpriteIdentifiers() const -> std::vector<SpriteIdentifier>;
+
+    /**
+     * @brief Sets the number of available sprite slots, e.g. the number of concurrently active sprites.
+     * If there are more active sprites than the newly set limit, the oldest sprites will be destroyed
+     * in order until the new limit is matched.
+     * @param slots The maximum number of active sprites. 0 disables user sprites. Default is 16.
+     */
+    void SpriteSlots(uint32_t slots);
+
+    /**
+     * @brief Returns the currently set maximum number of active sprites.
+     * @return The maximum number of active sprites.
+     */
+    auto SpriteSlots() const -> uint32_t;
+
+private:
+    using SpriteIdPair = std::pair<SpriteIdentifier, Sprite::Ptr>;
+
+    /**
+     * Returns the lowest free ID, starting at 1.
+     * @return The lowest available/unused sprite ID.
+     */
+    SpriteIdentifier GetLowestFreeIdentifier();
+
+    uint32_t m_spriteSlots{16};                     //!< Max number of active sprites.
+    std::set<SpriteIdentifier> m_spriteIdentifiers; //!< Set to keep track of ordered sprite IDs.
+    std::list<SpriteIdPair> m_sprites;              //!< Active sprites with their identifier.
+};
+
+} // namespace UserSprites
+} // namespace libprojectM
diff --git a/tests/libprojectM/CMakeLists.txt b/tests/libprojectM/CMakeLists.txt
index f0d49f8c4..040a82120 100644
--- a/tests/libprojectM/CMakeLists.txt
+++ b/tests/libprojectM/CMakeLists.txt
@@ -7,6 +7,7 @@ add_executable(projectM-unittest
         $<TARGET_OBJECTS:Audio>
         $<TARGET_OBJECTS:MilkdropPreset>
         $<TARGET_OBJECTS:Renderer>
+        $<TARGET_OBJECTS:UserSprites>
         $<TARGET_OBJECTS:hlslparser>
         $<TARGET_OBJECTS:SOIL2>
         $<TARGET_OBJECTS:projectM_main>
diff --git a/tests/libprojectM/PresetFileParserTest.cpp b/tests/libprojectM/PresetFileParserTest.cpp
index 25cd69201..1c6fc27f6 100644
--- a/tests/libprojectM/PresetFileParserTest.cpp
+++ b/tests/libprojectM/PresetFileParserTest.cpp
@@ -1,10 +1,10 @@
 #include <gtest/gtest.h>
 
-#include <MilkdropPreset/PresetFileParser.hpp>
+#include <PresetFileParser.hpp>
 
 static constexpr auto fileParserTestDataPath{ PROJECTM_TEST_DATA_DIR "/PresetFileParser/" };
 
-using libprojectM::MilkdropPreset::PresetFileParser;
+using libprojectM::PresetFileParser;
 
 /**
  * Class to make protected function accessible to tests.