diff --git a/.gitignore b/.gitignore
index aface6d10e..6e5e388bd5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -59,3 +59,4 @@ src/libprojectM/build/
 # CLion
 cmake-build-*
 .idea
+.aider*
diff --git a/src/libprojectM/MilkdropPreset/Border.cpp b/src/libprojectM/MilkdropPreset/Border.cpp
index f5805e4e80..7f25c0364d 100644
--- a/src/libprojectM/MilkdropPreset/Border.cpp
+++ b/src/libprojectM/MilkdropPreset/Border.cpp
@@ -9,10 +9,9 @@ namespace MilkdropPreset {
 
 Border::Border(PresetState& presetState)
     : m_presetState(presetState)
-    , m_borderMesh(Renderer::VertexBufferUsage::StreamDraw)
 {
-    m_borderMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::Triangles);
-    m_borderMesh.SetVertexCount(8);
+    Init();
+}
 
     m_borderMesh.Indices().Set({
     {
diff --git a/src/libprojectM/MilkdropPreset/Border.hpp b/src/libprojectM/MilkdropPreset/Border.hpp
index 839398ca19..1baaafb467 100644
--- a/src/libprojectM/MilkdropPreset/Border.hpp
+++ b/src/libprojectM/MilkdropPreset/Border.hpp
@@ -2,16 +2,15 @@
 
 #include "PresetState.hpp"
 
-#include <Renderer/Mesh.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
 
-
 /**
  * @brief Renders a border around the screen.
  */
-class Border
+class Border : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     Border() = delete;
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.cpp b/src/libprojectM/MilkdropPreset/CustomShape.cpp
index 1acbeb2395..122f89b1b0 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.cpp
@@ -19,8 +19,37 @@ CustomShape::CustomShape(PresetState& presetState)
     m_outlineMesh.SetVertexCount(100);
     m_outlineMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::LineLoop);
 
-    m_fillMesh.SetVertexCount(102);
-    m_fillMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::TriangleFan);
+    glGenVertexArrays(1, &m_vaoIdTextured);
+    glGenBuffers(1, &m_vboIdTextured);
+
+    glGenVertexArrays(1, &m_vaoIdUntextured);
+    glGenBuffers(1, &m_vboIdUntextured);
+
+    glBindVertexArray(m_vaoIdTextured);
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboIdTextured);
+
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, x))); // Position
+    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, r))); // Color
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, u))); // Texture coordinate
+
+    glBufferData(GL_ARRAY_BUFFER, sizeof(TexturedPoint) * vertexData.size(), vertexData.data(), GL_STREAM_DRAW);
+
+    glBindVertexArray(m_vaoIdUntextured);
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboIdUntextured);
+
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, x))); // Position
+    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, r))); // Color
+
+    glBufferData(GL_ARRAY_BUFFER, sizeof(TexturedPoint) * vertexData.size(), vertexData.data(), GL_STREAM_DRAW);
+
+    Init();
 
     m_perFrameContext.RegisterBuiltinVariables();
 }
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.hpp b/src/libprojectM/MilkdropPreset/CustomShape.hpp
index 5090b37eb7..49c7d2a82d 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.hpp
@@ -4,8 +4,8 @@
 #include "PresetState.hpp"
 #include "ShapePerFrameContext.hpp"
 
-#include <Renderer/Mesh.hpp>
-
+#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 #include <projectm-eval.h>
 
 namespace libprojectM {
@@ -19,7 +19,7 @@ class PresetFileParser;
  * The class creates two sets of VBO/VAO as it's only known later (in the Draw() call) whether the shape is textured
  * or not.
  */
-class CustomShape
+class CustomShape : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     CustomShape(PresetState& presetState);
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
index 3ca7bbe755..8f5d83f9cd 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
@@ -19,6 +19,8 @@ CustomWaveform::CustomWaveform(PresetState& presetState)
     , m_perPointContext(presetState.globalMemory, &presetState.globalRegisters)
     , m_mesh(Renderer::VertexBufferUsage::StreamDraw, true, false)
 {
+    Init();
+
     m_perFrameContext.RegisterBuiltinVariables();
     m_perPointContext.RegisterBuiltinVariables();
 
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
index 7c4c3df1a2..609aded314 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
@@ -3,9 +3,7 @@
 #include "WaveformPerFrameContext.hpp"
 #include "WaveformPerPointContext.hpp"
 
-#include <Renderer/Color.hpp>
-#include <Renderer/Mesh.hpp>
-#include <Renderer/Point.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <vector>
 
@@ -14,7 +12,9 @@ namespace MilkdropPreset {
 
 class PresetFileParser;
 
-class CustomWaveform
+namespace MilkdropPreset {
+
+class CustomWaveform : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
 
@@ -24,12 +24,14 @@ class CustomWaveform
      */
     explicit CustomWaveform(PresetState& presetState);
 
+    void InitVertexAttrib() override;
+
     /**
      * @brief Loads the initial values and code from the preset file.
      * @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.
@@ -69,10 +71,12 @@ class CustomWaveform
      *
      * Roughly doubles the number of points.
      *
-     * @param points A vector of points to be smoothed.
-     * @param colors A vector of colors for the points.
+     * @param inputVertices Array of input vertices to be smoothed.
+     * @param vertexCount Number of vertices in the input array.
+     * @param outputVertices Array to store the smoothed vertices.
+     * @return The number of vertices in the output array.
      */
-    void SmoothWave(const std::vector<Renderer::Point>& points, const std::vector<Renderer::Color>& colors);
+    static int SmoothWave(const ColoredPoint* inputVertices, int vertexCount, ColoredPoint* outputVertices);
 
     int m_index{0}; //!< Custom waveform index in the preset.
     bool m_enabled{false}; //!< Render waveform if non-zero.
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
index 1bd1d8a126..ae2266ae52 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
@@ -7,17 +7,17 @@ namespace MilkdropPreset {
 
 DarkenCenter::DarkenCenter(PresetState& presetState)
     : m_presetState(presetState)
-    , m_mesh(Renderer::VertexBufferUsage::StaticDraw, true, false)
 {
-    m_mesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::TriangleFan);
-    m_mesh.SetVertexCount(6);
-    m_mesh.Colors().Set({{0.0f, 0.0f, 0.0f, 3.0f / 32.0f},
-                         {0.0f, 0.0f, 0.0f, 0.0f},
-                         {0.0f, 0.0f, 0.0f, 0.0f},
-                         {0.0f, 0.0f, 0.0f, 0.0f},
-                         {0.0f, 0.0f, 0.0f, 0.0f},
-                         {0.0f, 0.0f, 0.0f, 0.0f}});
-    m_mesh.Update();
+    Init();
+}
+
+void DarkenCenter::InitVertexAttrib()
+{
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(ColoredPoint), nullptr);                                            // points
+    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(ColoredPoint), reinterpret_cast<void*>(offsetof(ColoredPoint, r))); // colors
 }
 
 void DarkenCenter::Draw()
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
index b6921d1a07..903c5ebb30 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
@@ -2,7 +2,7 @@
 
 #include "PresetState.hpp"
 
-#include <Renderer/Mesh.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -10,13 +10,15 @@ namespace MilkdropPreset {
 /**
  * @brief Darkens the screen center a bit on each frame.
  */
-class DarkenCenter
+class DarkenCenter : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     DarkenCenter() = delete;
 
     explicit DarkenCenter(PresetState& presetState);
 
+    void InitVertexAttrib() override;
+
     /**
      * Applies the darkening area.
      */
diff --git a/src/libprojectM/MilkdropPreset/Filters.cpp b/src/libprojectM/MilkdropPreset/Filters.cpp
index e5d8702df1..225f6e6415 100644
--- a/src/libprojectM/MilkdropPreset/Filters.cpp
+++ b/src/libprojectM/MilkdropPreset/Filters.cpp
@@ -9,10 +9,16 @@ namespace MilkdropPreset {
 
 Filters::Filters(const PresetState& presetState)
     : m_presetState(presetState)
-    , m_filterMesh(Renderer::VertexBufferUsage::StaticDraw)
 {
-    m_filterMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::TriangleStrip);
-    m_filterMesh.SetVertexCount(4);
+    Init();
+}
+
+void Filters::InitVertexAttrib()
+{
+    glEnableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Point), reinterpret_cast<void*>(offsetof(Point, x)));
 }
 
 void Filters::Draw()
