refactor: Bundle GPU context into GpuContext struct

- Created GpuContext struct {device, queue, format}
- Updated Effect/PostProcessEffect to take const GpuContext&
- Updated all 19 effect implementations
- Updated MainSequence.init() and LoadTimeline() signatures
- Updated generated timeline files
- Updated all test files
- Added gpu_get_context() accessor and fixture.ctx() helper

Fixes test_mesh.cc compilation error from g_device/g_queue/g_format conflicts.
All targets build successfully.

31 files changed, 220 insertions, 248 deletions

diff --git a/src/generated/test_demo_timeline.cc b/src/generated/test_demo_timeline.cc
index 75c5fe6..8b80d15 100644
--- a/src/generated/test_demo_timeline.cc
+++ b/src/generated/test_demo_timeline.cc
@@ -6,10 +6,10 @@ float GetDemoDuration() {
   return 16.000000f;
 }
 
-void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format) {
+void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx) {
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 16.0f, 0);
+    seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 16.0f, 0);
     main_seq.add_sequence(seq, 0.0f, 0);
   }
 }
diff --git a/src/generated/timeline.cc b/src/generated/timeline.cc
index cd03b77..1facf8f 100644
--- a/src/generated/timeline.cc
+++ b/src/generated/timeline.cc
@@ -6,118 +6,118 @@ float GetDemoDuration() {
   return 32.500000f;
 }
 
-void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format) {
+void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx) {
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1);
-    seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 1.f, 0);
-    seq->add_effect(std::make_shared<FadeEffect>(device, queue, format), 0.1f, 1.f, 1);
-    seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 2.000000f, 2);
+    seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1);
+    seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 1.f, 0);
+    seq->add_effect(std::make_shared<FadeEffect>(ctx), 0.1f, 1.f, 1);
+    seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 2.000000f, 2);
     main_seq.add_sequence(seq, 0.000000f, 0);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), 0.1f, 3.f, -1);
-    seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 0.2f, 0);
+    seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), 0.1f, 3.f, -1);
+    seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 0.2f, 0);
     main_seq.add_sequence(seq, 2.000000f, 0);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.0f, .2f, 0);
-    seq->add_effect(std::make_shared<FadeEffect>(device, queue, format), 0.1f, 1.0f, 1);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.0f, .2f, 0);
+    seq->add_effect(std::make_shared<FadeEffect>(ctx), 0.1f, 1.0f, 1);
     main_seq.add_sequence(seq, 3.500000f, 0);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.000000f, 8.000000f, 1);
-    seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 8.000000f, 2);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 3);
+    seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.000000f, 8.000000f, 1);
+    seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 8.000000f, 2);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 3);
     main_seq.add_sequence(seq, 16.000000f, 0);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 1);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 2);
-    seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 1.000000f, 3);
+    seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 1);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 2);
+    seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 1.000000f, 3);
     main_seq.add_sequence(seq, 24.000000f, 0);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 4.000000f, 0);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 0);
-    seq->add_effect(std::make_shared<Hybrid3DEffect>(device, queue, format), 0.000000f, 2.000000f, 1);
-    seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 4.000000f, 2);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.000000f, 8.000000f, 3);
-    seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 8.000000f, 4);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 5);
+    seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 4.000000f, 0);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 0);
+    seq->add_effect(std::make_shared<Hybrid3DEffect>(ctx), 0.000000f, 2.000000f, 1);
+    seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 4.000000f, 2);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.000000f, 8.000000f, 3);
+    seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 8.000000f, 4);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 5);
     main_seq.add_sequence(seq, 28.000000f, 0);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 1.500000f, 0);
-    seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 1.500000f, 1);
+    seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 1.500000f, 0);
+    seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 1.500000f, 1);
     main_seq.add_sequence(seq, 31.000000f, 0);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 2.000000f, 0);
-    seq->add_effect(std::make_shared<ParticlesEffect>(device, queue, format), 0.000000f, 2.000000f, 1);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 1);
+    seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 2.000000f, 0);
+    seq->add_effect(std::make_shared<ParticlesEffect>(ctx), 0.000000f, 2.000000f, 1);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 1);
     main_seq.add_sequence(seq, 3.000000f, 1);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 4.000000f, 0);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 1);
-    seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 4.000000f, 2);
-    seq->add_effect(std::make_shared<Hybrid3DEffect>(device, queue, format), 0.000000f, 10.000000f, 3);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 4);
-    seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 5.000000f, 5);
-    seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 5.000000f, 6);
+    seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 4.000000f, 0);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 1);
+    seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 4.000000f, 2);
+    seq->add_effect(std::make_shared<Hybrid3DEffect>(ctx), 0.000000f, 10.000000f, 3);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 4);
+    seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 5.000000f, 5);
+    seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 5.000000f, 6);
     main_seq.add_sequence(seq, 12.000000f, 1);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.000000f, 2.000000f, 0);
-    seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 2.000000f, 1);
-    seq->add_effect(std::make_shared<ParticlesEffect>(device, queue, format), 0.000000f, 2.000000f, 2);
+    seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.000000f, 2.000000f, 0);
+    seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 2.000000f, 1);
+    seq->add_effect(std::make_shared<ParticlesEffect>(ctx), 0.000000f, 2.000000f, 2);
     main_seq.add_sequence(seq, 6.000000f, 2);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1);
-    seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 0.500000f, 0);
+    seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1);
+    seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 0.500000f, 0);
     main_seq.add_sequence(seq, 7.500000f, 2);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 1);
-    seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 2.000000f, 2);
-    seq->add_effect(std::make_shared<ParticlesEffect>(device, queue, format), 0.000000f, 2.000000f, 2);
-    seq->add_effect(std::make_shared<Hybrid3DEffect>(device, queue, format), 0.000000f, 2.000000f, 3);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 4);
-    seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 3.000000f, 5);
+    seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 1);
+    seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 2.000000f, 2);
+    seq->add_effect(std::make_shared<ParticlesEffect>(ctx), 0.000000f, 2.000000f, 2);
+    seq->add_effect(std::make_shared<Hybrid3DEffect>(ctx), 0.000000f, 2.000000f, 3);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 4);
+    seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 3.000000f, 5);
     main_seq.add_sequence(seq, 8.500000f, 2);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0);
-    seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.0f, 4.0f, 0);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 1);
-    seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 3.000000f, 2);
-    seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 5.000000f, 3);
+    seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0);
+    seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.0f, 4.0f, 0);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 1);
+    seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 3.000000f, 2);
+    seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 5.000000f, 3);
     main_seq.add_sequence(seq, 4.000000f, 3);
   }
   {
     auto seq = std::make_shared<Sequence>();
-    seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1);
-    seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 0);
-    seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 0.2f, 1);
-    seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.500000f, 0.2f, 1);
+    seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1);
+    seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 0);
+    seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 0.2f, 1);
+    seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.500000f, 0.2f, 1);
     main_seq.add_sequence(seq, 8.000000f, 10);
   }
 }
