Render smoothness: avoid audio/render contention and GC stalls\n- Native: make clonable, keep last snapshot, use try_lock in render; skip pulse update if locked; shorter sleep\n- Web: reuse analyser buffer to avoid per-frame allocations\n- All: ci passes

Author: rgilks

crates/app-native/src/main.rs

@@ -26,7 +26,7 @@ struct InstanceData {
     pulse: f32,
 }
 
-#[derive(Default)]
+#[derive(Default, Clone)]
 struct VisState {
     positions: [Vec3; 3],
     colors: [Vec4; 3],
@@ -48,6 +48,8 @@ struct GpuState<'w> {
     height: u32,
     last_frame: Instant,
     shared: Arc<Mutex<VisState>>,
+    // Local snapshot to render when shared state is locked by audio thread
+    last_vis_snapshot: VisState,
 }
 
 impl<'w> GpuState<'w> {
@@ -212,6 +214,9 @@ impl<'w> GpuState<'w> {
             multiview: None,
         });
 
+        // Take an initial snapshot of visual state (non-blocking best-effort)
+        let initial_snapshot = shared.lock().map(|v| v.clone()).unwrap_or_default();
+
         Ok(Self {
             window,
             surface,
@@ -227,6 +232,7 @@ impl<'w> GpuState<'w> {
             height: size.height,
             last_frame: Instant::now(),
             shared,
+            last_vis_snapshot: initial_snapshot,
         })
     }
 
@@ -267,35 +273,46 @@ impl<'w> GpuState<'w> {
             }),
         );
 
-        // Build instance data from shared state
-        let mut vis = self.shared.lock().unwrap();
-        // decay pulses
+        // Build instance data from shared state without blocking the render thread.
+        // If the mutex is held by the audio scheduler, render using the last snapshot.
         let dt_sec = dt.as_secs_f32();
-        for p in vis.pulses.iter_mut() {
-            *p = (*p - dt_sec * 1.5).max(0.0);
-        }
+        let vis_local: VisState = if let Ok(mut vis) = self.shared.try_lock() {
+            // Decay pulses in shared state and copy snapshot
+            for p in vis.pulses.iter_mut() {
+                *p = (*p - dt_sec * 1.5).max(0.0);
+            }
+            let snapshot = vis.clone();
+            self.last_vis_snapshot = snapshot.clone();
+            snapshot
+        } else {
+            // Decay locally; avoid writing back to shared state
+            for p in self.last_vis_snapshot.pulses.iter_mut() {
+                *p = (*p - dt_sec * 1.5).max(0.0);
+            }
+            self.last_vis_snapshot.clone()
+        };
+
         let z_offset = app_core::z_offset_vec3();
         let spread = SPREAD;
         let positions = [
-            vis.positions[0] * spread + z_offset,
-            vis.positions[1] * spread + z_offset,
-            vis.positions[2] * spread + z_offset,
+            vis_local.positions[0] * spread + z_offset,
+            vis_local.positions[1] * spread + z_offset,
+            vis_local.positions[2] * spread + z_offset,
         ];
         let scales = [
-            BASE_SCALE + vis.pulses[0] * app_core::SCALE_PULSE_MULTIPLIER,
-            BASE_SCALE + vis.pulses[1] * app_core::SCALE_PULSE_MULTIPLIER,
-            BASE_SCALE + vis.pulses[2] * app_core::SCALE_PULSE_MULTIPLIER,
+            BASE_SCALE + vis_local.pulses[0] * app_core::SCALE_PULSE_MULTIPLIER,
+            BASE_SCALE + vis_local.pulses[1] * app_core::SCALE_PULSE_MULTIPLIER,
+            BASE_SCALE + vis_local.pulses[2] * app_core::SCALE_PULSE_MULTIPLIER,
         ];
         let mut instances: Vec<InstanceData> = Vec::with_capacity(3);
         for i in 0..3 {
             instances.push(InstanceData {
                 pos: positions[i].to_array(),
                 scale: scales[i],
-                color: vis.colors[i].to_array(),
-                pulse: vis.pulses[i],
+                color: vis_local.colors[i].to_array(),
+                pulse: vis_local.pulses[i],
             });
         }