diff --git a/src/libprojectM/MilkdropPreset/Filters.hpp b/src/libprojectM/MilkdropPreset/Filters.hpp
index 1decfcafb8..9b915b4d43 100644
--- a/src/libprojectM/MilkdropPreset/Filters.hpp
+++ b/src/libprojectM/MilkdropPreset/Filters.hpp
@@ -2,7 +2,7 @@
 
 #include "PresetState.hpp"
 
-#include <Renderer/Mesh.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -10,12 +10,14 @@ namespace MilkdropPreset {
 /**
  * @brief Classic Milkdrop 1 postprocessing effects.
  */
-class Filters
+class Filters : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     Filters() = delete;
     explicit Filters(const PresetState& presetState);
 
+    void InitVertexAttrib() override;
+
     /**
      * @brief Applies the configured filters to the current output.
      */
diff --git a/src/libprojectM/MilkdropPreset/FinalComposite.cpp b/src/libprojectM/MilkdropPreset/FinalComposite.cpp
index 693df44935..71692ad558 100644
--- a/src/libprojectM/MilkdropPreset/FinalComposite.cpp
+++ b/src/libprojectM/MilkdropPreset/FinalComposite.cpp
@@ -15,7 +15,8 @@ static std::string const defaultCompositeShader = "shader_body\n{\nret = tex2D(s
 FinalComposite::FinalComposite()
     : m_compositeMesh(Renderer::VertexBufferUsage::StreamDraw, true, true)
 {
-    m_compositeMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::Triangles);
+    Init();
+}
 
     // Add attribute array for radius and angle information to the mesh.
     m_compositeMesh.Bind();
diff --git a/src/libprojectM/MilkdropPreset/FinalComposite.hpp b/src/libprojectM/MilkdropPreset/FinalComposite.hpp
index 9701447706..0876a47a84 100644
--- a/src/libprojectM/MilkdropPreset/FinalComposite.hpp
+++ b/src/libprojectM/MilkdropPreset/FinalComposite.hpp
@@ -4,7 +4,7 @@
 #include "MilkdropShader.hpp"
 #include "VideoEcho.hpp"
 
-#include <Renderer/Mesh.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <memory>
 
@@ -14,11 +14,13 @@ namespace MilkdropPreset {
 /**
  * @brief Draws the final composite effect, either a shader or Milkdrop 1 effects.
  */
-class FinalComposite
+class FinalComposite : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     FinalComposite();
 
+    void InitVertexAttrib() override;
+
     /**
      * @brief Loads the composite shader, if the preset uses one.
      * @param presetState The preset state to retrieve the shader from.
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
index ef1716115b..284b5a84bf 100755
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
@@ -24,6 +24,7 @@
 #include "Factory.hpp"
 #include "MilkdropPresetExceptions.hpp"
 #include "PresetFileParser.hpp"
+#include <Renderer/Backend/OpenGL/OpenGLCopyTexture.hpp>
 
 #include <Logging.hpp>
 
@@ -38,7 +39,10 @@ MilkdropPreset::MilkdropPreset(const std::string& absoluteFilePath)
     , m_waveform(m_state)
     , m_darkenCenter(m_state)
     , m_border(m_state)
+    , m_flipTexture(std::make_unique<libprojectM::Renderer::Backend::OpenGL::OpenGLCopyTexture>())
 {
+    // Ensure OpenGLCopyTexture is visible to this translation unit
+    // (include the header if not already included at the top of this file)
     Load(absoluteFilePath);
 }
 
@@ -49,7 +53,10 @@ MilkdropPreset::MilkdropPreset(std::istream& presetData)
     , m_waveform(m_state)
     , m_darkenCenter(m_state)
     , m_border(m_state)
+    , m_flipTexture(std::make_unique<libprojectM::Renderer::Backend::OpenGL::OpenGLCopyTexture>())
 {
+    // Ensure OpenGLCopyTexture is visible to this translation unit
+    // (include the header if not already included at the top of this file)
     Load(presetData);
 }
 
@@ -103,8 +110,8 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     }
 
     // y-flip the previous frame and assign the flipped texture as "main"
-    m_flipTexture.Draw(*renderContext.shaderCache, m_framebuffer.GetColorAttachmentTexture(m_previousFrameBuffer, 0), nullptr, true, false);
-    m_state.mainTexture = m_flipTexture.Texture();
+    m_flipTexture->Draw(m_framebuffer.GetColorAttachmentTexture(m_previousFrameBuffer, 0), nullptr, true, false);
+    m_state.mainTexture = m_flipTexture->Texture();
 
     // We now draw to the current framebuffer.
     m_framebuffer.Bind(m_currentFrameBuffer);
@@ -144,8 +151,8 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     m_border.Draw(m_perFrameContext);
 
     // y-flip the image for final compositing again
-    m_flipTexture.Draw(*renderContext.shaderCache, m_framebuffer.GetColorAttachmentTexture(m_currentFrameBuffer, 0), nullptr, true, false);
-    m_state.mainTexture = m_flipTexture.Texture();
+    m_flipTexture->Draw(m_framebuffer.GetColorAttachmentTexture(m_currentFrameBuffer, 0), nullptr, true, false);
+    m_state.mainTexture = m_flipTexture->Texture();
 
     // We no longer need the previous frame image, use it to render the final composite.
     m_framebuffer.BindRead(m_currentFrameBuffer);
@@ -156,7 +163,7 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     if (!m_finalComposite.HasCompositeShader())
     {
         // Flip texture again in "previous" framebuffer as old-school effects are still upside down.
-        m_flipTexture.Draw(*renderContext.shaderCache, m_framebuffer.GetColorAttachmentTexture(m_previousFrameBuffer, 0), m_framebuffer, m_previousFrameBuffer, true, false);
+        m_flipTexture->Draw(m_framebuffer.GetColorAttachmentTexture(m_previousFrameBuffer, 0), m_framebuffer, m_previousFrameBuffer, true, false);
     }
 
     // Swap framebuffer IDs for the next frame.
@@ -168,7 +175,7 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
 auto MilkdropPreset::OutputTexture() const -> std::shared_ptr<Renderer::Texture>
 {
     // the composited image is always stored in the "current" framebuffer after a frame is rendered.
-    return m_framebuffer.GetColorAttachmentTexture(m_currentFrameBuffer, 0);
+    return m_flipTexture->Texture();
 }
 
 void MilkdropPreset::DrawInitialImage(const std::shared_ptr<Renderer::Texture>& image, const Renderer::RenderContext& renderContext)
@@ -176,7 +183,7 @@ void MilkdropPreset::DrawInitialImage(const std::shared_ptr<Renderer::Texture>&
     m_framebuffer.SetSize(renderContext.viewportSizeX, renderContext.viewportSizeY);
 
     // Render to previous framebuffer, as this is the image used to draw the next frame on.
-    m_flipTexture.Draw(*renderContext.shaderCache, image, m_framebuffer, m_previousFrameBuffer);
+    m_flipTexture->Draw(image, m_framebuffer, m_previousFrameBuffer);
 }
 
 void MilkdropPreset::BindFramebuffer()
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
index db8eb43ba4..e702f05a78 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
@@ -124,7 +124,7 @@ class MilkdropPreset : public ::libprojectM::Preset
     std::array<std::unique_ptr<CustomShape>, CustomShapeCount> m_customShapes;          //!< Custom shapes in this preset.
     DarkenCenter m_darkenCenter;                                                        //!< Center darkening effect.
     Border m_border;                                                                    //!< Inner/outer borders.
-    Renderer::CopyTexture m_flipTexture;                                                //!< Texture flip filter
+    std::unique_ptr<Renderer::CopyTexture> m_flipTexture;                               //!< Texture flip filter
 
     FinalComposite m_finalComposite; //!< Final composite shader or filters.
 
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.cpp b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
index 5cd31b111b..2b9a197bf0 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.cpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
@@ -13,9 +13,18 @@ namespace MilkdropPreset {
 
 MotionVectors::MotionVectors(PresetState& presetState)
     : m_presetState(presetState)
-    , m_motionVectorMesh(Renderer::VertexBufferUsage::StreamDraw)
 {
-    m_motionVectorMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::Lines);
+    Init();
+}
+
+void MotionVectors::InitVertexAttrib()
+{
+    glEnableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(MotionVectorVertex), reinterpret_cast<void*>(offsetof(MotionVectorVertex, x)));
+    glVertexAttribIPointer(2, 1, GL_INT, sizeof(MotionVectorVertex), reinterpret_cast<void*>(offsetof(MotionVectorVertex, index)));
 }
 
 void MotionVectors::Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<Renderer::Texture> motionTexture)
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.hpp b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
index 93e44124b2..84fbb074b1 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.hpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
@@ -3,7 +3,7 @@
 #include "PerFrameContext.hpp"
 #include "PresetState.hpp"
 
-#include <Renderer/Mesh.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <memory>
 
@@ -12,24 +12,16 @@ namespace MilkdropPreset {
 
 /**
  * @brief Draws a flexible motion vector field.
- *
- * Uses the same drawing logic as Milkdrop, but instead of reverse-propagating the motion data
- * on the CPU, projectM does this within the Motion Vector vertex shader. The Warp effect draws the
- * final U/V coordinates to a float texture, which is then used in the next frame to calculate the
- * vector length at the location of the line origin.
  */
-class MotionVectors
+class MotionVectors : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     MotionVectors() = delete;
 
     explicit MotionVectors(PresetState& presetState);
 
-    /**
-     * Renders the motion vectors.
-     * @param presetPerFrameContext The per-frame context variables.
-     * @param motionTexture The u/v "motion" texture written by the warp shader.
-     */
+    void InitVertexAttrib() override;
+
     void Draw(const PerFrameContext& presetPerFrameContext, std::shared_ptr<Renderer::Texture> motionTexture);
 
 private:
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
index 6e2bf9cc1c..a3881677dd 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
@@ -17,9 +17,9 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 PerPixelMesh::PerPixelMesh()
-    : m_warpMesh(Renderer::VertexBufferUsage::StreamDraw)
 {
-    m_warpMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::Triangles);
+    Init();
+}
 
     m_warpMesh.Bind();
     m_radiusAngleBuffer.Bind();
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
index dda77f114b..01038f6299 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Renderer/Mesh.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 #include <Renderer/Shader.hpp>
 
 namespace libprojectM {
@@ -24,7 +24,7 @@ class MilkdropShader;
  *
  * The mesh size can be changed between frames, the class will reallocate the buffers if needed.
  */
-class PerPixelMesh
+class PerPixelMesh : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     PerPixelMesh();
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.cpp b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
index 21b7399d89..dfa0b42342 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.cpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
@@ -7,10 +7,19 @@ namespace MilkdropPreset {
 
 VideoEcho::VideoEcho(const PresetState& presetState)
     : m_presetState(presetState)
-    , m_echoMesh(Renderer::VertexBufferUsage::DynamicDraw, true, true)
 {
-    m_echoMesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::TriangleStrip);
-    m_echoMesh.SetVertexCount(4);
+    Init();
+}
+
+void VideoEcho::InitVertexAttrib()
+{
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, x))); // Position
+    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, r))); // Color
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, u))); // Texture coordinates
 }
 
 void VideoEcho::Draw()
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.hpp b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
index 1077ba4f66..1986f24a45 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.hpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
@@ -3,7 +3,9 @@
 #include "PerFrameContext.hpp"
 #include "PresetState.hpp"
 
