Merge pull request #1674 from CapSoftware/rendering-engine-tweaks

Improved rendering engine, recording resilience, and analytics trackingRendering engine tweaks

Author: richiemcilroy

.gitignore

@@ -16,6 +16,7 @@ dist-ssr
 .env.development
 .env.test
 target
+target-agent
 .cursorrules
 .github/hooks
 
@@ -68,4 +69,5 @@ scripts/releases-backfill-data.txt
 .opencode/
 analysis/
 analysis/plans/
-.ralphy
+.ralphy
+tmp/

AGENTS.md

@@ -31,7 +31,7 @@ All Rust code must respect these workspace-level lints defined in `Cargo.toml`:
 **Clippy lints (all denied):**
 - `dbg_macro` — Never use `dbg!()` in code; use proper logging instead.
 - `let_underscore_future` — Never write `let _ = async_fn()` which silently drops futures; await or explicitly handle them.
-- `unchecked_duration_subtraction` — Use `saturating_sub` instead of `-` for `Duration` to avoid panics.
+- `unchecked_time_subtraction` — Use `saturating_sub` instead of `-` for `Duration` to avoid panics.
 - `collapsible_if` — Merge nested `if` statements: use `if a && b { }` instead of `if a { if b { } }`.
 - `clone_on_copy` — Don't call `.clone()` on `Copy` types; just copy them directly.
 - `redundant_closure` — Use function references directly: `iter.map(foo)` instead of `iter.map(|x| foo(x))`.

CLAUDE.md

@@ -380,7 +380,7 @@ All Rust code must respect these workspace-level lints defined in `Cargo.toml`.
 **Clippy lints (all denied — code MUST NOT contain these patterns):**
 - `dbg_macro` — Never use `dbg!()` in code; use proper logging (`tracing::debug!`, etc.) instead.
 - `let_underscore_future` — Never write `let _ = async_fn()` which silently drops futures; await or explicitly handle them.
-- `unchecked_duration_subtraction` — Use `duration.saturating_sub(other)` instead of `duration - other` to avoid panics on underflow.
+- `unchecked_time_subtraction` — Use `duration.saturating_sub(other)` instead of `duration - other` to avoid panics on underflow.
 - `collapsible_if` — Merge nested `if` statements: write `if a && b { }` instead of `if a { if b { } }`.
 - `clone_on_copy` — Don't call `.clone()` on `Copy` types (integers, bools, etc.); just copy them directly.
 - `redundant_closure` — Use function references directly: `iter.map(foo)` instead of `iter.map(|x| foo(x))`.

Cargo.toml

@@ -83,7 +83,7 @@ unused_must_use = "deny"
 [workspace.lints.clippy]
 dbg_macro = "deny"
 let_underscore_future = "deny"
-unchecked_duration_subtraction = "deny"
+unchecked_time_subtraction = "deny"
 collapsible_if = "deny"
 clone_on_copy = "deny"
 redundant_closure = "deny"

apps/desktop/src-tauri/src/export.rs

