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 2cebe2a541..7f96cb77d4 100644
--- a/src/libprojectM/MilkdropPreset/Border.cpp
+++ b/src/libprojectM/MilkdropPreset/Border.cpp
@@ -4,10 +4,9 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 Border::Border(PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
 {
-    RenderItem::Init();
+    Init();
 }
 
 void Border::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/Border.hpp b/src/libprojectM/MilkdropPreset/Border.hpp
index 8b258f6d08..fa831ec89b 100644
--- a/src/libprojectM/MilkdropPreset/Border.hpp
+++ b/src/libprojectM/MilkdropPreset/Border.hpp
@@ -3,16 +3,15 @@
 #include "PerFrameContext.hpp"
 #include "PresetState.hpp"
 
-#include "Renderer/RenderItem.hpp"
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
 
-
 /**
  * @brief Renders a border around the screen.
  */
-class Border : public Renderer::RenderItem
+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 9eaef3784c..a2c72a77f9 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.cpp
@@ -3,7 +3,7 @@
 #include "PresetFileParser.hpp"
 
 #include <Renderer/TextureManager.hpp>
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <vector>
 
@@ -47,7 +47,7 @@ CustomShape::CustomShape(PresetState& presetState)
 
     glBufferData(GL_ARRAY_BUFFER, sizeof(TexturedPoint) * vertexData.size(), vertexData.data(), GL_STREAM_DRAW);
 
-    RenderItem::Init();
+    Init();
 
     m_perFrameContext.RegisterBuiltinVariables();
 }
@@ -285,8 +285,8 @@ void CustomShape::Draw()
             glEnable(GL_LINE_SMOOTH);
 #endif
 
-            glBindVertexArray(m_vaoID);
-            glBindBuffer(GL_ARRAY_BUFFER, m_vboID);
+            glBindVertexArray(m_vaoIdUntextured);
+            glBindBuffer(GL_ARRAY_BUFFER, m_vboIdUntextured);
 
             const auto iterations = m_thickOutline ? 4 : 1;
 
diff --git a/src/libprojectM/MilkdropPreset/CustomShape.hpp b/src/libprojectM/MilkdropPreset/CustomShape.hpp
index ea59d34e48..cb8aee445a 100644
--- a/src/libprojectM/MilkdropPreset/CustomShape.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomShape.hpp
@@ -5,7 +5,7 @@
 #include "ShapePerFrameContext.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 : public Renderer::RenderItem