-#include <Renderer/Mesh.hpp>
+#include <projectM-opengl.h>
+
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -11,13 +13,15 @@ namespace MilkdropPreset {
 /**
  * @brief Renders a video "echo" (ghost image) effect and gamma adjustments.
  */
-class VideoEcho
+class VideoEcho : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
-	VideoEcho() = delete;
+    VideoEcho() = delete;
     explicit VideoEcho(const PresetState& presetState);
 
-	void Draw();
+    void InitVertexAttrib() override;
+
+    void Draw();
 
 private:
     void DrawVideoEcho();
diff --git a/src/libprojectM/MilkdropPreset/Waveform.cpp b/src/libprojectM/MilkdropPreset/Waveform.cpp
index 78c3a97b7a..e719f0e94e 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.cpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.cpp
@@ -17,8 +17,20 @@ namespace MilkdropPreset {
 
 Waveform::Waveform(PresetState& presetState)
     : m_presetState(presetState)
-    , m_waveMesh(Renderer::VertexBufferUsage::StreamDraw)
 {
+    Init();
+}
+
+void Waveform::InitVertexAttrib()
+{
+    glEnableVertexAttribArray(0);
+    glDisableVertexAttribArray(1);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+    std::vector<Point> vertexData;
+    vertexData.resize(std::max(libprojectM::Audio::SpectrumSamples, libprojectM::Audio::WaveformSamples) * 2 + 2);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(Point) * vertexData.size(), vertexData.data(), GL_STREAM_DRAW);
 }
 
 void Waveform::Draw(const PerFrameContext& presetPerFrameContext)
diff --git a/src/libprojectM/MilkdropPreset/Waveform.hpp b/src/libprojectM/MilkdropPreset/Waveform.hpp
index 5e6084aab8..7fd25a1580 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.hpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.hpp
@@ -4,7 +4,7 @@
 
 #include "Waveforms/WaveformMath.hpp"
 
-#include <Renderer/Mesh.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <memory>
 
@@ -14,7 +14,7 @@ namespace MilkdropPreset {
 class PresetState;
 class PerFrameContext;
 
-class Waveform
+class Waveform : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     explicit Waveform(PresetState& presetState);
diff --git a/src/libprojectM/ProjectM.cpp b/src/libprojectM/ProjectM.cpp
index 9ec73afac7..5d36477553 100644
--- a/src/libprojectM/ProjectM.cpp
+++ b/src/libprojectM/ProjectM.cpp
@@ -25,10 +25,11 @@
 #include "Preset.hpp"
 #include "PresetFactoryManager.hpp"
 #include "TimeKeeper.hpp"
+#include "Renderer/Backend/OpenGL/OpenGLPresetTransition.hpp"
 
 #include <Audio/PCM.hpp>
 
-#include <Renderer/CopyTexture.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLCopyTexture.hpp>
 #include <Renderer/PresetTransition.hpp>
 #include <Renderer/ShaderCache.hpp>
 #include <Renderer/TextureManager.hpp>
@@ -222,7 +223,7 @@ void ProjectM::Initialize()
 
     m_transitionShaderManager = std::make_unique<Renderer::TransitionShaderManager>();
 
-    m_textureCopier = std::make_unique<Renderer::CopyTexture>();
+    m_textureCopier = std::make_unique<Renderer::Backend::OpenGL::OpenGLCopyTexture>();
 
     m_spriteManager = std::make_unique<UserSprites::SpriteManager>();
 
@@ -305,7 +306,11 @@ void ProjectM::StartPresetTransition(std::unique_ptr<Preset>&& preset, bool hard
     {
         m_transitioningPreset = std::move(preset);
         m_timeKeeper->StartSmoothing();
-        m_transition = std::make_unique<Renderer::PresetTransition>(m_transitionShaderManager->RandomTransition(), m_softCutDuration, m_timeKeeper->GetFrameTime());
+        m_transition = std::make_unique<Renderer::Backend::OpenGL::OpenGLPresetTransition>(
+            m_transitionShaderManager->RandomTransition(),
+            m_softCutDuration,
+            m_timeKeeper->GetFrameTime()
+        );
     }
 }
 
diff --git a/src/libprojectM/Renderer/Backend/OpenGL/OpenGLCopyTexture.cpp b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLCopyTexture.cpp
new file mode 100644
index 0000000000..cedf4fa899
--- /dev/null
+++ b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLCopyTexture.cpp
@@ -0,0 +1,236 @@
+#include "OpenGLCopyTexture.hpp"
+
+#include <array>
+#include <iostream>
+
+namespace libprojectM {
+namespace Renderer {
+namespace Backend {
+namespace OpenGL {
+
+#ifdef USE_GLES
+static constexpr char ShaderVersion[] = "#version 300 es\n\n";
+#else
+static constexpr char ShaderVersion[] = "#version 330\n\n";
+#endif
+
+static constexpr char CopyTextureVertexShader[] = R"(
+precision mediump float;
+
+layout(location = 0) in vec2 position;
+layout(location = 1) in vec2 tex_coord;
+
+out vec2 fragment_tex_coord;
+
+uniform ivec2 flip;
+
+void main() {
+    gl_Position = vec4(position, 0.0, 1.0);
+    fragment_tex_coord = tex_coord;
+    if (flip.x > 0)
+    {
+        fragment_tex_coord.s = 1.0 - fragment_tex_coord.s;
+    }
+    if (flip.y > 0)
+    {
+        fragment_tex_coord.t = 1.0 - fragment_tex_coord.t;
+    }
+}
+)";
+
+static constexpr char CopyTextureFragmentShader[] = R"(
+precision mediump float;
+
+in vec2 fragment_tex_coord;
+
+uniform sampler2D texture_sampler;
+
+out vec4 color;
+
+void main(){
+    color = texture(texture_sampler, fragment_tex_coord);
+}
+
+)";
+
+OpenGLCopyTexture::OpenGLCopyTexture()
+{
+    Init();
+
+    m_framebuffer.CreateColorAttachment(0, 0);
+
+    std::string vertexShader(static_cast<const char*>(ShaderVersion));
+    std::string fragmentShader(static_cast<const char*>(ShaderVersion));
+    vertexShader.append(static_cast<const char*>(CopyTextureVertexShader));
+    fragmentShader.append(static_cast<const char*>(CopyTextureFragmentShader));
+
+    m_shader.CompileProgram(vertexShader, fragmentShader);
+}
+
+void OpenGLCopyTexture::InitVertexAttrib()
+{
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, x))); // Position
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedPoint), reinterpret_cast<void*>(offsetof(TexturedPoint, u))); // Texture coordinate
+
+    std::array<RenderItem::TexturedPoint, 4> points;
+
+    points[0].x = -1.0;
+    points[0].y = 1.0;
+    points[1].x = 1.0;
+    points[1].y = 1.0;
+    points[2].x = -1.0;
+    points[2].y = -1.0;
+    points[3].x = 1.0;
+    points[3].y = -1.0;
+
+    points[0].u = 0.0;
+    points[0].v = 1.0;
+    points[1].u = 1.0;
+    points[1].v = 1.0;
+    points[2].u = 0.0;
+    points[2].v = 0.0;
+    points[3].u = 1.0;
+    points[3].v = 0.0;
+
+    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points.data(), GL_STATIC_DRAW);
+}
+
+void OpenGLCopyTexture::Draw(const std::shared_ptr<class Texture>& originalTexture, bool flipVertical, bool flipHorizontal)
+{
+    if (originalTexture == nullptr)
+    {
+        return;
+    }
+
+    // Just bind the texture and draw it to the currently bound buffer.
+    originalTexture->Bind(0);
+    Copy(flipVertical, flipHorizontal);
+}
+
+void OpenGLCopyTexture::Draw(const std::shared_ptr<class Texture>& originalTexture, const std::shared_ptr<class Texture>& targetTexture,
+                       bool flipVertical, bool flipHorizontal)
+{
+    if (originalTexture == nullptr ||
+        originalTexture->Empty() ||
+        (targetTexture != nullptr && targetTexture->Empty()) ||
+        originalTexture == targetTexture)
+    {
+        return;
+    }
+
+    if (targetTexture == nullptr)
+    {
+        UpdateTextureSize(originalTexture->Width(), originalTexture->Height());
+    }
+    else
+    {
+        UpdateTextureSize(targetTexture->Width(), targetTexture->Height());
+    }
+
+    if (m_width == 0 || m_height == 0)
+    {
+        return;
+    }
+
+    std::shared_ptr<class Texture> internalTexture;
+
+    m_framebuffer.Bind(0);
+
+    // Draw from unflipped texture
+    originalTexture->Bind(0);
+
+    if (targetTexture)
+    {
+        internalTexture = m_framebuffer.GetColorAttachmentTexture(0, 0);
+        m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0)->Texture(targetTexture);
+    }
+
+    Copy(flipVertical, flipHorizontal);
+
+    // Rebind our internal texture.
+    if (targetTexture)
+    {
+        m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0)->Texture(internalTexture);
+    }
+
+    Framebuffer::Unbind();
+}
+
+void OpenGLCopyTexture::Draw(const std::shared_ptr<class Texture>& originalTexture, Framebuffer& framebuffer, int framebufferIndex,
+                       bool flipVertical, bool flipHorizontal)
+{
+    if (originalTexture == nullptr
+        || originalTexture->Empty()
+        || framebuffer.GetColorAttachmentTexture(framebufferIndex, 0) == nullptr
+        || framebuffer.GetColorAttachmentTexture(framebufferIndex, 0)->Empty())
+    {
+        return;
+    }
+
+    UpdateTextureSize(framebuffer.Width(), framebuffer.Height());
+
+    if (m_width == 0 || m_height == 0)
+    {
+        return;
+    }
+
+    m_framebuffer.Bind(0);
+
+    // Draw from unflipped texture
+    originalTexture->Bind(0);
+
+    Copy(flipVertical, flipHorizontal);
+
+    // Swap texture attachments
+    auto tempAttachment = framebuffer.GetAttachment(framebufferIndex, TextureAttachment::AttachmentType::Color, 0);
+    framebuffer.RemoveColorAttachment(framebufferIndex, 0);
+    framebuffer.SetAttachment(framebufferIndex, 0, m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0));
+    m_framebuffer.RemoveColorAttachment(0, 0);
+    m_framebuffer.SetAttachment(0, 0, tempAttachment);
+
+    Framebuffer::Unbind();
+}
+
+auto OpenGLCopyTexture::Texture() -> std::shared_ptr<class Texture>
+{
+    return m_framebuffer.GetColorAttachmentTexture(0, 0);
+}
+
+void OpenGLCopyTexture::UpdateTextureSize(int width, int height)
+{
+    if (m_width == width &&
+        m_height == height)
+    {
+        return;
+    }
+
+    m_width = width;
+    m_height = height;
+
+    m_framebuffer.SetSize(m_width, m_height);
+}
+
+void OpenGLCopyTexture::Copy(bool flipVertical, bool flipHorizontal) const
+{
+    m_shader.Bind();
+    m_shader.SetUniformInt("texture_sampler", 0);
+    m_shader.SetUniformInt2("flip", {flipHorizontal ? 1 : 0, flipVertical ? 1 : 0});
+
+    m_sampler.Bind(0);
+
+    glBindVertexArray(m_vaoID);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    glBindVertexArray(0);
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+    Sampler::Unbind(0);
+    Shader::Unbind();
+}
+
+} // namespace OpenGL
+} // namespace Backend
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Backend/OpenGL/OpenGLCopyTexture.hpp b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLCopyTexture.hpp
new file mode 100644
index 0000000000..97874626d4
--- /dev/null
+++ b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLCopyTexture.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <Renderer/CopyTexture.hpp>
+#include <Renderer/Framebuffer.hpp>
+#include <Renderer/Shader.hpp>
+#include "Renderer/Backend/OpenGL/OpenGLRenderItem.hpp"
+
+namespace libprojectM {
+namespace Renderer {
+namespace Backend {
+namespace OpenGL {
+
+class OpenGLCopyTexture : public CopyTexture, public OpenGLRenderItem
+{
+public:
+    OpenGLCopyTexture();
+    ~OpenGLCopyTexture() = default;
+
+    // Mark override for clarity and to avoid hiding warnings
+    void InitVertexAttrib() override;
+
+    // Mark override for clarity and to avoid hiding warnings
+    void Init() override
+    {
+        // Call both base class Init() to ensure proper initialization
+        OpenGLRenderItem::Init();
+        CopyTexture::Init();
+    }
+
+    using OpenGLRenderItem::Init; // Unhide base Init() to avoid -Woverloaded-virtual warning
+
+    void Draw(const std::shared_ptr<class Texture>& originalTexture,
+              bool flipVertical = false, bool flipHorizontal = false) override;
+
+    void Draw(const std::shared_ptr<class Texture>& originalTexture, const std::shared_ptr<class Texture>& targetTexture,
+              bool flipVertical = false, bool flipHorizontal = false) override;
+
+    void Draw(const std::shared_ptr<class Texture>& originalTexture, Framebuffer& framebuffer, int framebufferIndex,
+              bool flipVertical = false, bool flipHorizontal = false) override;
+
+    std::shared_ptr<class Texture> Texture() override;
+
+private:
+    void UpdateTextureSize(int width, int height);
+    void Copy(bool flipVertical, bool flipHorizontal) const;
+
+    Shader m_shader;
+    Framebuffer m_framebuffer{1};
+    Sampler m_sampler{GL_CLAMP_TO_EDGE, GL_NEAREST};
+
+    int m_width{};
+    int m_height{};
+};
+
+} // namespace OpenGL
+} // namespace Backend
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Backend/OpenGL/OpenGLPresetTransition.cpp b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLPresetTransition.cpp
new file mode 100644
index 0000000000..d4b357df30
--- /dev/null
+++ b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLPresetTransition.cpp
@@ -0,0 +1,121 @@
+#include "OpenGLPresetTransition.hpp"
+
+namespace libprojectM {
+namespace Renderer {
+namespace Backend {
+namespace OpenGL {
+
+OpenGLPresetTransition::OpenGLPresetTransition(const std::shared_ptr<Shader>& transitionShader,
+                                               double durationSeconds,
+                                               double transitionStartTime)
+    : PresetTransition(transitionShader, durationSeconds, transitionStartTime)
+{
+    Init();
+}
+
+void OpenGLPresetTransition::InitVertexAttrib()
+{
+    static const std::array<RenderItem::Point, 4> points{{{-1.0f, 1.0f},
+                                                          {1.0f, 1.0f},
+                                                          {-1.0f, -1.0f},
+                                                          {1.0f, -1.0f}}};
+
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(Point), reinterpret_cast<void*>(offsetof(Point, x))); // Position
+    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points.data(), GL_STATIC_DRAW);
+}
+
+void OpenGLPresetTransition::Draw(const Preset& oldPreset,
+                                  const Preset& newPreset,
+                                  const RenderContext& context,
+                                  const libprojectM::Audio::FrameAudioData& audioData,
+                                  double currentFrameTime)
+{
+    if (m_transitionShader == nullptr)
+    {
+        return;
+    }
+
+    std::mt19937 rand32(m_randomDevice);
+
+    constexpr double PI = 3.14159265358979323846;
+    const auto secondsSinceStart = currentFrameTime - m_transitionStartTime;
+
+    double linearProgress{1.0};
+    double cosineProgress{1.0};
+    double bicubicProgress{1.0};
+
+    if (m_durationSeconds > 0.0)
+    {
+        linearProgress = secondsSinceStart / m_durationSeconds;
+        cosineProgress = (-std::cos(linearProgress * PI) + 1.0) * 0.5;
+        bicubicProgress = linearProgress < 0.5 ? 4.0 * linearProgress * linearProgress * linearProgress : 1.0 - pow(-2.0 * linearProgress + 2.0, 3.0) / 2.0;
+    }
+
+    m_transitionShader->Bind();
+
+    m_transitionShader->SetUniformFloat3("iResolution", {static_cast<float>(context.viewportSizeX),
+                                                         static_cast<float>(context.viewportSizeY),
+                                                         0.0f});
+
+    m_transitionShader->SetUniformFloat4("durationParams", {linearProgress,
+                                                            cosineProgress,
+                                                            bicubicProgress,
+                                                            m_durationSeconds});
+
+    m_transitionShader->SetUniformFloat2("timeParams", {secondsSinceStart,
+                                                        currentFrameTime - m_lastFrameTime});
+
+    m_transitionShader->SetUniformInt4("iRandStatic", m_staticRandomValues);
+
+    m_transitionShader->SetUniformInt4("iRandFrame", {rand32(),
+                                                      rand32(),
+                                                      rand32(),
+                                                      rand32()});
+
+    m_transitionShader->SetUniformFloat3("iBeatValues", {audioData.bass,
+                                                         audioData.mid,
+                                                         audioData.treb});
+
+    m_transitionShader->SetUniformFloat3("iBeatAttValues", {audioData.bassAtt,
+                                                            audioData.midAtt,
+                                                            audioData.trebAtt});
+
+    m_transitionShader->SetUniformInt("iChannel0", 0);
+    oldPreset.OutputTexture()->Bind(0, m_presetSampler);
+    m_transitionShader->SetUniformInt("iChannel1", 1);
+    newPreset.OutputTexture()->Bind(1, m_presetSampler);
+
+    int textureUnit = 2;
+    std::vector<Renderer::TextureSamplerDescriptor> noiseDescriptors(m_noiseTextureNames.size());
+    for (const auto& noiseTextureName : m_noiseTextureNames)
+    {
+        noiseDescriptors[textureUnit - 2] = context.textureManager->GetTexture(noiseTextureName);
+        noiseDescriptors[textureUnit - 2].Bind(textureUnit, *m_transitionShader);
+        textureUnit++;
+    }
+
+    // Render the transition quad
+    InitVertexAttrib();
+    glBindVertexArray(m_vaoID);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    glBindVertexArray(0);
+
+    // Clean up
+    oldPreset.OutputTexture()->Unbind(0);
+    newPreset.OutputTexture()->Unbind(1);
+
+    for (int i = 2; i < textureUnit; i++)
+    {
+        noiseDescriptors[i - 2].Unbind(textureUnit);
+    }
+
+    Renderer::Shader::Unbind();
+
+    m_lastFrameTime = currentFrameTime;
+}
+
+} // namespace OpenGL
+} // namespace Backend
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Backend/OpenGL/OpenGLPresetTransition.hpp b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLPresetTransition.hpp
new file mode 100644
index 0000000000..360c19b6f1
--- /dev/null
+++ b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLPresetTransition.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <Renderer/PresetTransition.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
+
+namespace libprojectM {
+namespace Renderer {
+namespace Backend {
+namespace OpenGL {
+
+/**
+ * @brief OpenGL backend implementation of PresetTransition.
+ */
+class OpenGLPresetTransition : public PresetTransition, public OpenGLRenderItem
+{
+public:
+    OpenGLPresetTransition(const std::shared_ptr<Shader>& transitionShader,
+                           double durationSeconds,
+                           double transitionStartTime);
+
+    // Mark override for clarity and to avoid hiding warnings
+    void InitVertexAttrib() override;
+
+    // Mark override for clarity and to avoid hiding warnings
+    void Init() override
+    {
+        // Call both base class Init() to ensure proper initialization
+        OpenGLRenderItem::Init();
+        PresetTransition::Init();
+    }
+
+    using OpenGLRenderItem::Init; // Unhide base Init() to avoid -Woverloaded-virtual warning
+
+    void Draw(const Preset& oldPreset,
+              const Preset& newPreset,
+              const RenderContext& context,
+              const libprojectM::Audio::FrameAudioData& audioData,
+              double currentFrameTime);
+
+private:
+    // Any OpenGL-specific members if needed
+};
+
+} // namespace OpenGL
+} // namespace Backend
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Backend/OpenGL/OpenGLRenderItem.cpp b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLRenderItem.cpp
new file mode 100644
index 0000000000..79bd998110
--- /dev/null
+++ b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLRenderItem.cpp
@@ -0,0 +1,33 @@
+#include "OpenGLRenderItem.hpp"
+
+namespace libprojectM {
+namespace Renderer {
+namespace Backend {
+namespace OpenGL {
+
+OpenGLRenderItem::OpenGLRenderItem() = default;
+
+OpenGLRenderItem::~OpenGLRenderItem()
+{
+    glDeleteBuffers(1, &m_vboID);
+    glDeleteVertexArrays(1, &m_vaoID);
+}
+
+void OpenGLRenderItem::Init()
+{
+    glGenVertexArrays(1, &m_vaoID);
+    glGenBuffers(1, &m_vboID);
+
+    glBindVertexArray(m_vaoID);
+    glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+
+    InitVertexAttrib();
+
+    glBindVertexArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+} // namespace OpenGL
+} // namespace Backend
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/Backend/OpenGL/OpenGLRenderItem.hpp b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLRenderItem.hpp
new file mode 100644
index 0000000000..0166100510
--- /dev/null
+++ b/src/libprojectM/Renderer/Backend/OpenGL/OpenGLRenderItem.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "Renderer/RenderItem.hpp"
+#include <projectM-opengl.h>
+
+#ifdef PROJECTM_USERSPRITES_DEBUG
+#pragma message("DEBUG: Including OpenGLRenderItem.hpp")
+#endif
+
+namespace libprojectM {
+namespace Renderer {
+namespace Backend {
+namespace OpenGL {
+
+class OpenGLRenderItem : public ::libprojectM::Renderer::RenderItem
+{
+public:
+    OpenGLRenderItem();
+    virtual ~OpenGLRenderItem();
+
+    // Mark override for clarity and to avoid hiding warnings
+    void InitVertexAttrib() override;
+
+    // Mark override for clarity and to avoid hiding warnings
+    void Init() override;
+
+protected:
+    // Unhide base Init() to avoid -Woverloaded-virtual warning and allow calling base from derived
+    using ::libprojectM::Renderer::RenderItem::Init;
+    GLuint m_vboID{0};
+    GLuint m_vaoID{0};
+};
+
+} // namespace OpenGL
+} // namespace Backend
+} // namespace Renderer
+} // namespace libprojectM
diff --git a/src/libprojectM/Renderer/CopyTexture.cpp b/src/libprojectM/Renderer/CopyTexture.cpp
index 14b36c977e..f8e1ab7bdf 100644
--- a/src/libprojectM/Renderer/CopyTexture.cpp
+++ b/src/libprojectM/Renderer/CopyTexture.cpp
@@ -1,331 +1,9 @@
-#include "Renderer/CopyTexture.hpp"
+#include "CopyTexture.hpp"
+
+// Implementation moved to Backend/OpenGL/OpenGLCopyTexture.cpp
 
 namespace libprojectM {
 namespace Renderer {
 
-#ifdef USE_GLES
-static constexpr char ShaderVersion[] = "#version 300 es\n\n";
-#else
-static constexpr char ShaderVersion[] = "#version 330\n\n";
-#endif
-
-static constexpr char CopyTextureVertexShader[] = R"(
-precision mediump float;
-
-layout(location = 0) in vec2 position;
-layout(location = 2) in vec2 tex_coord;
-
-out vec2 fragment_tex_coord;
-
-uniform mat4 vertex_transformation;
-
-void main() {
-    gl_Position = vec4(position, 0.0, 1.0) * vertex_transformation;
-    fragment_tex_coord = tex_coord;
-}
-)";
-
-static constexpr char CopyTextureFragmentShader[] = R"(
-precision mediump float;
-
-in vec2 fragment_tex_coord;
-
-uniform sampler2D texture_sampler;
-
-out vec4 color;
-
-void main(){
-    color = texture(texture_sampler, fragment_tex_coord);
-}
-
-)";
-
-CopyTexture::CopyTexture()
-    : m_mesh(VertexBufferUsage::StaticDraw, false, true)
-{
-    m_framebuffer.CreateColorAttachment(0, 0);
-
-    m_mesh.SetRenderPrimitiveType(Mesh::PrimitiveType::TriangleStrip);
-
-    m_mesh.SetVertexCount(4);
-    m_mesh.Vertices().Set({{-1.0, 1.0},
-                           {1.0, 1.0},
-                           {-1.0, -1.0},
-                           {1.0, -1.0}});
-
-    m_mesh.UVs().Set({{0.0, 1.0},
-                      {1.0, 1.0},
-                      {0.0, 0.0},
-                      {1.0, 0.0}});
-
-    m_mesh.Indices().Set({0, 1, 2, 3});
-
-    m_mesh.Update();
-}
-
-void CopyTexture::Draw(ShaderCache& shaderCache,
-                       const std::shared_ptr<class Texture>& originalTexture,
-                       bool flipVertical, bool flipHorizontal)
-{
-    if (originalTexture == nullptr)
-    {
-        return;
-    }
-
-    // Just bind the texture and draw it to the currently bound buffer.
-    originalTexture->Bind(0);
-    Copy(shaderCache, flipVertical, flipHorizontal);
-}
-
-void CopyTexture::Draw(ShaderCache& shaderCache,
-                       const std::shared_ptr<class Texture>& originalTexture,
-                       const std::shared_ptr<class Texture>& targetTexture,
-                       bool flipVertical, bool flipHorizontal)
-{
-    if (originalTexture == nullptr ||
-        originalTexture->Empty() ||
-        (targetTexture != nullptr && targetTexture->Empty()) ||
-        originalTexture == targetTexture)
-    {
-        return;
-    }
-
-    if (targetTexture == nullptr)
-    {
-        UpdateTextureSize(originalTexture->Width(), originalTexture->Height());
-    }
-    else
-    {
-        UpdateTextureSize(targetTexture->Width(), targetTexture->Height());
-    }
-
-    if (m_width == 0 || m_height == 0)
-    {
-        return;
-    }
-
-    std::shared_ptr<class Texture> internalTexture;
-
-    m_framebuffer.Bind(0);
-
-    // Draw from unflipped texture
-    originalTexture->Bind(0);
-
-    if (targetTexture)
-    {
-        internalTexture = m_framebuffer.GetColorAttachmentTexture(0, 0);
-        m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0)->Texture(targetTexture);
-    }
-
-    Copy(shaderCache, flipVertical, flipHorizontal);
-
-    // Rebind our internal texture.
-    if (targetTexture)
-    {
-        m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0)->Texture(internalTexture);
-    }
-
-    Framebuffer::Unbind();
-}
-
-void CopyTexture::Draw(ShaderCache& shaderCache,
-                       const std::shared_ptr<class Texture>& originalTexture,
-                       Framebuffer& framebuffer, int framebufferIndex,
-                       bool flipVertical, bool flipHorizontal)
-{
-    if (originalTexture == nullptr                                               //
-        || originalTexture->Empty()                                              //
-        || framebuffer.GetColorAttachmentTexture(framebufferIndex, 0) == nullptr //
-        || framebuffer.GetColorAttachmentTexture(framebufferIndex, 0)->Empty())
-    {
-        return;
-    }
-
-    UpdateTextureSize(framebuffer.Width(), framebuffer.Height());
-
-    if (m_width == 0 || m_height == 0)
-    {
-        return;
-    }
-
-    m_framebuffer.Bind(0);
-
-    // Draw from unflipped texture
-    originalTexture->Bind(0);
-
-    Copy(shaderCache, flipVertical, flipHorizontal);
-
-    // Swap texture attachments
-    auto tempAttachment = framebuffer.GetAttachment(framebufferIndex, TextureAttachment::AttachmentType::Color, 0);
-    framebuffer.RemoveColorAttachment(framebufferIndex, 0);
-    framebuffer.SetAttachment(framebufferIndex, 0, m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0));
-    m_framebuffer.RemoveColorAttachment(0, 0);
-    m_framebuffer.SetAttachment(0, 0, tempAttachment);
-
-    Framebuffer::Unbind();
-}
-
-void CopyTexture::Draw(ShaderCache& shaderCache,
-                       const std::shared_ptr<struct Texture>& originalTexture,
-                       const std::shared_ptr<struct Texture>& targetTexture,
-                       int left, int top, int width, int height)
-{
-    if (originalTexture == nullptr ||
-        originalTexture->Empty() ||
-        targetTexture == nullptr ||
-        targetTexture->Empty() ||
-        originalTexture == targetTexture)
-    {
-        return;
-    }
-
-    UpdateTextureSize(targetTexture->Width(), targetTexture->Height());
-
-    if (m_width == 0 || m_height == 0)
-    {
-        return;
-    }
-
-    std::shared_ptr<class Texture> internalTexture;
-
-    m_framebuffer.Bind(0);
-
-    // Draw from original texture
-    originalTexture->Bind(0);
-    internalTexture = m_framebuffer.GetColorAttachmentTexture(0, 0);
-    m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0)->Texture(targetTexture);
-
-    Copy(shaderCache, left, top, width, height);
-
-    // Rebind our internal texture.
-    m_framebuffer.GetAttachment(0, TextureAttachment::AttachmentType::Color, 0)->Texture(internalTexture);
-
-    Framebuffer::Unbind();
-}
-
-void CopyTexture::Draw(ShaderCache& shaderCache,
-                       GLuint originalTexture,
-                       int viewportWidth, int viewportHeight,
-                       int left, int top, int width, int height)
-{
-    if (originalTexture == 0)
-    {
-        return;
-    }
-
-    if (viewportWidth == 0 || viewportHeight == 0)
-    {
-        return;
-    }
-
-    int oldWidth = m_width;
-    int oldHeight = m_height;
-
-    m_width = viewportWidth;
-    m_height = viewportHeight;
-
-    // Draw from original texture
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, originalTexture);
-    Copy(shaderCache, left, top, width, height);
-
-    m_width = oldWidth;
-    m_height = oldHeight;
-}
-
-auto CopyTexture::Texture() -> std::shared_ptr<class Texture>
-{
-    return m_framebuffer.GetColorAttachmentTexture(0, 0);
-}
-
-void CopyTexture::UpdateTextureSize(int width, int height)
-{
-    if (m_width == width &&
-        m_height == height)
-    {
-        return;
-    }
-
-    m_width = width;
-    m_height = height;
-
-    m_framebuffer.SetSize(m_width, m_height);
-}
-
-void CopyTexture::Copy(ShaderCache& shaderCache,
-                       bool flipVertical, bool flipHorizontal)
-{
-    glm::mat4x4 flipMatrix(1.0);
-
-    flipMatrix[0][0] = flipHorizontal ? -1.0 : 1.0;
-    flipMatrix[1][1] = flipVertical ? -1.0 : 1.0;
-
-    std::shared_ptr<Shader> shader = BindShader(shaderCache);
-
-    shader->SetUniformInt("texture_sampler", 0);
-    shader->SetUniformMat4x4("vertex_transformation", flipMatrix);
-
-    m_sampler.Bind(0);
-
-    m_mesh.Draw();
-
-    glBindTexture(GL_TEXTURE_2D, 0);
-    Mesh::Unbind();
-    Sampler::Unbind(0);
-    Shader::Unbind();
-}
-
-void CopyTexture::Copy(ShaderCache& shaderCache,
-                       int left, int top, int width, int height)
-{
-    glm::mat4x4 translationMatrix(1.0);
-    translationMatrix[0][0] = static_cast<float>(width) / static_cast<float>(m_width);
-    translationMatrix[1][1] = static_cast<float>(height) / static_cast<float>(m_height);
-
-    translationMatrix[3][0] = static_cast<float>(left) / static_cast<float>(m_width);
-    translationMatrix[3][1] = static_cast<float>(top) / static_cast<float>(m_height);
-
-    std::shared_ptr<Shader> shader = BindShader(shaderCache);
-
-    shader->SetUniformInt("texture_sampler", 0);
-    shader->SetUniformMat4x4("vertex_transformation", translationMatrix);
-
-    m_sampler.Bind(0);
-
-    m_mesh.Draw();
-
-    Mesh::Unbind();
-    Sampler::Unbind(0);
-    Shader::Unbind();
-}
-
-std::shared_ptr<Shader> CopyTexture::BindShader(ShaderCache& shaderCache)
-{
-    auto shader = m_shader.lock();
-
-    if (!shader)
-    {
-        shader = shaderCache.Get("copy_texture");
-    }
-
-    if (!shader)
-    {
-        std::string vertexShader(ShaderVersion);
-        std::string fragmentShader(ShaderVersion);
-        vertexShader.append(CopyTextureVertexShader);
-        fragmentShader.append(CopyTextureFragmentShader);
-
-        shader = std::make_shared<Shader>();
-        shader->CompileProgram(vertexShader, fragmentShader);
-
-        m_shader = shader;
-        shaderCache.Insert("copy_texture", shader);
-    }
-
-    shader->Bind();
-
-    return shader;
-}
-
 } // namespace Renderer
 } // namespace libprojectM