-        drop(vis);
         self.queue
             .write_buffer(&self.instance_vb, 0, bytemuck::cast_slice(&instances));
 
@@ -628,13 +645,16 @@ fn start_audio_engine(
                         }
                         drop(guard);
                         // Kick visual pulses
-                        let mut vis = vis_clone.lock().unwrap();
-                        for ev in &events {
-                            let i = ev.voice_index.min(2);
-                            vis.pulses[i] = (vis.pulses[i] + ev.velocity).min(1.5);
+                        // Try to update visual pulses without blocking; if busy, skip this tick
+                        if let Ok(mut vis) = vis_clone.try_lock() {
+                            for ev in &events {
+                                let i = ev.voice_index.min(2);
+                                vis.pulses[i] = (vis.pulses[i] + ev.velocity).min(1.5);
+                            }
                         }
                     }
-                    std::thread::sleep(Duration::from_millis(15));
+                    // Small sleep to limit CPU without inducing long stalls
+                    std::thread::sleep(Duration::from_millis(8));
                 }
             })
             .ok()?;

crates/app-web/src/lib.rs

@@ -402,6 +402,12 @@ async fn init() -> anyhow::Result<()> {
                     if let Some(a) = &analyser {
                         a.set_fft_size(256);
                     }
+                    // Reusable buffer for analyser to avoid per-frame allocations/GC pauses
+                    let analyser_buf: Rc<RefCell<Vec<f32>>> = Rc::new(RefCell::new(Vec::new()));
+                    if let Some(a) = &analyser {
+                        let bins = a.frequency_bin_count() as usize;
+                        analyser_buf.borrow_mut().resize(bins, 0.0);
+                    }
 
                     // Pause state (stops scheduling new notes but keeps rendering)
                     let paused = Rc::new(RefCell::new(false));
@@ -924,14 +930,19 @@ async fn init() -> anyhow::Result<()> {
                             }
                             // Optional analyser-driven mild ambient pulse
                             if let Some(a) = &analyser {
-                                let bins = a.frequency_bin_count();
-                                let mut freq = vec![0.0_f32; bins as usize];
-                                a.get_float_frequency_data(&mut freq);
+                                let bins = a.frequency_bin_count() as usize;
+                                {
+                                    let mut buf = analyser_buf.borrow_mut();
+                                    if buf.len() != bins {
+                                        buf.resize(bins, 0.0);
+                                    }
+                                    a.get_float_frequency_data(&mut buf);
+                                }
                                 // Use low-frequency bin energy to adjust background subtly
                                 let mut sum = 0.0f32;
                                 let take = (bins.min(16)) as u32;
                                 for i in 0..take {
-                                    let v = freq[i as usize]; // in dBFS (-inf..0)
+                                    let v = analyser_buf.borrow()[i as usize]; // in dBFS (-inf..0)
                                                               // map dB to 0..1 roughly
                                     let lin = ((v + 100.0) / 100.0).clamp(0.0, 1.0);
                                     sum += lin;
@@ -1005,15 +1016,20 @@ async fn init() -> anyhow::Result<()> {
                                 let bins = a.frequency_bin_count() as usize;
                                 let dots = bins.min(16);
                                 if dots > 0 {
-                                    let mut freq = vec![0.0_f32; bins];
-                                    a.get_float_frequency_data(&mut freq);
+                                    {
+                                        let mut buf = analyser_buf.borrow_mut();
+                                        if buf.len() != bins {
+                                            buf.resize(bins, 0.0);
+                                        }
+                                        a.get_float_frequency_data(&mut buf);
+                                    }
                                     let _w = canvas_for_tick.width().max(1) as f32;
                                     let _h = canvas_for_tick.height().max(1) as f32;
                                     // place dots near bottom of view in world space
                                     // map x from -2.8..2.8 and y slightly below origin
                                     let z = z_offset.z;
                                     for i in 0..dots {
-                                        let v_db = freq[i];
+                                        let v_db = analyser_buf.borrow()[i];
                                         let lin = ((v_db + 100.0) / 100.0).clamp(0.0, 1.0);
                                         let x = -2.8 + (i as f32) * (5.6 / (dots as f32 - 1.0));
                                         let y = -1.8;