diff --git a/src/gpu/demo_effects.h b/src/gpu/demo_effects.h
index 4b96ba7..cddd04b 100644
--- a/src/gpu/demo_effects.h
+++ b/src/gpu/demo_effects.h
@@ -23,7 +23,7 @@ struct Particle {
 
 class HeptagonEffect : public Effect {
  public:
-  HeptagonEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  HeptagonEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
 
@@ -33,7 +33,7 @@ class HeptagonEffect : public Effect {
 
 class ParticlesEffect : public Effect {
  public:
-  ParticlesEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  ParticlesEffect(const GpuContext& ctx);
   void compute(WGPUCommandEncoder encoder, float time, float beat,
                float intensity, float aspect_ratio) override;
   void render(WGPURenderPassEncoder pass, float time, float beat,
@@ -47,15 +47,13 @@ class ParticlesEffect : public Effect {
 
 class PassthroughEffect : public PostProcessEffect {
  public:
-  PassthroughEffect(WGPUDevice device, WGPUQueue queue,
-                    WGPUTextureFormat format);
+  PassthroughEffect(const GpuContext& ctx);
   void update_bind_group(WGPUTextureView input_view) override;
 };
 
 class MovingEllipseEffect : public Effect {
  public:
-  MovingEllipseEffect(WGPUDevice device, WGPUQueue queue,
-                      WGPUTextureFormat format);
+  MovingEllipseEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
 
@@ -65,8 +63,7 @@ class MovingEllipseEffect : public Effect {
 
 class ParticleSprayEffect : public Effect {
  public:
-  ParticleSprayEffect(WGPUDevice device, WGPUQueue queue,
-                      WGPUTextureFormat format);
+  ParticleSprayEffect(const GpuContext& ctx);
   void compute(WGPUCommandEncoder encoder, float time, float beat,
                float intensity, float aspect_ratio) override;
   void render(WGPURenderPassEncoder pass, float time, float beat,
@@ -80,8 +77,7 @@ class ParticleSprayEffect : public Effect {
 
 class GaussianBlurEffect : public PostProcessEffect {
  public:
-  GaussianBlurEffect(WGPUDevice device, WGPUQueue queue,
-                     WGPUTextureFormat format);
+  GaussianBlurEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
@@ -89,7 +85,7 @@ class GaussianBlurEffect : public PostProcessEffect {
 
 class SolarizeEffect : public PostProcessEffect {
  public:
-  SolarizeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  SolarizeEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
@@ -97,7 +93,7 @@ class SolarizeEffect : public PostProcessEffect {
 
 class DistortEffect : public PostProcessEffect {
  public:
-  DistortEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  DistortEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
@@ -105,8 +101,7 @@ class DistortEffect : public PostProcessEffect {
 
 class ChromaAberrationEffect : public PostProcessEffect {
  public:
-  ChromaAberrationEffect(WGPUDevice device, WGPUQueue queue,
-                         WGPUTextureFormat format);
+  ChromaAberrationEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
@@ -114,7 +109,7 @@ class ChromaAberrationEffect : public PostProcessEffect {
 
 class Hybrid3DEffect : public Effect {
  public:
-  Hybrid3DEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  Hybrid3DEffect(const GpuContext& ctx);
   void init(MainSequence* demo) override;
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
@@ -130,7 +125,7 @@ class Hybrid3DEffect : public Effect {
 
 class FlashCubeEffect : public Effect {
  public:
-  FlashCubeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  FlashCubeEffect(const GpuContext& ctx);
   void init(MainSequence* demo) override;
   void resize(int width, int height) override;
   void render(WGPURenderPassEncoder pass, float time, float beat,
@@ -149,8 +144,7 @@ class FlashCubeEffect : public Effect {
 
 class ThemeModulationEffect : public PostProcessEffect {
  public:
-  ThemeModulationEffect(WGPUDevice device, WGPUQueue queue,
-                        WGPUTextureFormat format);
+  ThemeModulationEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
@@ -158,7 +152,7 @@ class ThemeModulationEffect : public PostProcessEffect {
 
 class FadeEffect : public PostProcessEffect {
  public:
-  FadeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  FadeEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
@@ -166,7 +160,7 @@ class FadeEffect : public PostProcessEffect {
 
 class FlashEffect : public PostProcessEffect {
  public:
-  FlashEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  FlashEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
@@ -176,7 +170,6 @@ class FlashEffect : public PostProcessEffect {
 };
 
 // Auto-generated functions
-void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue,
-                  WGPUTextureFormat format);
+void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx);
 float GetDemoDuration(); // Returns demo end time in seconds, or -1 if not
                          // specified
\ No newline at end of file
diff --git a/src/gpu/effect.cc b/src/gpu/effect.cc
index b95c4ce..ea5230d 100644
--- a/src/gpu/effect.cc
+++ b/src/gpu/effect.cc
@@ -117,16 +117,16 @@ void MainSequence::create_framebuffers(int width, int height) {
       WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_TextureBinding;
   desc.dimension = WGPUTextureDimension_2D;
   desc.size = {(uint32_t)width, (uint32_t)height, 1};
-  desc.format = format;
+  desc.format = gpu_ctx.format;
   desc.mipLevelCount = 1;
   desc.sampleCount = 1;
 
-  framebuffer_a_ = wgpuDeviceCreateTexture(device, &desc);
-  framebuffer_b_ = wgpuDeviceCreateTexture(device, &desc);
+  framebuffer_a_ = wgpuDeviceCreateTexture(gpu_ctx.device, &desc);
+  framebuffer_b_ = wgpuDeviceCreateTexture(gpu_ctx.device, &desc);
 
   WGPUTextureViewDescriptor view_desc = {};
   view_desc.dimension = WGPUTextureViewDimension_2D;
-  view_desc.format = format;
+  view_desc.format = gpu_ctx.format;
   view_desc.mipLevelCount = 1;
   view_desc.arrayLayerCount = 1;
 
@@ -141,7 +141,7 @@ void MainSequence::create_framebuffers(int width, int height) {
   depth_desc.format = WGPUTextureFormat_Depth24Plus;
   depth_desc.mipLevelCount = 1;
   depth_desc.sampleCount = 1;
-  depth_texture_ = wgpuDeviceCreateTexture(device, &depth_desc);
+  depth_texture_ = wgpuDeviceCreateTexture(gpu_ctx.device, &depth_desc);
 
   WGPUTextureViewDescriptor depth_view_desc = {};
   depth_view_desc.format = WGPUTextureFormat_Depth24Plus;
@@ -152,25 +152,20 @@ void MainSequence::create_framebuffers(int width, int height) {
   depth_view_ = wgpuTextureCreateView(depth_texture_, &depth_view_desc);
 }
 
-void MainSequence::init_test(WGPUDevice d, WGPUQueue q, WGPUTextureFormat f) {
-  device = d;
-  queue = q;
-  format = f;
+void MainSequence::init_test(const GpuContext& ctx) {
+  gpu_ctx = ctx;
   // No framebuffers or passthrough effect created in test mode.
   // Test effects should not rely on these being real.
 }
 
-void MainSequence::init(WGPUDevice d, WGPUQueue q, WGPUTextureFormat f,
-                        int width, int height) {
-  device = d;
-  queue = q;
-  format = f;
+void MainSequence::init(const GpuContext& ctx, int width, int height) {
+  gpu_ctx = ctx;
   width_ = width;
   height_ = height;
 
   create_framebuffers(width, height);
   passthrough_effect_ =
-      std::make_unique<PassthroughEffect>(device, queue, format);
+      std::make_unique<PassthroughEffect>(gpu_ctx);
   passthrough_effect_->resize(width, height);
 
   for (ActiveSequence& entry : sequences_) {
@@ -183,7 +178,7 @@ void MainSequence::add_sequence(std::shared_ptr<Sequence> seq, float start_time,
                                 int priority) {
   sequences_.push_back({seq, start_time, priority});
   // If MainSequence is already initialized, init the new sequence immediately
-  if (device) {
+  if (gpu_ctx.device) {
     seq->init(this);
     seq->resize(width_, height_);
   }
@@ -225,7 +220,7 @@ void MainSequence::resize(int width, int height) {
 
 void MainSequence::render_frame(float global_time, float beat, float peak,
                                 float aspect_ratio, WGPUSurface surface) {
-  WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr);
+  WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(gpu_ctx.device, nullptr);
 
   std::vector<SequenceItem*> scene_effects;
   std::vector<SequenceItem*> post_effects;
@@ -360,7 +355,7 @@ void MainSequence::render_frame(float global_time, float beat, float peak,
   }
 
   WGPUCommandBuffer commands = wgpuCommandEncoderFinish(encoder, nullptr);
-  wgpuQueueSubmit(queue, 1, &commands);
+  wgpuQueueSubmit(gpu_ctx.queue, 1, &commands);
 
   if (st.texture) {
     wgpuTextureViewRelease(final_view);
@@ -393,7 +388,7 @@ void MainSequence::simulate_until(float target_time, float step_rate) {
   const float aspect_ratio = 16.0f / 9.0f;
   for (float t = 0.0f; t < target_time; t += step_rate) {
     WGPUCommandEncoder encoder =
-        wgpuDeviceCreateCommandEncoder(device, nullptr);
+        wgpuDeviceCreateCommandEncoder(gpu_ctx.device, nullptr);
     float beat = fmodf(t * bpm / 60.0f, 1.0f);
     std::vector<SequenceItem*> scene_effects, post_effects;
     for (ActiveSequence& entry : sequences_) {
@@ -407,7 +402,7 @@ void MainSequence::simulate_until(float target_time, float step_rate) {
                             aspect_ratio);
     }
     WGPUCommandBuffer commands = wgpuCommandEncoderFinish(encoder, nullptr);
-    wgpuQueueSubmit(queue, 1, &commands);
+    wgpuQueueSubmit(gpu_ctx.queue, 1, &commands);
   }
 }
 #endif /* !defined(STRIP_ALL) */
diff --git a/src/gpu/effect.h b/src/gpu/effect.h
index 0cc9de5..006ee6f 100644
--- a/src/gpu/effect.h
+++ b/src/gpu/effect.h
@@ -9,7 +9,7 @@ class PostProcessEffect;
 
 class Effect {
  public:
-  Effect(WGPUDevice device, WGPUQueue queue) : device_(device), queue_(queue) {
+  Effect(const GpuContext& ctx) : device_(ctx.device), queue_(ctx.queue), format_(ctx.format) {
   }
   virtual ~Effect() = default;
   virtual void init(MainSequence* demo) {
@@ -42,6 +42,7 @@ class Effect {
  protected:
   WGPUDevice device_;
   WGPUQueue queue_;
+  WGPUTextureFormat format_;
   GpuBuffer uniforms_;
   int width_ = 1280;
   int height_ = 720;
@@ -49,8 +50,8 @@ class Effect {
 
 class PostProcessEffect : public Effect {
  public:
-  PostProcessEffect(WGPUDevice device, WGPUQueue queue)
-      : Effect(device, queue) {
+  PostProcessEffect(const GpuContext& ctx)
+      : Effect(ctx) {
   }
   bool is_post_process() const override {
     return true;
@@ -103,13 +104,10 @@ class MainSequence {
  public:
   MainSequence();
   ~MainSequence();
-  WGPUDevice device;
-  WGPUQueue queue;
-  WGPUTextureFormat format;
+  GpuContext gpu_ctx;
 
-  void init(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format,
-            int width, int height);
-  void init_test(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  void init(const GpuContext& ctx, int width, int height);
+  void init_test(const GpuContext& ctx);
   void add_sequence(std::shared_ptr<Sequence> seq, float start_time,
                     int priority = 0);
   void render_frame(float global_time, float beat, float peak,
diff --git a/src/gpu/effects/chroma_aberration_effect.cc b/src/gpu/effects/chroma_aberration_effect.cc
index 6e64988..83c5f2a 100644
--- a/src/gpu/effects/chroma_aberration_effect.cc
+++ b/src/gpu/effects/chroma_aberration_effect.cc
@@ -5,14 +5,12 @@
 #include "gpu/gpu.h"
 
 // --- ChromaAberrationEffect ---
-ChromaAberrationEffect::ChromaAberrationEffect(WGPUDevice device,
-                                               WGPUQueue queue,
-                                               WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+ChromaAberrationEffect::ChromaAberrationEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 6,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
-  pipeline_ = create_post_process_pipeline(device_, format,
+  pipeline_ = create_post_process_pipeline(device_, format_,
                                            chroma_aberration_shader_wgsl);
 }
 void ChromaAberrationEffect::render(WGPURenderPassEncoder pass, float t,
diff --git a/src/gpu/effects/distort_effect.cc b/src/gpu/effects/distort_effect.cc
index 0d4bb36..abaa2e7 100644
--- a/src/gpu/effects/distort_effect.cc
+++ b/src/gpu/effects/distort_effect.cc
@@ -5,14 +5,13 @@
 #include "gpu/gpu.h"
 
 // --- DistortEffect ---
-DistortEffect::DistortEffect(WGPUDevice device, WGPUQueue queue,
-                             WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+DistortEffect::DistortEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 6,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   pipeline_ =
-      create_post_process_pipeline(device_, format, distort_shader_wgsl);
+      create_post_process_pipeline(device_, format_, distort_shader_wgsl);
 }
 void DistortEffect::render(WGPURenderPassEncoder pass, float t, float b,
                            float i, float a) {
diff --git a/src/gpu/effects/fade_effect.cc b/src/gpu/effects/fade_effect.cc
index 4d7633c..dce2360 100644
--- a/src/gpu/effects/fade_effect.cc
+++ b/src/gpu/effects/fade_effect.cc
@@ -5,9 +5,8 @@
 #include "gpu/effects/post_process_helper.h"
 #include <cmath>
 
-FadeEffect::FadeEffect(WGPUDevice device, WGPUQueue queue,
-                       WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+FadeEffect::FadeEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   const char* shader_code = R"(
     struct VertexOutput {
       @builtin(position) position: vec4<f32>,
@@ -46,9 +45,9 @@ FadeEffect::FadeEffect(WGPUDevice device, WGPUQueue queue,
     }
   )";
 
-  pipeline_ = create_post_process_pipeline(device, format, shader_code);
+  pipeline_ = create_post_process_pipeline(device_, format_, shader_code);
   uniforms_ = gpu_create_buffer(
-      device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
+      device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
 }
 
 void FadeEffect::update_bind_group(WGPUTextureView input_view) {
diff --git a/src/gpu/effects/fade_effect.h b/src/gpu/effects/fade_effect.h
index fc91646..2048c2a 100644
--- a/src/gpu/effects/fade_effect.h
+++ b/src/gpu/effects/fade_effect.h
@@ -8,7 +8,7 @@
 
 class FadeEffect : public PostProcessEffect {
  public:
-  FadeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  FadeEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
diff --git a/src/gpu/effects/flash_cube_effect.cc b/src/gpu/effects/flash_cube_effect.cc
index 75c71e1..4f58562 100644
--- a/src/gpu/effects/flash_cube_effect.cc
+++ b/src/gpu/effects/flash_cube_effect.cc
@@ -8,10 +8,8 @@
 #include <cmath>
 #include <iostream>
 
-FlashCubeEffect::FlashCubeEffect(WGPUDevice device, WGPUQueue queue,
-                                 WGPUTextureFormat format)
-    : Effect(device, queue) {
-  (void)format;
+FlashCubeEffect::FlashCubeEffect(const GpuContext& ctx)
+    : Effect(ctx) {
 }
 
 void FlashCubeEffect::resize(int width, int height) {
@@ -22,9 +20,9 @@ void FlashCubeEffect::resize(int width, int height) {
 
 void FlashCubeEffect::init(MainSequence* demo) {
   (void)demo;
-  WGPUTextureFormat format = demo->format;
+  WGPUTextureFormat format = demo->gpu_ctx.format;
 
-  renderer_.init(device_, queue_, format);
+  renderer_.init(device_, queue_, format_);
   renderer_.resize(width_, height_);
 
   // Texture Manager
diff --git a/src/gpu/effects/flash_cube_effect.h b/src/gpu/effects/flash_cube_effect.h
index 3af13eb..7089af2 100644
--- a/src/gpu/effects/flash_cube_effect.h
+++ b/src/gpu/effects/flash_cube_effect.h
@@ -11,7 +11,7 @@
 
 class FlashCubeEffect : public Effect {
  public:
-  FlashCubeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  FlashCubeEffect(const GpuContext& ctx);
   void init(MainSequence* demo) override;
   void resize(int width, int height) override;
   void render(WGPURenderPassEncoder pass, float time, float beat,
diff --git a/src/gpu/effects/flash_effect.cc b/src/gpu/effects/flash_effect.cc
index 176c60c..3dcb48a 100644
--- a/src/gpu/effects/flash_effect.cc
+++ b/src/gpu/effects/flash_effect.cc
@@ -5,9 +5,8 @@
 #include "gpu/effects/post_process_helper.h"
 #include <cmath>
 
-FlashEffect::FlashEffect(WGPUDevice device, WGPUQueue queue,
-                         WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+FlashEffect::FlashEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   const char* shader_code = R"(
     struct VertexOutput {
       @builtin(position) position: vec4<f32>,
@@ -48,9 +47,9 @@ FlashEffect::FlashEffect(WGPUDevice device, WGPUQueue queue,
     }
   )";
 
-  pipeline_ = create_post_process_pipeline(device, format, shader_code);
+  pipeline_ = create_post_process_pipeline(device_, format_, shader_code);
   uniforms_ = gpu_create_buffer(
-      device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
+      device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
 }
 
 void FlashEffect::update_bind_group(WGPUTextureView input_view) {
diff --git a/src/gpu/effects/flash_effect.h b/src/gpu/effects/flash_effect.h
index 9aa2c67..6be375d 100644
--- a/src/gpu/effects/flash_effect.h
+++ b/src/gpu/effects/flash_effect.h
@@ -8,7 +8,7 @@
 
 class FlashEffect : public PostProcessEffect {
  public:
-  FlashEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  FlashEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
diff --git a/src/gpu/effects/gaussian_blur_effect.cc b/src/gpu/effects/gaussian_blur_effect.cc
index ad9bf4b..72a93b8 100644
--- a/src/gpu/effects/gaussian_blur_effect.cc
+++ b/src/gpu/effects/gaussian_blur_effect.cc
@@ -5,14 +5,13 @@
 #include "gpu/gpu.h"
 
 // --- GaussianBlurEffect ---
-GaussianBlurEffect::GaussianBlurEffect(WGPUDevice device, WGPUQueue queue,
-                                       WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+GaussianBlurEffect::GaussianBlurEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 6,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   pipeline_ =
-      create_post_process_pipeline(device_, format, gaussian_blur_shader_wgsl);
+      create_post_process_pipeline(device_, format_, gaussian_blur_shader_wgsl);
 }
 void GaussianBlurEffect::render(WGPURenderPassEncoder pass, float t, float b,
                                 float i, float a) {
diff --git a/src/gpu/effects/heptagon_effect.cc b/src/gpu/effects/heptagon_effect.cc
index c982912..024f076 100644
--- a/src/gpu/effects/heptagon_effect.cc
+++ b/src/gpu/effects/heptagon_effect.cc
@@ -5,15 +5,14 @@
 #include "gpu/gpu.h"
 
 // --- HeptagonEffect ---
-HeptagonEffect::HeptagonEffect(WGPUDevice device, WGPUQueue queue,
-                               WGPUTextureFormat format)
-    : Effect(device, queue) {
+HeptagonEffect::HeptagonEffect(const GpuContext& ctx)
+    : Effect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 4,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   ResourceBinding bindings[] = {{uniforms_, WGPUBufferBindingType_Uniform}};
   pass_ =
-      gpu_create_render_pass(device_, format, main_shader_wgsl, bindings, 1);
+      gpu_create_render_pass(device_, format_, main_shader_wgsl, bindings, 1);
   pass_.vertex_count = 21;
 }
 void HeptagonEffect::render(WGPURenderPassEncoder pass, float t, float b,
diff --git a/src/gpu/effects/hybrid_3d_effect.cc b/src/gpu/effects/hybrid_3d_effect.cc
index 8c70c07..6f89bf3 100644
--- a/src/gpu/effects/hybrid_3d_effect.cc
+++ b/src/gpu/effects/hybrid_3d_effect.cc
@@ -8,10 +8,8 @@
 #include <cmath>
 #include <iostream>
 
-Hybrid3DEffect::Hybrid3DEffect(WGPUDevice device, WGPUQueue queue,
-                               WGPUTextureFormat format)
-    : Effect(device, queue) {
-  (void)format; // Passed to base, not directly used here.
+Hybrid3DEffect::Hybrid3DEffect(const GpuContext& ctx)
+    : Effect(ctx) {
 }
 
 void Hybrid3DEffect::resize(int width, int height) {
@@ -23,10 +21,10 @@ void Hybrid3DEffect::resize(int width, int height) {
 void Hybrid3DEffect::init(MainSequence* demo) {
   (void)demo;
   WGPUTextureFormat format =
-      demo->format; // Get current format from MainSequence (might be different
-                    // than constructor if resized)
+      demo->gpu_ctx.format; // Get current format from MainSequence (might be different
+                            // than constructor if resized)
 
-  renderer_.init(device_, queue_, format);
+  renderer_.init(device_, queue_, format_);
   renderer_.resize(width_, height_);
 
   // Texture Manager
diff --git a/src/gpu/effects/hybrid_3d_effect.h b/src/gpu/effects/hybrid_3d_effect.h
index 8e2fef9..3a4e87c 100644
--- a/src/gpu/effects/hybrid_3d_effect.h
+++ b/src/gpu/effects/hybrid_3d_effect.h
@@ -12,7 +12,7 @@
 
 class Hybrid3DEffect : public Effect {
  public:
-  Hybrid3DEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+  Hybrid3DEffect(const GpuContext& ctx);
   virtual ~Hybrid3DEffect() override = default;
 
   void init(MainSequence* demo) override;
diff --git a/src/gpu/effects/moving_ellipse_effect.cc b/src/gpu/effects/moving_ellipse_effect.cc
index 3b73697..1163215 100644
--- a/src/gpu/effects/moving_ellipse_effect.cc
+++ b/src/gpu/effects/moving_ellipse_effect.cc
@@ -5,15 +5,14 @@
 #include "gpu/gpu.h"
 
 // --- MovingEllipseEffect ---
-MovingEllipseEffect::MovingEllipseEffect(WGPUDevice device, WGPUQueue queue,
-                                         WGPUTextureFormat format)
-    : Effect(device, queue) {
+MovingEllipseEffect::MovingEllipseEffect(const GpuContext& ctx)
+    : Effect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 6,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   ResourceBinding bindings[] = {{uniforms_, WGPUBufferBindingType_Uniform}};
   pass_ =
-      gpu_create_render_pass(device_, format, ellipse_shader_wgsl, bindings, 1);
+      gpu_create_render_pass(device_, format_, ellipse_shader_wgsl, bindings, 1);
   pass_.vertex_count = 3;
 }
 void MovingEllipseEffect::render(WGPURenderPassEncoder pass, float t, float b,
diff --git a/src/gpu/effects/particle_spray_effect.cc b/src/gpu/effects/particle_spray_effect.cc
index e8ead0a..452017e 100644
--- a/src/gpu/effects/particle_spray_effect.cc
+++ b/src/gpu/effects/particle_spray_effect.cc
@@ -6,9 +6,8 @@
 #include <vector>
 
 // --- ParticleSprayEffect ---
-ParticleSprayEffect::ParticleSprayEffect(WGPUDevice device, WGPUQueue queue,
-                                         WGPUTextureFormat format)
-    : Effect(device, queue) {
+ParticleSprayEffect::ParticleSprayEffect(const GpuContext& ctx)
+    : Effect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 6,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
@@ -27,7 +26,7 @@ ParticleSprayEffect::ParticleSprayEffect(WGPUDevice device, WGPUQueue queue,
       {particles_buffer_, WGPUBufferBindingType_ReadOnlyStorage},
       {uniforms_, WGPUBufferBindingType_Uniform}};
   render_pass_ =
-      gpu_create_render_pass(device_, format, particle_render_wgsl, rb, 2);
+      gpu_create_render_pass(device_, format_, particle_render_wgsl, rb, 2);
   render_pass_.vertex_count = 6;
   render_pass_.instance_count = NUM_PARTICLES;
 }
diff --git a/src/gpu/effects/particles_effect.cc b/src/gpu/effects/particles_effect.cc
index 6218af9..137150a 100644
--- a/src/gpu/effects/particles_effect.cc
+++ b/src/gpu/effects/particles_effect.cc
@@ -6,9 +6,8 @@
 #include <vector>
 
 // --- ParticlesEffect ---
-ParticlesEffect::ParticlesEffect(WGPUDevice device, WGPUQueue queue,
-                                 WGPUTextureFormat format)
-    : Effect(device, queue) {
+ParticlesEffect::ParticlesEffect(const GpuContext& ctx)
+    : Effect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 4,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
@@ -25,7 +24,7 @@ ParticlesEffect::ParticlesEffect(WGPUDevice device, WGPUQueue queue,
       {particles_buffer_, WGPUBufferBindingType_ReadOnlyStorage},
       {uniforms_, WGPUBufferBindingType_Uniform}};
   render_pass_ =
-      gpu_create_render_pass(device_, format, particle_render_wgsl, rb, 2);
+      gpu_create_render_pass(device_, format_, particle_render_wgsl, rb, 2);
   render_pass_.vertex_count = 6;
   render_pass_.instance_count = NUM_PARTICLES;
 }
diff --git a/src/gpu/effects/passthrough_effect.cc b/src/gpu/effects/passthrough_effect.cc
index 7825c0a..203f912 100644
--- a/src/gpu/effects/passthrough_effect.cc
+++ b/src/gpu/effects/passthrough_effect.cc
@@ -5,14 +5,13 @@
 #include "gpu/gpu.h"
 
 // --- PassthroughEffect ---
-PassthroughEffect::PassthroughEffect(WGPUDevice device, WGPUQueue queue,
-                                     WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+PassthroughEffect::PassthroughEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 6,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   pipeline_ =
-      create_post_process_pipeline(device_, format, passthrough_shader_wgsl);
+      create_post_process_pipeline(device_, format_, passthrough_shader_wgsl);
 }
 void PassthroughEffect::update_bind_group(WGPUTextureView input_view) {
   struct {
diff --git a/src/gpu/effects/solarize_effect.cc b/src/gpu/effects/solarize_effect.cc
index a0bc971..b6cf6f9 100644
--- a/src/gpu/effects/solarize_effect.cc
+++ b/src/gpu/effects/solarize_effect.cc
@@ -5,14 +5,13 @@
 #include "gpu/gpu.h"
 
 // --- SolarizeEffect ---
-SolarizeEffect::SolarizeEffect(WGPUDevice device, WGPUQueue queue,
-                               WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+SolarizeEffect::SolarizeEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   uniforms_ =
       gpu_create_buffer(device_, sizeof(float) * 6,
                         WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   pipeline_ =
-      create_post_process_pipeline(device_, format, solarize_shader_wgsl);
+      create_post_process_pipeline(device_, format_, solarize_shader_wgsl);
 }
 void SolarizeEffect::render(WGPURenderPassEncoder pass, float t, float b,
                             float i, float a) {
diff --git a/src/gpu/effects/theme_modulation_effect.cc b/src/gpu/effects/theme_modulation_effect.cc
index d2705d5..d0d71cb 100644
--- a/src/gpu/effects/theme_modulation_effect.cc
+++ b/src/gpu/effects/theme_modulation_effect.cc
@@ -6,9 +6,8 @@
 #include "gpu/effects/shaders.h"
 #include <cmath>
 
-ThemeModulationEffect::ThemeModulationEffect(WGPUDevice device, WGPUQueue queue,
-                                             WGPUTextureFormat format)
-    : PostProcessEffect(device, queue) {
+ThemeModulationEffect::ThemeModulationEffect(const GpuContext& ctx)
+    : PostProcessEffect(ctx) {
   const char* shader_code = R"(
     struct VertexOutput {
       @builtin(position) position: vec4<f32>,
@@ -48,11 +47,11 @@ ThemeModulationEffect::ThemeModulationEffect(WGPUDevice device, WGPUQueue queue,
     }
   )";
 
-  pipeline_ = create_post_process_pipeline(device, format, shader_code);
+  pipeline_ = create_post_process_pipeline(device_, format_, shader_code);
 
   // Create uniform buffer (4 floats: brightness + padding)
   uniforms_ = gpu_create_buffer(
-      device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
+      device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
 }
 
 void ThemeModulationEffect::update_bind_group(WGPUTextureView input_view) {
diff --git a/src/gpu/effects/theme_modulation_effect.h b/src/gpu/effects/theme_modulation_effect.h
index ac584e2..ad7322e 100644
--- a/src/gpu/effects/theme_modulation_effect.h
+++ b/src/gpu/effects/theme_modulation_effect.h
@@ -8,8 +8,7 @@
 
 class ThemeModulationEffect : public PostProcessEffect {
  public:
-  ThemeModulationEffect(WGPUDevice device, WGPUQueue queue,
-                        WGPUTextureFormat format);
+  ThemeModulationEffect(const GpuContext& ctx);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
diff --git a/src/gpu/gpu.cc b/src/gpu/gpu.cc
index 63a30ff..fe71d3e 100644
--- a/src/gpu/gpu.cc
+++ b/src/gpu/gpu.cc
@@ -21,12 +21,13 @@
 
 static WGPUInstance g_instance = nullptr;
 static WGPUAdapter g_adapter = nullptr;
-WGPUDevice g_device = nullptr;  // Non-static for external access (debug builds)
-WGPUQueue g_queue = nullptr;    // Non-static for external access (debug builds)
+static WGPUDevice g_device = nullptr;
+static WGPUQueue g_queue = nullptr;
 static WGPUSurface g_surface = nullptr;
 static WGPUSurfaceConfiguration g_config = {};
-WGPUTextureFormat g_format = WGPUTextureFormat_BGRA8Unorm;  // Exposed for custom effects
+static WGPUTextureFormat g_format = WGPUTextureFormat_BGRA8Unorm;
 
+static GpuContext g_gpu_context = {};
 static MainSequence g_main_sequence;
 
 // --- Helper Functions ---
@@ -355,7 +356,12 @@ void gpu_init(PlatformState* platform_state) {
 
   g_config.device = g_device;
   g_config.format = swap_chain_format;
-  g_format = swap_chain_format;  // Update global format for external access
+  g_format = swap_chain_format;
+
+  // Update GPU context for accessor
+  g_gpu_context.device = g_device;
+  g_gpu_context.queue = g_queue;
+  g_gpu_context.format = g_format;
   g_config.usage = WGPUTextureUsage_RenderAttachment;
   g_config.width = platform_state->width;
   g_config.height = platform_state->height;
@@ -365,10 +371,9 @@ void gpu_init(PlatformState* platform_state) {
 
   InitShaderComposer();
 
-  g_main_sequence.init(g_device, g_queue, g_config.format,
-                       platform_state->width, platform_state->height);
+  g_main_sequence.init(g_gpu_context, platform_state->width, platform_state->height);
 
-  LoadTimeline(g_main_sequence, g_device, g_queue, g_config.format);
+  LoadTimeline(g_main_sequence, g_gpu_context);
 }
 
 void gpu_draw(float audio_peak, float aspect_ratio, float time, float beat) {
@@ -395,6 +400,10 @@ void gpu_add_custom_effect(Effect* effect, float start_time, float end_time, int
   seq->init(&g_main_sequence);
   g_main_sequence.add_sequence(seq, 0.0f, priority);
 }
+
+const GpuContext* gpu_get_context() {
+  return &g_gpu_context;
+}
 #endif /* !defined(STRIP_ALL) */
 
 void gpu_shutdown() {
diff --git a/src/gpu/gpu.h b/src/gpu/gpu.h
index b8f58b2..c4d1993 100644
--- a/src/gpu/gpu.h
+++ b/src/gpu/gpu.h
@@ -9,6 +9,13 @@
 struct PlatformState; // Forward declaration
 class Effect; // Forward declaration
 
+// GPU context bundling device, queue, and surface format
+struct GpuContext {
+  WGPUDevice device;
+  WGPUQueue queue;
+  WGPUTextureFormat format;
+};
+
 // Basic wrapper for WebGPU buffers
 struct GpuBuffer {
   WGPUBuffer buffer;
@@ -39,10 +46,8 @@ void gpu_resize(int width, int height);
 void gpu_simulate_until(float time);
 void gpu_add_custom_effect(Effect* effect, float start_time, float end_time, int priority);
 
-// Expose WebGPU globals for custom effects (debug builds only)
-extern WGPUDevice g_device;
-extern WGPUQueue g_queue;
-extern WGPUTextureFormat g_format;
+// Get GPU context for custom effects (debug builds only)
+const GpuContext* gpu_get_context();
 #endif
 void gpu_shutdown();
 
diff --git a/src/test_demo.cc b/src/test_demo.cc
index 9ae0e3a..69b18cc 100644
--- a/src/test_demo.cc
+++ b/src/test_demo.cc
@@ -15,14 +15,14 @@
 
 // External declarations from generated files
 extern float GetDemoDuration();
-extern void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format);
+extern void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx);
 
 // Inline peak meter effect for debugging audio-visual sync
 #include "gpu/effects/post_process_helper.h"
 class PeakMeterEffect : public PostProcessEffect {
  public:
-  PeakMeterEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format)
-      : PostProcessEffect(device, queue) {
+  PeakMeterEffect(const GpuContext& ctx)
+      : PostProcessEffect(ctx) {
     const char* shader_code = R"(
       struct VertexOutput {
         @builtin(position) position: vec4<f32>,
@@ -82,9 +82,9 @@ class PeakMeterEffect : public PostProcessEffect {
       }
     )";
 
-    pipeline_ = create_post_process_pipeline(device, format, shader_code);
+    pipeline_ = create_post_process_pipeline(device_, format_, shader_code);
     uniforms_ = gpu_create_buffer(
-        device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
+        device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   }
 
   void update_bind_group(WGPUTextureView input_view) {
@@ -196,7 +196,8 @@ int main(int argc, char** argv) {
 
   // Add peak meter visualization effect (renders as final post-process)
 #if !defined(STRIP_ALL)
-  auto* peak_meter = new PeakMeterEffect(g_device, g_queue, g_format);
+  const GpuContext* gpu_ctx = gpu_get_context();
+  auto* peak_meter = new PeakMeterEffect(*gpu_ctx);
   gpu_add_custom_effect(peak_meter, 0.0f, 99999.0f, 999); // High priority = renders last
 #endif
 
diff --git a/src/tests/test_demo_effects.cc b/src/tests/test_demo_effects.cc
index 3292c9c..ec1d68c 100644
--- a/src/tests/test_demo_effects.cc
+++ b/src/tests/test_demo_effects.cc
@@ -79,34 +79,28 @@ static void test_post_process_effects() {
   }
 
   MainSequence main_seq;
-  main_seq.init_test(fixture.device(), fixture.queue(), fixture.format());
+  main_seq.init_test(fixture.ctx());
 
   // Test each post-process effect
   std::vector<std::pair<const char*, std::shared_ptr<Effect>>> effects = {
       {"FlashEffect",
-       std::make_shared<FlashEffect>(fixture.device(), fixture.queue(),
-                                      fixture.format())},
+       std::make_shared<FlashEffect>(fixture.ctx())},
       {"PassthroughEffect",
-       std::make_shared<PassthroughEffect>(fixture.device(), fixture.queue(),
-                                            fixture.format())},
+       std::make_shared<PassthroughEffect>(fixture.ctx())},
       {"GaussianBlurEffect",
-       std::make_shared<GaussianBlurEffect>(fixture.device(), fixture.queue(),
-                                             fixture.format())},
+       std::make_shared<GaussianBlurEffect>(fixture.ctx())},
       {"ChromaAberrationEffect",
        std::make_shared<ChromaAberrationEffect>(
-           fixture.device(), fixture.queue(), fixture.format())},
+           fixture.ctx())},
       {"DistortEffect",
-       std::make_shared<DistortEffect>(fixture.device(), fixture.queue(),
-                                        fixture.format())},
+       std::make_shared<DistortEffect>(fixture.ctx())},
       {"SolarizeEffect",
-       std::make_shared<SolarizeEffect>(fixture.device(), fixture.queue(),
-                                         fixture.format())},
+       std::make_shared<SolarizeEffect>(fixture.ctx())},
       {"FadeEffect",
-       std::make_shared<FadeEffect>(fixture.device(), fixture.queue(),
-                                     fixture.format())},
+       std::make_shared<FadeEffect>(fixture.ctx())},
       {"ThemeModulationEffect",
        std::make_shared<ThemeModulationEffect>(
-           fixture.device(), fixture.queue(), fixture.format())},
+           fixture.ctx())},
   };
 
   int passed = 0;
@@ -146,28 +140,22 @@ static void test_scene_effects() {
   }
 
   MainSequence main_seq;
-  main_seq.init_test(fixture.device(), fixture.queue(), fixture.format());
+  main_seq.init_test(fixture.ctx());
 
   // Test each scene effect
   std::vector<std::pair<const char*, std::shared_ptr<Effect>>> effects = {
       {"HeptagonEffect",
-       std::make_shared<HeptagonEffect>(fixture.device(), fixture.queue(),
-                                         fixture.format())},
+       std::make_shared<HeptagonEffect>(fixture.ctx())},
       {"ParticlesEffect",
-       std::make_shared<ParticlesEffect>(fixture.device(), fixture.queue(),
-                                          fixture.format())},
+       std::make_shared<ParticlesEffect>(fixture.ctx())},
       {"ParticleSprayEffect",
-       std::make_shared<ParticleSprayEffect>(fixture.device(), fixture.queue(),
-                                              fixture.format())},
+       std::make_shared<ParticleSprayEffect>(fixture.ctx())},
       {"MovingEllipseEffect",
-       std::make_shared<MovingEllipseEffect>(fixture.device(), fixture.queue(),
-                                              fixture.format())},
+       std::make_shared<MovingEllipseEffect>(fixture.ctx())},
       {"FlashCubeEffect",
-       std::make_shared<FlashCubeEffect>(fixture.device(), fixture.queue(),
-                                          fixture.format())},
+       std::make_shared<FlashCubeEffect>(fixture.ctx())},
       {"Hybrid3DEffect",
-       std::make_shared<Hybrid3DEffect>(fixture.device(), fixture.queue(),
-                                         fixture.format())},
+       std::make_shared<Hybrid3DEffect>(fixture.ctx())},
   };
 
   int passed = 0;
@@ -215,20 +203,20 @@ static void test_effect_type_classification() {
 
   // Post-process effects should return true
   auto flash = std::make_shared<FlashEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
   assert(flash->is_post_process() && "FlashEffect should be post-process");
 
   auto blur = std::make_shared<GaussianBlurEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
   assert(blur->is_post_process() && "GaussianBlurEffect should be post-process");
 
   // Scene effects should return false
   auto heptagon = std::make_shared<HeptagonEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
   assert(!heptagon->is_post_process() && "HeptagonEffect should NOT be post-process");
 
   auto particles = std::make_shared<ParticlesEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
   assert(!particles->is_post_process() &&
          "ParticlesEffect should NOT be post-process");
 
diff --git a/src/tests/test_effect_base.cc b/src/tests/test_effect_base.cc
index bc837be..8180535 100644
--- a/src/tests/test_effect_base.cc
+++ b/src/tests/test_effect_base.cc
@@ -73,7 +73,7 @@ static void test_effect_construction() {
 
   // Create FlashEffect (simple post-process effect)
   auto effect = std::make_shared<FlashEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
 
   assert(!effect->is_initialized && "Effect should not be initialized yet");
 
@@ -92,11 +92,11 @@ static void test_effect_initialization() {
 
   // Create MainSequence (use init_test for test environment)
   MainSequence main_seq;
-  main_seq.init_test(fixture.device(), fixture.queue(), fixture.format());
+  main_seq.init_test(fixture.ctx());
 
   // Create FlashEffect
   auto effect = std::make_shared<FlashEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
 
   assert(!effect->is_initialized && "Effect should not be initialized yet");
 
@@ -123,14 +123,14 @@ static void test_sequence_add_effect() {
   }
 
   MainSequence main_seq;
-  main_seq.init_test(fixture.device(), fixture.queue(), fixture.format());
+  main_seq.init_test(fixture.ctx());
 
   // Create sequence
   auto seq = std::make_shared<Sequence>();
 
   // Create effect
   auto effect = std::make_shared<FlashEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
 
   assert(!effect->is_initialized && "Effect should not be initialized before Sequence::init()");
 
@@ -156,11 +156,11 @@ static void test_sequence_activation() {
   }
 
   MainSequence main_seq;
-  main_seq.init_test(fixture.device(), fixture.queue(), fixture.format());
+  main_seq.init_test(fixture.ctx());
 
   auto seq = std::make_shared<Sequence>();
   auto effect = std::make_shared<FlashEffect>(
-      fixture.device(), fixture.queue(), fixture.format());
+      fixture.ctx());
 
   // Effect active from 5.0 to 10.0 seconds
   seq->add_effect(effect, 5.0f, 10.0f, 0);
diff --git a/src/tests/test_sequence.cc b/src/tests/test_sequence.cc
index 788e0b1..e00e606 100644
--- a/src/tests/test_sequence.cc
+++ b/src/tests/test_sequence.cc
@@ -12,6 +12,7 @@
 static WGPUDevice dummy_device = (WGPUDevice)1;
 static WGPUQueue dummy_queue = (WGPUQueue)1;
 static WGPUTextureFormat dummy_format = (WGPUTextureFormat)1;
+static const GpuContext dummy_ctx = {dummy_device, dummy_queue, dummy_format};
 static WGPUSurface dummy_surface = (WGPUSurface)1;
 static WGPUCommandEncoder dummy_encoder = (WGPUCommandEncoder)1;
 static WGPURenderPassEncoder dummy_render_pass_encoder =
@@ -26,8 +27,8 @@ class DummyEffect : public Effect {
   int end_calls = 0;
   bool is_pp = false;
 
-  DummyEffect(WGPUDevice device, WGPUQueue queue, bool post_process = false)
-      : Effect(device, queue), is_pp(post_process) {
+  DummyEffect(const GpuContext& ctx, bool post_process = false)
+      : Effect(ctx), is_pp(post_process) {
   }
 
   void init(MainSequence* demo) override {
@@ -69,10 +70,8 @@ class DummyPostProcessEffect : public PostProcessEffect {
   int render_calls = 0;
   int update_bind_group_calls = 0;
 
-  DummyPostProcessEffect(WGPUDevice device, WGPUQueue queue,
-                         WGPUTextureFormat format)
-      : PostProcessEffect(device, queue) {
-    (void)format;
+  DummyPostProcessEffect(const GpuContext& ctx)
+      : PostProcessEffect(ctx) {
   }
 
   void init(MainSequence* demo) override {
@@ -99,9 +98,9 @@ class DummyPostProcessEffect : public PostProcessEffect {
 void test_effect_lifecycle() {
   printf("  test_effect_lifecycle...\n");
   MainSequence main_seq;
-  main_seq.init_test(dummy_device, dummy_queue, dummy_format);
+  main_seq.init_test(dummy_ctx);
 
-  auto effect1 = std::make_shared<DummyEffect>(dummy_device, dummy_queue);
+  auto effect1 = std::make_shared<DummyEffect>(dummy_ctx);
   auto seq1 = std::make_shared<Sequence>();
   seq1->add_effect(effect1, 1.0f, 3.0f);
   main_seq.add_sequence(seq1, 0.0f, 0);
@@ -145,9 +144,9 @@ void test_simulate_until() {
 #if !defined(STRIP_ALL)
   printf("  test_simulate_until...\n");
   MainSequence main_seq;
-  main_seq.init_test(dummy_device, dummy_queue, dummy_format);
+  main_seq.init_test(dummy_ctx);
 
-  auto effect1 = std::make_shared<DummyEffect>(dummy_device, dummy_queue);
+  auto effect1 = std::make_shared<DummyEffect>(dummy_ctx);
   auto seq1 = std::make_shared<Sequence>();
   seq1->add_effect(effect1, 1.0f, 3.0f);
   main_seq.add_sequence(seq1, 0.0f, 0);
diff --git a/src/tests/webgpu_test_fixture.h b/src/tests/webgpu_test_fixture.h
index 2c700a4..fd08276 100644
--- a/src/tests/webgpu_test_fixture.h
+++ b/src/tests/webgpu_test_fixture.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "gpu/gpu.h"
 #include "platform/platform.h"
 
 // Shared test fixture for WebGPU tests
@@ -25,6 +26,7 @@ class WebGPUTestFixture {
   WGPUDevice device() const { return device_; }
   WGPUQueue queue() const { return queue_; }
   WGPUTextureFormat format() const { return WGPUTextureFormat_BGRA8Unorm; }
+  GpuContext ctx() const { return {device_, queue_, format()}; }
 
   // Check if fixture is ready
   bool is_initialized() const { return device_ != nullptr; }