diff --git a/src/libprojectM/Renderer/CopyTexture.hpp b/src/libprojectM/Renderer/CopyTexture.hpp
index 154324f522..805e006cc2 100644
--- a/src/libprojectM/Renderer/CopyTexture.hpp
+++ b/src/libprojectM/Renderer/CopyTexture.hpp
@@ -16,107 +16,18 @@ namespace Renderer {
 class CopyTexture
 {
 public:
-    CopyTexture();
+    virtual ~CopyTexture() = default;
 
-    /**
-     * @brief Copies the original texture into the currently bound framebuffer.
-     * @param shaderCache The global shader cache instance.
-     * @param originalTexture The texture to be copied.
-     * @param flipVertical Flip image on the y-axis when copying.
-     * @param flipHorizontal Flip image on the x-axis when copying.
-     */
-    void Draw(ShaderCache& shaderCache,
-              const std::shared_ptr<Texture>& originalTexture,
-              bool flipVertical = false, bool flipHorizontal = false);
+    virtual void Draw(const std::shared_ptr<class Texture>& originalTexture,
+                     bool flipVertical = false, bool flipHorizontal = false) = 0;
 
-    /**
-     * @brief Copies the original texture either into the object's internal framebuffer or a given target texture.
-     * The original and target textures must not be the same.
-     * @param shaderCache The global shader cache instance.
-     * @param originalTexture The texture to be copied.
-     * @param targetTexture Optional target texture to draw onto.
-     * @param flipVertical Flip image on the y-axis when copying.
-     * @param flipHorizontal Flip image on the x-axis when copying.
-     */
-    void Draw(ShaderCache& shaderCache,
-              const std::shared_ptr<Texture>& originalTexture,
-              const std::shared_ptr<Texture>& targetTexture = {},
-              bool flipVertical = false, bool flipHorizontal = false);
+    virtual void Draw(const std::shared_ptr<class Texture>& originalTexture, const std::shared_ptr<class Texture>& targetTexture,
+                     bool flipVertical = false, bool flipHorizontal = false) = 0;
 
-    /**
-     * @brief Copies the texture bound the given framebuffer's first color attachment.
-     * This is done by drawing into a second framebuffer, then swapping the textures, so the original texture
-     * can be the current color attachment of targetFramebuffer.
-     * @param shaderCache The global shader cache instance.
-     * @param originalTexture The texture to be copied.
-     * @param targetFramebuffer Optional target texture to draw onto.
-     * @param framebufferIndex The index of the framebuffer to use.
-     * @param flipVertical Flip image on the y-axis when copying.
-     * @param flipHorizontal Flip image on the x-axis when copying.
-     */
-    void Draw(ShaderCache& shaderCache,
-              const std::shared_ptr<Texture>& originalTexture,
-              Framebuffer& framebuffer, int framebufferIndex,
-              bool flipVertical = false, bool flipHorizontal = false);
+    virtual void Draw(const std::shared_ptr<class Texture>& originalTexture, Framebuffer& framebuffer, int framebufferIndex,
+                     bool flipVertical = false, bool flipHorizontal = false) = 0;
 
-    /**
-     * @brief Draws the original texture onto the specified target texture, using the provided screen coordinates to position it.
-     * @param shaderCache The global shader cache instance.
-     * @param originalTexture The texture to be copied.
-     * @param targetTexture The target texture to draw onto.
-     * @param left Left offset on the target texture in screen coordinates.
-     * @param top Top offset on the target texture in screen coordinates.
-     * @param width Width on the target texture in screen coordinates. Use a negative value to flip vertically.
-     * @param height Height on the target texture in screen coordinates. Use a negative value to flip horizontally.
-     */
-    void Draw(ShaderCache& shaderCache,
-              const std::shared_ptr<Texture>& originalTexture,
-              const std::shared_ptr<Texture>& targetTexture,
-              int left, int top, int width, int height);
-
-    /**
-     * @brief Draws a raw GL texture into the currently bound framebuffer, using the provided screen coordinates to position it.
-     * @param shaderCache The global shader cache instance.
-     * @param originalTexture The texture ID to be copied.
-     * @param viewportWidth The target surface width.
-     * @param viewportHeight The target surface height.
-     * @param left Left offset on the target texture in screen coordinates.
-     * @param top Top offset on the target texture in screen coordinates.
-     * @param width Width on the target texture in screen coordinates. Use a negative value to flip vertically.
-     * @param height Height on the target texture in screen coordinates. Use a negative value to flip horizontally.
-     */
-    void Draw(ShaderCache& shaderCache,
-              GLuint originalTexture,
-              int viewportWidth, int viewportHeight,
-              int left, int top, int width, int height);
-
-    /**
-     * @brief Returns the flipped texture.
-     *
-     * @return The flipped texture.
-     */
-    auto Texture() -> std::shared_ptr<Texture>;
-
-private:
-    /**
-     * Updates the mesh
-     */
-    void UpdateTextureSize(int width, int height);
-
-    void Copy(ShaderCache& shaderCache,
-              bool flipVertical, bool flipHorizontal);
-
-    void Copy(ShaderCache& shaderCache,
-              int left, int top, int width, int height);
-
-    Mesh m_mesh;
-    std::weak_ptr<Shader> m_shader;                  //!< Simple textured shader
-    Framebuffer m_framebuffer{1};                    //!< Framebuffer for drawing the flipped texture
-    Sampler m_sampler{GL_CLAMP_TO_EDGE, GL_NEAREST}; //!< Texture sampler settings
-
-    int m_width{};  //!< Last known framebuffer/texture width
-    int m_height{}; //!< Last known framebuffer/texture height
-    std::shared_ptr<Shader> BindShader(ShaderCache& shaderCache);
+    virtual auto Texture() -> std::shared_ptr<class Texture> = 0;
 };
 
 } // namespace Renderer