+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 9f046d5335..520e3f9963 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.cpp
@@ -12,12 +12,11 @@ namespace MilkdropPreset {
 static constexpr int CustomWaveformMaxSamples = std::max(libprojectM::Audio::WaveformSamples, libprojectM::Audio::SpectrumSamples);
 
 CustomWaveform::CustomWaveform(PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
     , m_perFrameContext(presetState.globalMemory, &presetState.globalRegisters)
     , m_perPointContext(presetState.globalMemory, &presetState.globalRegisters)
 {
-    RenderItem::Init();
+    Init();
 
     m_perFrameContext.RegisterBuiltinVariables();
     m_perPointContext.RegisterBuiltinVariables();
diff --git a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
index 31d2bfae0c..c22f13e583 100644
--- a/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
+++ b/src/libprojectM/MilkdropPreset/CustomWaveform.hpp
@@ -3,7 +3,7 @@
 #include "WaveformPerFrameContext.hpp"
 #include "WaveformPerPointContext.hpp"
 
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <vector>
 
@@ -13,7 +13,7 @@ class PresetFileParser;
 
 namespace MilkdropPreset {
 
-class CustomWaveform : public Renderer::RenderItem
+class CustomWaveform : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
 
@@ -23,61 +23,21 @@ class CustomWaveform : public Renderer::RenderItem
      */
     explicit CustomWaveform(PresetState& presetState);
 
-    /**
-     * @brief Initializes the waveform's vertex buffer and attribute data.
-     */
     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(::libprojectM::PresetFileParser& parsedFile, int index);
 
-    /**
-     * @brief Compiles all code blocks and runs the init expression.
-     * @throws MilkdropCompileException Thrown if one of the code blocks couldn't be compiled.
-     * @param presetPerFrameContext The per-frame context to retrieve the init Q vars from.
-     */
     void CompileCodeAndRunInitExpressions(const PerFrameContext& presetPerFrameContext);
 
-    /**
-     * @brief Renders the waveform.
-     * @param presetPerFrameContext The per-frame context to retrieve the init Q vars from.
-     */
     void Draw(const PerFrameContext& presetPerFrameContext);
 
 private:
-    /**
-     * @brief Initializes the per-frame context with the preset per-frame state.
-     * @param presetPerFrameContext The preset per-frame context to pull q vars from.
-     */
     void LoadPerFrameEvaluationVariables(const PerFrameContext& presetPerFrameContext);
 
-    /**
-     * @brief Loads the Q and T variables from the per-frame code into the per-point context.
-     */
     void InitPerPointEvaluationVariables();
 
-    /**
-     * @brief Loads the variables for each point into the per-point evaluation context.
-     * @param sample The sample index being rendered.
-     * @param value1 The left channel value.
-     * @param value2 The right channel value.
-     */
     void LoadPerPointEvaluationVariables(float sample, float value1, float value2);
 
-    /**
-     * @brief Does a better-than-linear smooth on a wave.
-     *
-     * Roughly doubles the number of points.
-     *
-     * @param inputVertices Pointer to an array of vertices to be smoothed.
-     * @param vertexCount Number of vertices/points in the input data.
-     * @param outputVertices Pointer to a buffer that will receive the smoothed data. Must be able to hold 2 * vertexCount vertices.
-     * @return The number of vertices in outputVertices after smoothing.
-     */
     static int SmoothWave(const ColoredPoint* inputVertices, int vertexCount, ColoredPoint* outputVertices);
 
     int m_index{0}; //!< Custom waveform index in the preset.
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
index 64899b3242..9c6caa6c2f 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.cpp
@@ -4,10 +4,9 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 DarkenCenter::DarkenCenter(PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
 {
-    RenderItem::Init();
+    Init();
 }
 
 void DarkenCenter::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
index 3f04012f7b..60d7b9dd62 100644
--- a/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
+++ b/src/libprojectM/MilkdropPreset/DarkenCenter.hpp
@@ -2,7 +2,7 @@
 
 #include "PresetState.hpp"
 
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -10,14 +10,14 @@ namespace MilkdropPreset {
 /**
  * @brief Darkens the screen center a bit on each frame.
  */
-class DarkenCenter : public Renderer::RenderItem
+class DarkenCenter : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     DarkenCenter() = delete;
 
     explicit DarkenCenter(PresetState& presetState);
 
-    void InitVertexAttrib();
+    void InitVertexAttrib() override;
 
     /**
      * Applies the darkening area.
diff --git a/src/libprojectM/MilkdropPreset/Filters.cpp b/src/libprojectM/MilkdropPreset/Filters.cpp
index 472a0e70b5..40d6890845 100644
--- a/src/libprojectM/MilkdropPreset/Filters.cpp
+++ b/src/libprojectM/MilkdropPreset/Filters.cpp
@@ -4,10 +4,9 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 Filters::Filters(const PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
 {
-    RenderItem::Init();
+    Init();
 }
 
 void Filters::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/Filters.hpp b/src/libprojectM/MilkdropPreset/Filters.hpp
index c00084654d..875095252a 100644
--- a/src/libprojectM/MilkdropPreset/Filters.hpp
+++ b/src/libprojectM/MilkdropPreset/Filters.hpp
@@ -2,7 +2,7 @@
 
 #include "PresetState.hpp"
 
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -10,13 +10,13 @@ namespace MilkdropPreset {
 /**
  * @brief Classic Milkdrop 1 postprocessing effects.
  */
-class Filters : public Renderer::RenderItem
+class Filters : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     Filters() = delete;
     explicit Filters(const PresetState& presetState);
 
-    void InitVertexAttrib();
+    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 549c950437..0250f5250c 100644
--- a/src/libprojectM/MilkdropPreset/FinalComposite.cpp
+++ b/src/libprojectM/MilkdropPreset/FinalComposite.cpp
@@ -15,7 +15,7 @@ static std::string const defaultCompositeShader = "shader_body\n{\nret = tex2D(s
 
 FinalComposite::FinalComposite()
 {
-    RenderItem::Init();
+    Init();
 }
 
 void FinalComposite::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/FinalComposite.hpp b/src/libprojectM/MilkdropPreset/FinalComposite.hpp
index b9cf50b400..2abfb767e0 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/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <array>
 #include <memory>
@@ -15,43 +15,23 @@ namespace MilkdropPreset {
 /**
  * @brief Draws the final composite effect, either a shader or Milkdrop 1 effects.
  */
-class FinalComposite : public Renderer::RenderItem
+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.
-     */
     void LoadCompositeShader(const PresetState& presetState);
 
-    /**
-     * @brief Loads the required textures and compiles the composite shader.
-     * @param presetState The preset state to retrieve the configuration values from.
-     */
     void CompileCompositeShader(PresetState& presetState);
 
-    /**
-     * @brief Renders the composite quad with the appropriate effects or shaders.
-     * @param presetState The preset state to retrieve the configuration values from.
-     * @param presetPerFrameContext The per-frame context to retrieve the initial vars from.
-     */
     void Draw(const PresetState& presetState,
               const PerFrameContext& perFrameContext);
 
-    /**
-     * @brief Returns if the final composite is using a shader or classic filters.
-     * @return true if the final composite is done via a shader, false if not.
-     */
     auto HasCompositeShader() const -> bool;
 
 private:
-    /**
-     * Composite mesh vertex with all required attributes.
-     */
     struct MeshVertex {
         float x{}; //!< Vertex X coordinate.
         float y{}; //!< Vertex Y coordinate.
@@ -65,13 +45,6 @@ class FinalComposite : public Renderer::RenderItem
         float angle{};
     };
 
-    /**
-     * @brief Initializes the vertex array and fills in static data if needed.
-     *
-     * The vertices will only be reinitialized if the viewport size changed.
-     *
-     * @param presetState The preset state to retrieve the configuration values from.
-     */
     void InitializeMesh(const PresetState& presetState);
 
     static float SquishToCenter(float x, float exponent);
@@ -79,10 +52,6 @@ class FinalComposite : public Renderer::RenderItem
     static void UvToMathSpace(float aspectX, float aspectY,
                               float u, float v, float& rad, float& ang);
 
-    /**
-     * @brief Calculates the randomized, slowly changing diffuse colors.
-     * @param presetState The preset state to retrieve the configuration values from.
-     */
     void ApplyHueShaderColors(const PresetState& presetState);
 
     static constexpr int compositeGridWidth{32};
diff --git a/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp b/src/libprojectM/MilkdropPreset/MilkdropPreset.cpp
index 110489a808..8154572d69 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>
 
 #ifdef MILKDROP_PRESET_DEBUG
 #include <iostream>
@@ -40,7 +41,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);
 }
 
@@ -51,7 +55,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);
 }
 
@@ -105,8 +112,8 @@ void MilkdropPreset::RenderFrame(const libprojectM::Audio::FrameAudioData& audio
     }
 
     // y-flip the previous frame and assign the flipped texture as "main"
-    m_flipTexture.Draw(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);
@@ -146,8 +153,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(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);
@@ -158,7 +165,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(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.
@@ -170,7 +177,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)
@@ -178,7 +185,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(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 06fa470bb7..e6c0c718f8 100644
--- a/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
+++ b/src/libprojectM/MilkdropPreset/MilkdropPreset.hpp
@@ -127,7 +127,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 3ec34e17e6..c13130447a 100644
--- a/src/libprojectM/MilkdropPreset/MotionVectors.cpp
+++ b/src/libprojectM/MilkdropPreset/MotionVectors.cpp
@@ -9,10 +9,9 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 MotionVectors::MotionVectors(PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
 {
-    RenderItem::Init();
+    Init();
 }
 
 void MotionVectors::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/MotionVectors.hpp b/src/libprojectM/MilkdropPreset/MotionVectors.hpp
index 4782e03ade..707962ffe6 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/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <memory>
 
@@ -12,27 +12,16 @@ namespace MilkdropPreset {
 
 /**
  * @brief Draws a flexible motion vector field.
- *
- * This is broken right now, as it only renders a relatively static 1px point grid, with no apparent motion trails.
- * Milkdrop renders this as lines with trails.
- *
- * @todo Reverse-engineer the original Milkdrop code and reimplement it properly.
- *       https://github.com/projectM-visualizer/milkdrop2/blob/f05b0d811a87a17c4624170c26c93bac39b05bde/src/vis_milk2/milkdropfs.cpp#L1239
  */
-class MotionVectors : public Renderer::RenderItem
+class MotionVectors : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
     MotionVectors() = delete;
 
     explicit MotionVectors(PresetState& presetState);
 
-    void InitVertexAttrib();
+    void InitVertexAttrib() override;
 
-    /**
-     * Renders the motion vectors.
-     * @param presetPerFrameContext The per-frame context variables.
-     * @param motionTexture The u/v "motion" texture written by the warp shader.
-     */
     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 5ad57c28d6..1ff71e570f 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.cpp
@@ -21,9 +21,8 @@ namespace MilkdropPreset {
 static constexpr uint32_t VerticesPerDrawCall = 1024 * 3;
 
 PerPixelMesh::PerPixelMesh()
-    : RenderItem()
 {
-    RenderItem::Init();
+    Init();
 }
 
 void PerPixelMesh::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
index 98576d30a3..3041c7b086 100644
--- a/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
+++ b/src/libprojectM/MilkdropPreset/PerPixelMesh.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 #include <Renderer/Shader.hpp>
 
 #include <cstdint>
@@ -27,7 +27,7 @@ class MilkdropShader;
  *
  * The mesh size can be changed between frames, the class will reallocate the buffers if needed.
  */
-class PerPixelMesh : public Renderer::RenderItem
+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 9bf9ae4f26..eb88331775 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.cpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.cpp
@@ -4,10 +4,9 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 VideoEcho::VideoEcho(const PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
 {
-    RenderItem::Init();
+    Init();
 }
 
 void VideoEcho::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/VideoEcho.hpp b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
index dce3cace9f..0c04bdcfb4 100644
--- a/src/libprojectM/MilkdropPreset/VideoEcho.hpp
+++ b/src/libprojectM/MilkdropPreset/VideoEcho.hpp
@@ -5,7 +5,7 @@
 
 #include <projectM-opengl.h>
 
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 namespace libprojectM {
 namespace MilkdropPreset {
@@ -13,15 +13,15 @@ namespace MilkdropPreset {
 /**
  * @brief Renders a video "echo" (ghost image) effect and gamma adjustments.
  */
-class VideoEcho: public Renderer::RenderItem
+class VideoEcho : public libprojectM::Renderer::Backend::OpenGL::OpenGLRenderItem
 {
 public:
-	VideoEcho() = delete;
+    VideoEcho() = delete;
     explicit VideoEcho(const PresetState& presetState);
 
     void InitVertexAttrib() override;
 
-	void Draw();
+    void Draw();
 
 private:
     void DrawVideoEcho();
diff --git a/src/libprojectM/MilkdropPreset/Waveform.cpp b/src/libprojectM/MilkdropPreset/Waveform.cpp
index ce4351784c..1fadc20686 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.cpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.cpp
@@ -18,10 +18,9 @@ namespace libprojectM {
 namespace MilkdropPreset {
 
 Waveform::Waveform(PresetState& presetState)
-    : RenderItem()
-    , m_presetState(presetState)
+    : m_presetState(presetState)
 {
-    RenderItem::Init();
+    Init();
 }
 
 void Waveform::InitVertexAttrib()
diff --git a/src/libprojectM/MilkdropPreset/Waveform.hpp b/src/libprojectM/MilkdropPreset/Waveform.hpp
index bad7b944be..9a4c860724 100644
--- a/src/libprojectM/MilkdropPreset/Waveform.hpp
+++ b/src/libprojectM/MilkdropPreset/Waveform.hpp
@@ -5,7 +5,7 @@
 
 #include "Waveforms/WaveformMath.hpp"
 
-#include <Renderer/RenderItem.hpp>
+#include <Renderer/Backend/OpenGL/OpenGLRenderItem.hpp>
 
 #include <memory>
 #include <vector>
@@ -16,7 +16,7 @@ namespace MilkdropPreset {
 class PresetState;
 class PerFrameContext;
 
-class Waveform : public Renderer::RenderItem
+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 495c5d4b7d..92c1126e57 100644
--- a/src/libprojectM/ProjectM.cpp
+++ b/src/libprojectM/ProjectM.cpp
@@ -24,10 +24,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/TextureManager.hpp>
 #include <Renderer/ShaderCache.hpp>
@@ -204,7 +205,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>();
 
@@ -263,7 +264,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 6e6ec383cc..f8e1ab7bdf 100644
--- a/src/libprojectM/Renderer/CopyTexture.cpp
+++ b/src/libprojectM/Renderer/CopyTexture.cpp
@@ -1,232 +1,9 @@
 #include "CopyTexture.hpp"
 
-#include <array>
-#include <iostream>
+// 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 = 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);
-}
-
-)";
-
-CopyTexture::CopyTexture()
-{
-    RenderItem::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 CopyTexture::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 CopyTexture::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 CopyTexture::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 CopyTexture::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 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(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 Renderer
 } // namespace libprojectM
diff --git a/src/libprojectM/Renderer/CopyTexture.hpp b/src/libprojectM/Renderer/CopyTexture.hpp
index e8911d3cad..654e4a8d82 100644
--- a/src/libprojectM/Renderer/CopyTexture.hpp
+++ b/src/libprojectM/Renderer/CopyTexture.hpp
@@ -16,64 +16,18 @@ namespace Renderer {
 class CopyTexture : public RenderItem
 {
 public:
-    CopyTexture();
+    virtual ~CopyTexture() = default;
 
-    void InitVertexAttrib() override;
+    virtual void Draw(const std::shared_ptr<class Texture>& originalTexture,
+                     bool flipVertical = false, bool flipHorizontal = false) = 0;
 
-    /**
-     * @brief Copies the original texture into the currently bound framebuffer.
-     * @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(const std::shared_ptr<class Texture>& originalTexture,
-              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 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 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(const std::shared_ptr<class Texture>& originalTexture, const std::shared_ptr<class Texture>& targetTexture = {},
-              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 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 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(const std::shared_ptr<class Texture>& originalTexture, Framebuffer& framebuffer, int framebufferIndex,
-              bool flipVertical = false, bool flipHorizontal = false);
-
-    /**
-     * @brief Returns the flipped texture.
-     *
-     * @return The flipped texture.
-     */
-    auto Texture() -> std::shared_ptr<class Texture>;
-
-private:
-    /**
-     * Updates the mesh
-     */
-    void UpdateTextureSize(int width, int height);
-
-    void Copy(bool flipVertical, bool flipHorizontal) const;
-
-    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
+    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 b486f329eb..17adfe6bf7 100644
--- a/src/libprojectM/Renderer/PresetTransition.cpp
+++ b/src/libprojectM/Renderer/PresetTransition.cpp
@@ -19,20 +19,6 @@ PresetTransition::PresetTransition(const std::shared_ptr<Shader>& transitionShad
 {
     std::mt19937 rand32(m_randomDevice());
     m_staticRandomValues = {rand32(), rand32(), rand32(), rand32()};
-
-    RenderItem::Init();
-}
-
-void PresetTransition::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);
 }
 
 auto PresetTransition::IsDone(double currentFrameTime) const -> bool
@@ -52,91 +38,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
-    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);
-    }
-
-    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 cdd6ac1e60..7b5d658ef5 100644
--- a/src/libprojectM/Renderer/PresetTransition.hpp
+++ b/src/libprojectM/Renderer/PresetTransition.hpp
@@ -16,52 +16,27 @@ namespace Renderer {
 /**
  * @brief Implements the shader and rendering logic to blend two presets into each other.
  */
-class PresetTransition : public RenderItem
+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);
 
-    void InitVertexAttrib() override;
+    virtual ~PresetTransition() = default;
 
-    /**
-     * @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;
-
-    /**
-     * @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.
-     * @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 libprojectM::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",
@@ -71,18 +46,18 @@ class PresetTransition : public RenderItem
                                                  "noisevol_lq",
                                                  "pw_noisevol_lq",
                                                  "noisevol_hq",
-                                                 "pw_noisevol_hq"}; //!< Names of noise textures to retrieve from TextureManager.
+                                                 "pw_noisevol_hq"};
 
-    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/Renderer/RenderItem.cpp b/src/libprojectM/Renderer/RenderItem.cpp
index 08b9bdcdc2..dc56daa7a1 100644
--- a/src/libprojectM/Renderer/RenderItem.cpp
+++ b/src/libprojectM/Renderer/RenderItem.cpp
@@ -3,25 +3,8 @@
 namespace libprojectM {
 namespace Renderer {
 
-void RenderItem::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);
-}
-
-RenderItem::~RenderItem()
-{
-    glDeleteBuffers(1, &m_vboID);
-    glDeleteVertexArrays(1, &m_vaoID);
-}
+// RenderItem is now an abstract interface/base class.
+// OpenGL implementation is in Backend/OpenGL/OpenGLRenderItem.cpp
 
 } // namespace Renderer
 } // namespace libprojectM
diff --git a/src/libprojectM/Renderer/RenderItem.hpp b/src/libprojectM/Renderer/RenderItem.hpp
index 7ebf9928f3..f44c2ee34d 100644
--- a/src/libprojectM/Renderer/RenderItem.hpp
+++ b/src/libprojectM/Renderer/RenderItem.hpp
@@ -54,70 +54,30 @@ inline float color_modulo(double x)
 class RenderItem
 {
 public:
-    /**
-     * A simple 2D point.
-     */
     struct Point {
         Point() = default;
         Point(float pointX, float pointY)
             : x(pointX)
             , y(pointY){};
-
-        float x{}; //!< Vertex X coordinate.
-        float y{}; //!< Vertex Y coordinate.
+        float x{};
+        float y{};
     };
 
-    /**
-     * Struct for use as a vertex attribute in the untextured shader.
-     */
     struct ColoredPoint {
-        float x{}; //!< Vertex X coordinate.
-        float y{}; //!< Vertex Y coordinate.
-        float r{}; //!< Vertex red color value.
-        float g{}; //!< Vertex green color value.
-        float b{}; //!< Vertex blue color value.
-        float a{}; //!< Vertex alpha value.
+        float x{}, y{}, r{}, g{}, b{}, a{};
     };
 
-    /**
-     * Struct for use as a vertex attribute in the textured shader.
-     */
     struct TexturedPoint {
-        float x{}; //!< Vertex X coordinate.
-        float y{}; //!< Vertex Y coordinate.
-        float r{}; //!< Vertex red color value.
-        float g{}; //!< Vertex green color value.
-        float b{}; //!< Vertex blue color value.
-        float a{}; //!< Vertex alpha value.
-        float u{}; //!< Texture X coordinate.
-        float v{}; //!< Texture Y coordinate.
+        float x{}, y{}, r{}, g{}, b{}, a{}, u{}, v{};
     };
 
-    /**
-     * Default constructor.
-     */
-    RenderItem() = default;
-
-    /**
-     * Destructor.
-     */
-    virtual ~RenderItem();
+    virtual ~RenderItem() = default;
 
-    /**
-     * Sets up the vertex attribute pointers for rendering this item.
-     */
+    // Abstract interface for backend implementations
     virtual void InitVertexAttrib() = 0;
 
-protected:
-    /**
-     * @brief Initializes the OpenGL objects in the base class.
-     *
-     * Must be called in the constructor of derived classes.
-     */
-    void Init();
-
-    GLuint m_vboID{0}; //!< This RenderItem's vertex buffer object ID
-    GLuint m_vaoID{0}; //!< This RenderItem's vertex array object ID
+    // For legacy compatibility: allow (optional) backend-specific initialization
+    virtual void Init() {}
 };
 
 } // namespace Renderer
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.cpp b/src/libprojectM/UserSprites/MilkdropSprite.cpp
index 4fbfbf2390..ba8721fcbb 100644
--- a/src/libprojectM/UserSprites/MilkdropSprite.cpp
+++ b/src/libprojectM/UserSprites/MilkdropSprite.cpp
@@ -25,7 +25,7 @@ namespace UserSprites {
 
 MilkdropSprite::MilkdropSprite()
 {
-    RenderItem::Init();
+    // Do not call Init() here; OpenGLRenderItem::Init() will be called by the rendering system when needed.
 }
 
 void MilkdropSprite::InitVertexAttrib()
diff --git a/src/libprojectM/UserSprites/MilkdropSprite.hpp b/src/libprojectM/UserSprites/MilkdropSprite.hpp
index 21cd14e916..800b807235 100644
--- a/src/libprojectM/UserSprites/MilkdropSprite.hpp
+++ b/src/libprojectM/UserSprites/MilkdropSprite.hpp
@@ -10,7 +10,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();
diff --git a/vendor/projectm-eval b/vendor/projectm-eval
index ee180a2473..7cefc94eb2 160000
--- a/vendor/projectm-eval
+++ b/vendor/projectm-eval
@@ -1 +1 @@
-Subproject commit ee180a2473c12856fd25dc754bafdab7e843cc7a
+Subproject commit 7cefc94eb2583c5106e022850cfba70d76391015