@@ -336,8 +336,14 @@ pub async fn generate_export_preview(
     let zoom_focus_interpolator = ZoomFocusInterpolator::new(
         &render_segment.cursor,
         cursor_smoothing,
+        project_config.cursor.click_spring_config(),
         project_config.screen_movement_spring,
         total_duration,
+        project_config
+            .timeline
+            .as_ref()
+            .map(|t| t.zoom_segments.as_slice())
+            .unwrap_or(&[]),
     );
 
     let uniforms = ProjectUniforms::new(
@@ -482,8 +488,14 @@ pub async fn generate_export_preview_fast(
     let zoom_focus_interpolator = ZoomFocusInterpolator::new(
         &segment_media.cursor,
         cursor_smoothing,
+        project_config.cursor.click_spring_config(),
         project_config.screen_movement_spring,
         total_duration,
+        project_config
+            .timeline
+            .as_ref()
+            .map(|t| t.zoom_segments.as_slice())
+            .unwrap_or(&[]),
     );
 
     let uniforms = ProjectUniforms::new(

apps/desktop/src-tauri/src/posthog.rs

@@ -2,8 +2,11 @@ use std::{
     sync::{OnceLock, PoisonError, RwLock},
     time::Duration,
 };
+use tauri::AppHandle;
 use tracing::error;
 
+use crate::auth::AuthStore;
+
 #[derive(Debug)]
 pub enum PostHogEvent {
     MultipartUploadComplete {
@@ -22,36 +25,42 @@ pub enum PostHogEvent {
     },
 }
 
-impl From<PostHogEvent> for posthog_rs::Event {
-    fn from(event: PostHogEvent) -> Self {
-        match event {
-            PostHogEvent::MultipartUploadComplete {
-                duration,
-                length,
-                size,
-            } => {
-                let mut e = posthog_rs::Event::new_anon("multipart_upload_complete");
-                e.insert_prop("duration", duration.as_secs())
-                    .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-                    .ok();
-                e.insert_prop("length", length.as_secs())
-                    .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-                    .ok();
-                e.insert_prop("size", size)
-                    .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-                    .ok();
-                e
-            }
-            PostHogEvent::MultipartUploadFailed { duration, error } => {
-                let mut e = posthog_rs::Event::new_anon("multipart_upload_failed");
-                e.insert_prop("duration", duration.as_secs())
-                    .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-                    .ok();
-                e.insert_prop("error", error)
-                    .map_err(|err| error!("Error adding PostHog property: {err:?}"))
-                    .ok();
-                e
-            }
+fn posthog_event(event: PostHogEvent, distinct_id: Option<&str>) -> posthog_rs::Event {
+    match event {
+        PostHogEvent::MultipartUploadComplete {
+            duration,
+            length,
+            size,
+        } => {
+            let mut e = match distinct_id {
+                Some(distinct_id) => {
+                    posthog_rs::Event::new("multipart_upload_complete", distinct_id)
+                }
+                None => posthog_rs::Event::new_anon("multipart_upload_complete"),
+            };
+            e.insert_prop("duration", duration.as_secs())
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+            e.insert_prop("length", length.as_secs())
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+            e.insert_prop("size", size)
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+            e
+        }
+        PostHogEvent::MultipartUploadFailed { duration, error } => {
+            let mut e = match distinct_id {
+                Some(distinct_id) => posthog_rs::Event::new("multipart_upload_failed", distinct_id),
+                None => posthog_rs::Event::new_anon("multipart_upload_failed"),
+            };
+            e.insert_prop("duration", duration.as_secs())
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+            e.insert_prop("error", error)
+                .map_err(|err| error!("Error adding PostHog property: {err:?}"))
+                .ok();
+            e
         }
     }
 }
@@ -76,10 +85,14 @@ pub fn set_server_url(url: &str) {
 
 static API_SERVER_IS_CAP_CLOUD: OnceLock<RwLock<Option<bool>>> = OnceLock::new();
 
-pub fn async_capture_event(event: PostHogEvent) {
+pub fn async_capture_event(app: &AppHandle, event: PostHogEvent) {
     if option_env!("VITE_POSTHOG_KEY").is_some() {
+        let distinct_id = AuthStore::get(app)
+            .ok()
+            .flatten()
+            .and_then(|auth| auth.user_id);
         tokio::spawn(async move {
-            let mut e: posthog_rs::Event = event.into();
+            let mut e = posthog_event(event, distinct_id.as_deref());
 
             e.insert_prop("cap_version", env!("CARGO_PKG_VERSION"))
                 .map_err(|err| error!("Error adding PostHog property: {err:?}"))

apps/desktop/src-tauri/src/screenshot_editor.rs

@@ -356,8 +356,14 @@ impl ScreenshotEditorInstances {
                         let zoom_focus_interpolator = ZoomFocusInterpolator::new(
                             &cursor_events,
                             None,
+                            current_config.cursor.click_spring_config(),
                             current_config.screen_movement_spring,
                             0.0,
+                            current_config
+                                .timeline
+                                .as_ref()
+                                .map(|t| t.zoom_segments.as_slice())
+                                .unwrap_or(&[]),
                         );
 
                         let uniforms = ProjectUniforms::new(

apps/desktop/src-tauri/src/upload.rs

@@ -146,22 +146,25 @@ pub async fn upload_video(
 
     emit_upload_complete(app, &video_id);
 
-    async_capture_event(match &video_result {
-        Ok(meta) => PostHogEvent::MultipartUploadComplete {
-            duration: start.elapsed(),
-            length: meta
-                .as_ref()
-                .map(|v| Duration::from_secs(v.duration_in_secs as u64))
-                .unwrap_or_default(),
-            size: std::fs::metadata(file_path)
-                .map(|m| ((m.len() as f64) / 1_000_000.0) as u64)
-                .unwrap_or_default(),
-        },
-        Err(err) => PostHogEvent::MultipartUploadFailed {
-            duration: start.elapsed(),
-            error: err.to_string(),
+    async_capture_event(
+        app,
+        match &video_result {
+            Ok(meta) => PostHogEvent::MultipartUploadComplete {
+                duration: start.elapsed(),
+                length: meta
+                    .as_ref()
+                    .map(|v| Duration::from_secs(v.duration_in_secs as u64))
+                    .unwrap_or_default(),
+                size: std::fs::metadata(file_path)
+                    .map(|m| ((m.len() as f64) / 1_000_000.0) as u64)
+                    .unwrap_or_default(),
+            },
+            Err(err) => PostHogEvent::MultipartUploadFailed {
+                duration: start.elapsed(),
+                error: err.to_string(),
+            },
         },
-    });
+    );
 
     let _ = (video_result?, thumbnail_result?);
 
@@ -399,29 +402,32 @@ impl InstantMultipartUpload {
             handle: spawn_actor(async move {
                 let start = Instant::now();
                 let result = Self::run(
-                    app,
+                    app.clone(),
                     file_path.clone(),
                     pre_created_video,
                     recording_dir,
                     realtime_upload_done,
                 )
                 .await;
-                async_capture_event(match &result {
-                    Ok(meta) => PostHogEvent::MultipartUploadComplete {
-                        duration: start.elapsed(),
-                        length: meta
-                            .as_ref()
-                            .map(|v| Duration::from_secs(v.duration_in_secs as u64))
-                            .unwrap_or_default(),
-                        size: std::fs::metadata(file_path)
-                            .map(|m| ((m.len() as f64) / 1_000_000.0) as u64)
-                            .unwrap_or_default(),
-                    },
-                    Err(err) => PostHogEvent::MultipartUploadFailed {
-                        duration: start.elapsed(),
-                        error: err.to_string(),
+                async_capture_event(
+                    &app,
+                    match &result {
+                        Ok(meta) => PostHogEvent::MultipartUploadComplete {
+                            duration: start.elapsed(),
+                            length: meta
+                                .as_ref()
+                                .map(|v| Duration::from_secs(v.duration_in_secs as u64))
+                                .unwrap_or_default(),
+                            size: std::fs::metadata(file_path)
+                                .map(|m| ((m.len() as f64) / 1_000_000.0) as u64)
+                                .unwrap_or_default(),
+                        },
+                        Err(err) => PostHogEvent::MultipartUploadFailed {
+                            duration: start.elapsed(),
+                            error: err.to_string(),
+                        },
                     },
-                });
+                );
 
                 result.map(|_| ())
             }),

apps/desktop/src/routes/editor/ConfigSidebar.tsx

@@ -224,7 +224,7 @@ type CursorPresetValues = {
 	friction: number;
 };
 
-const DEFAULT_CURSOR_MOTION_BLUR = 0.5;
+const DEFAULT_CURSOR_MOTION_BLUR = 1.0;
 
 const CURSOR_TYPE_OPTIONS = [
 	{
@@ -619,6 +619,16 @@ export function ConfigSidebar() {
 								step={1}
 							/>
 						</Field>
+						<Field name="Tilt" icon={<IconLucideRotate3d class="size-4" />}>
+							<Slider
+								value={[project.cursor.rotationAmount ?? 0.15]}
+								onChange={(v) => setProject("cursor", "rotationAmount", v[0])}
+								minValue={0}
+								maxValue={1}
+								step={0.01}
+								formatTooltip={(value) => `${Math.round(value * 100)}%`}
+							/>
+						</Field>
 						<Field
 							name="Hide When Idle"
 							icon={<IconLucideTimer class="size-4" />}

apps/desktop/src/utils/frame-worker.ts

@@ -417,7 +417,6 @@ function drainAndRenderLatestSharedWebGPU(maxDrain: number): boolean {
 	if (renderMode !== "webgpu" || !webgpuRenderer) return false;
 
 	let latest: { bytes: Uint8Array; release: () => void } | null = null;
-	let drained = 0;
 
 	for (let i = 0; i < maxDrain; i += 1) {
 		const borrowed = consumer.borrow(0);
@@ -427,7 +426,6 @@ function drainAndRenderLatestSharedWebGPU(maxDrain: number): boolean {
 			latest.release();
 		}
 		latest = { bytes: borrowed.data, release: borrowed.release };
-		drained += 1;
 	}
 
 	if (!latest) return false;