diff --git a/src/libprojectM/Renderer/PresetTransition.cpp b/src/libprojectM/Renderer/PresetTransition.cpp
index e7060861ea..b5eb831ed5 100644
--- a/src/libprojectM/Renderer/PresetTransition.cpp
+++ b/src/libprojectM/Renderer/PresetTransition.cpp
@@ -48,90 +48,7 @@ void PresetTransition::Draw(const Preset& oldPreset,
                             const libprojectM::Audio::FrameAudioData& audioData,
                             double currentFrameTime)
 {
-    if (m_transitionShader == nullptr)
-    {
-        return;
-    }
-
-    std::mt19937 rand32(m_randomDevice());
-
-    // Calculate progress values
-    const auto secondsSinceStart = currentFrameTime - m_transitionStartTime;
-
-    // If duration is zero,
-    double linearProgress{1.0};
-    double cosineProgress{1.0};
-    double bicubicProgress{1.0};
-
-    if (m_durationSeconds > 0.0)
-    {
-        linearProgress = secondsSinceStart / m_durationSeconds;
-        cosineProgress = (-std::cos(linearProgress * PI) + 1.0) * 0.5;
-        bicubicProgress = linearProgress < 0.5 ? 4.0 * linearProgress * linearProgress * linearProgress : 1.0 - pow(-2.0 * linearProgress + 2.0, 3.0) / 2.0;
-    }
-
-    m_transitionShader->Bind();
-
-    // Numerical parameters
-    m_transitionShader->SetUniformFloat3("iResolution", {static_cast<float>(context.viewportSizeX),
-                                                         static_cast<float>(context.viewportSizeY),
-                                                         0.0f});
-
-    m_transitionShader->SetUniformFloat4("durationParams", {linearProgress,
-                                                            cosineProgress,
-                                                            bicubicProgress,
-                                                            m_durationSeconds});
-
-    m_transitionShader->SetUniformFloat2("timeParams", {secondsSinceStart,
-                                                        currentFrameTime - m_lastFrameTime});
-
-    m_transitionShader->SetUniformInt4("iRandStatic", m_staticRandomValues);
-
-    m_transitionShader->SetUniformInt4("iRandFrame", {rand32(),
-                                                      rand32(),
-                                                      rand32(),
-                                                      rand32()});
-
-    m_transitionShader->SetUniformFloat3("iBeatValues", {audioData.bass,
-                                                         audioData.mid,
-                                                         audioData.treb});
-
-    m_transitionShader->SetUniformFloat3("iBeatAttValues", {audioData.bassAtt,
-                                                            audioData.midAtt,
-                                                            audioData.trebAtt});
-
-    // Texture samplers
-    m_transitionShader->SetUniformInt("iChannel0", 0);
-    oldPreset.OutputTexture()->Bind(0, m_presetSampler);
-    m_transitionShader->SetUniformInt("iChannel1", 1);
-    newPreset.OutputTexture()->Bind(1, m_presetSampler);
-
-    int textureUnit = 2;
-    std::vector<TextureSamplerDescriptor> noiseDescriptors(m_noiseTextureNames.size());
-    for (const auto& noiseTextureName : m_noiseTextureNames)
-    {
-        noiseDescriptors[textureUnit - 2] = context.textureManager->GetTexture(noiseTextureName);
-        noiseDescriptors[textureUnit - 2].Bind(textureUnit, *m_transitionShader);
-        textureUnit++;
-    }
-
-    // Render the transition quad
-    m_mesh.Draw();
-
-    // Clean up
-    oldPreset.OutputTexture()->Unbind(0);
-    newPreset.OutputTexture()->Unbind(1);
-
-    for (int i = 2; i < textureUnit; i++)
-    {
-        noiseDescriptors[i - 2].Unbind(textureUnit);
-    }
-
-    Mesh::Unbind();
-    Shader::Unbind();
-
-    // Update last frame time.
-    m_lastFrameTime = currentFrameTime;
+    // This method is now a stub; OpenGL-specific rendering is in the backend implementation.
 }
 
 } // namespace Renderer
diff --git a/src/libprojectM/Renderer/PresetTransition.hpp b/src/libprojectM/Renderer/PresetTransition.hpp
index 1822811a74..16467c2a6a 100644
--- a/src/libprojectM/Renderer/PresetTransition.hpp
+++ b/src/libprojectM/Renderer/PresetTransition.hpp
@@ -20,45 +20,22 @@ class PresetTransition
 public:
     PresetTransition() = delete;
 
-    /**
-     * Constructor.
-     * @param transitionShader The transition shader program.
-     * @param durationSeconds Transition duration in seconds.
-     * @param transitionStartTime The time in seconds since start of projectM.
-     */
     explicit PresetTransition(const std::shared_ptr<Shader>& transitionShader,
                               double durationSeconds,
                               double transitionStartTime);
 
-    /**
-     * @brief Returns true if the transition is done.
-     * @param currentFrameTime The time in seconds since start of the current frame.
-     * @return false if the transition is still in progress, true if it's done.
-     */
-    auto IsDone(double currentFrameTime) const -> bool;
+    virtual ~PresetTransition() = default;
 
-    /**
-     * @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 IsDone(double currentFrameTime) const -> bool;
     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.
-     * @param newPreset A reference to the new (fading in) preset.
-     * @param context The rendering context used to render the presets.
-     * @param audioData Current audio data and beat detection values.
-     * @param currentFrameTime The time in seconds since start of the current frame.
-     */
-    void Draw(const Preset& oldPreset,
-              const Preset& newPreset,
-              const RenderContext& context,
-              const Audio::FrameAudioData& audioData,
-              double currentFrameTime);
-
-private:
+    virtual void Draw(const Preset& oldPreset,
+                     const Preset& newPreset,
+                     const RenderContext& context,
+                     const libprojectM::Audio::FrameAudioData& audioData,
+                     double currentFrameTime);
+
+protected:
     std::vector<std::string> m_noiseTextureNames{"noise_lq",
                                                  "pw_noise_lq",
                                                  "noise_mq",
@@ -68,19 +45,18 @@ class PresetTransition
                                                  "noisevol_lq",
                                                  "pw_noisevol_lq",
                                                  "noisevol_hq",
-                                                 "pw_noisevol_hq"}; //!< Names of noise textures to retrieve from TextureManager.
+                                                 "pw_noisevol_hq"};
 
-    Mesh m_mesh;                                                                                      //!< The mesh used to draw the transition effect.
-    std::shared_ptr<Shader> m_transitionShader;                                                       //!< The compiled shader used for this transition.
-    std::shared_ptr<Sampler> m_presetSampler{std::make_shared<Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR)}; //!< Sampler for preset textures. Uses bilinear interpolation and no repeat.
+    std::shared_ptr<Shader> m_transitionShader;
+    std::shared_ptr<Sampler> m_presetSampler{std::make_shared<Sampler>(GL_CLAMP_TO_EDGE, GL_LINEAR)};
 
-    double m_durationSeconds{3.0};  //!< Transition duration in seconds.
-    double m_transitionStartTime{}; //!< Start time of this transition. Duration is measured from this point.
-    double m_lastFrameTime{};       //!< Time when the previous frame was rendered.
+    double m_durationSeconds{3.0};
+    double m_transitionStartTime{};
+    double m_lastFrameTime{};
 
-    glm::ivec4 m_staticRandomValues{}; //!< Four random integers, remaining static during the whole transition.
+    glm::ivec4 m_staticRandomValues{};
 
-    std::random_device m_randomDevice; //!< Seed for the random number generator
+    std::random_device m_randomDevice;
 };
 
 } // namespace Renderer
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.cpp b/src/libprojectM/UserSprites/MilkdropSprite.cpp
index 7a8af5cb9e..c4180c84cc 100644
--- a/src/libprojectM/UserSprites/MilkdropSprite.cpp
+++ b/src/libprojectM/UserSprites/MilkdropSprite.cpp
@@ -30,8 +30,18 @@ namespace UserSprites {
 MilkdropSprite::MilkdropSprite()
     : m_mesh(Renderer::VertexBufferUsage::DynamicDraw, false, true)
 {
-    m_mesh.SetRenderPrimitiveType(Renderer::Mesh::PrimitiveType::TriangleStrip);
-    m_mesh.SetVertexCount(4);
+    // Do not call Init() here; OpenGLRenderItem::Init() will be called by the rendering system when needed.
+}
+
+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)
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.hpp b/src/libprojectM/UserSprites/MilkdropSprite.hpp
index d19139012b..b87011b9d6 100644
--- a/src/libprojectM/UserSprites/MilkdropSprite.hpp
+++ b/src/libprojectM/UserSprites/MilkdropSprite.hpp
@@ -11,7 +11,9 @@
 namespace libprojectM {
 namespace UserSprites {
 
-class MilkdropSprite : public Sprite
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
+
+class MilkdropSprite : public Sprite, public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     MilkdropSprite();