Keyframes: mute keyframes without deleting them (#1894)

Add a muted flag to Keyframe. Muted keys stay in the Timeline and Graph Editor (dimmed, selectable and movable) but evaluation skips them, so the active neighbours interpolate as if they were not there; auto-Bezier and eases use the active neighbours. When every key is muted the property falls back to its static value.\n\nkeys.setMuted {muted} mutes or unmutes the selected keys in one undo step. The Timeline context menu offers Mute/Unmute Keyframes and the Animation menu has Mute Keyframes. Muted keys have no Bezier handles and motion-path points are dimmed.\n\nLottie export omits muted keys (with a warning) because Lottie has no mute state; scripting keeps seeing them in numKeys/key().\n\nTests: keyframe evaluation (linear, auto-Bezier spatial, all muted), serialization and value replacement, engine command + undo, Lottie export.

crates/engine/src/cmd/prop.rs

@@ -1189,6 +1189,15 @@ fn toggle_hold(s: &mut Session, _: &Value) -> Result<Value> {
     })
 }
 
+fn set_muted(s: &mut Session, p: &Value) -> Result<Value> {
+    let muted = b_p(p, "muted").unwrap_or(true);
+    let label = if muted { "Mute Keyframes" } else { "Unmute Keyframes" };
+    edit_keys(s, label, None, move |keys, i, _| {
+        keys[i].muted = muted;
+        false
+    })
+}
+
 /// A number or a per-dimension array of numbers.
 fn nums_p(p: &Value, k: &str, scale: f64) -> Option<Vec<f64>> {
     match p.get(k)? {
@@ -1381,6 +1390,7 @@ pub fn specs() -> Vec<CommandSpec> {
             &json!({"which": "out"})
         )),
         cmd!("keys.toggleHold", "Toggle Hold Keyframe", ["Animation"], Some("Cmd+Alt+H"), "{}", has_keys, toggle_hold),
+        cmd!("keys.setMuted", "Mute Keyframes", ["Animation"], None, "{muted?: bool (default true)}", has_keys, set_muted),
         cmd!(
             "keys.interpolation",
             "Keyframe Interpolation...",

crates/engine/src/menus.rs

@@ -1036,6 +1036,7 @@ Animation
   ---
   Add Keyframe | anim.addKeyframe
   Toggle Hold Keyframe | keys.toggleHold
+  Mute Keyframes | keys.setMuted
   Keyframe Interpolation... | keys.interpolation
   Keyframe Velocity... | keys.velocity
   Keyframe Assistant

crates/engine/src/tests/menu_cmds.rs

@@ -1483,6 +1483,32 @@ fn key_selection_toggles_and_skips_locked_layers_and_hold_restores_bezier() {
     assert!(s.state.selected_keys.is_empty());
 }
 
+#[test]
+fn muting_keys_skips_them_in_the_timeline_value_and_undoes() {
+    let mut s = comp();
+    let a = solid(&mut s, "#ff0000");
+    for (t, v) in [(0.0, 0.0), (1.0, 100.0), (2.0, 300.0)] {
+        s.execute("prop.addKey", json!({"layer": a, "path": "transform/opacity", "time": t, "value": v})).unwrap();
+    }
+    let value_at = |s: &Session, t: f64| layer(s, a).props.prop("transform/opacity").unwrap().value_at(Tick::from_seconds_f64(t)).as_f64();
+    let select = |s: &mut Session| s.execute("keys.select", json!({"keys": [{"layer": a, "path": "transform/opacity", "time": 1.0}]})).unwrap();
+    select(&mut s);
+    let before = value_at(&s, 0.5);
+    s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+    assert!(layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+    // The muted key no longer bends the 0 → 300 segment.
+    assert!((value_at(&s, 0.5) - 75.0).abs() < 1e-6);
+    assert!((value_at(&s, 1.5) - 225.0).abs() < 1e-6);
+    s.undo();
+    assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+    assert!((value_at(&s, 0.5) - before).abs() < 1e-6);
+    // The same command unmutes.
+    select(&mut s);
+    s.execute("keys.setMuted", json!({"muted": true})).unwrap();
+    s.execute("keys.setMuted", json!({"muted": false})).unwrap();
+    assert!(!layer(&s, a).props.prop("transform/opacity").unwrap().keys[1].muted);
+}
+
 #[test]
 fn transform_drags_apply_their_whole_offset_to_the_keys_they_started_with() {
     let mut s = comp();

crates/interchange/src/export.rs

@@ -155,12 +155,7 @@ fn unsupported(project: &Project, comp: &Comp, l: &Layer, format: TimelineFormat
         return Some(format!("blend mode {}", l.blend_mode.label()));
     }
     // Premiere's Basic Motion in the interchange formats has one (uniform) scale.
-    if let Some(s) = l.transform().and_then(|t| t.get("scale"))
-        && std::iter::once(&s.value).chain(s.keys.iter().map(|k| &k.value)).any(|v| {
-            let a = v.as_vec3();
-            (a[0] - a[1]).abs() > 1e-9
-        })
-    {
+    if l.transform().and_then(|t| t.get("scale")).is_some_and(non_uniform_scale) {
         return Some("non-uniform scale".into());
     }
     if l.preserve_transparency {
@@ -581,10 +576,7 @@ impl Exporter<'_> {
             }
         }
         if let Some(p) = tr.get("scale") {
-            let uniform = std::iter::once(&p.value).chain(p.keys.iter().map(|k| &k.value)).all(|v| {
-                let a = v.as_vec3();
-                (a[0] - a[1]).abs() < 1e-9
-            });
+            let uniform = !non_uniform_scale(p);
             m.params.insert("scale".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[1])));
             if !uniform {
                 m.params.insert("scale_width".into(), param_out(p, &to_clip, |v| fp::ParamValue::Float(v.as_vec3()[0])));
@@ -636,6 +628,16 @@ fn differs(v: &Value, def: [f64; 2]) -> bool {
     (a[0] - def[0]).abs() > 1e-6 || (a[1] - def[1]).abs() > 1e-6
 }
 
+/// Whether a scale property is non-uniform at some point: active key values, or the static
+/// value when every key is muted (muted keys are not exported, #1894).
+fn non_uniform_scale(p: &Property) -> bool {
+    let non_uniform = |v: &Value| {
+        let a = v.as_vec3();
+        (a[0] - a[1]).abs() > 1e-9
+    };
+    if p.keys.iter().any(|k| !k.muted) { p.keys.iter().filter(|k| !k.muted).any(|k| non_uniform(&k.value)) } else { non_uniform(&p.value) }
+}
+
 /// The clip's `id` effect, or a new instance of it (None if the registry has no such effect).
 fn effect_or_new(ti: &fp::TrackItem, id: &str) -> Option<fp::EffectInstance> {
     ti.effect(id).cloned().or_else(|| fp::find_effect(id).map(|e| e.instance()))
@@ -651,7 +653,9 @@ fn set_effect(ti: &mut fp::TrackItem, e: fp::EffectInstance) {
 /// A property → a FilmCraft parameter (layer-time keys → clip-time keys).
 fn param_out(p: &Property, to_clip: &impl Fn(Tick) -> filmcraft_time::Tick, conv: impl Fn(&Value) -> fp::ParamValue) -> fp::Param {
     let mut out = fp::Param::new(conv(&p.value));
-    for k in &p.keys {
+    // XML timelines have no mute state: leave muted keys out, as the Lottie exporter does, so
+    // the exported animation matches what the renderer shows (#1894).
+    for k in p.keys.iter().filter(|k| !k.muted) {
         let mut fk = fp::Keyframe::new(to_clip(k.time), conv(&k.value));
         fk.interp = match k.out_interp {
             Interp::Linear => fp::Interpolation::Linear,

crates/interchange/src/tests.rs

@@ -480,6 +480,59 @@ fn tr_orig(l: &Layer) -> &effectcraft_project::Property {
     l.transform().unwrap().get("position").unwrap()
 }
 
+/// #1894: XML timelines have no mute state, so a muted key must not be written as a keyframe
+/// (the export would otherwise animate through it).
+#[test]
+fn export_skips_muted_keyframes() {
+    let mut p = Project::default();
+    let a = footage_item(&mut p, "/media/a.mov");
+    let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(4.0));
+    let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+    {
+        let pos = l.transform_mut().unwrap().get_mut("position").unwrap();
+        pos.keys = vec![
+            Keyframe::new(t(0.0), Value::Vec3([100.0, 120.0, 0.0])),
+            Keyframe::new(t(1.0), Value::Vec3([500.0, 240.0, 0.0])),
+            Keyframe::new(t(2.0), Value::Vec3([300.0, 60.0, 0.0])),
+        ];
+        pos.keys[1].muted = true;
+    }
+    c.layers.push(l);
+    let cid = comp_item(&mut p, "Main", c);
+    let out = export(&p, cid, &ExportOptions { format: TimelineFormat::Fcp7Xml, ..Default::default() }, &HashMap::new()).unwrap();
+    let (q, r) = import_doc(&out.bytes, "Main.xml", &mut probe);
+    let main = r.comps.iter().copied().find(|c| q.item(*c).unwrap().name == "Main").expect("Main");
+    let pos = layer(q.comp(main).unwrap(), "clip").transform().unwrap().get("position").unwrap();
+    assert_eq!(pos.keys.len(), 2, "the muted key was exported");
+    assert_eq!(pos.keys[0].value.as_vec3()[0], 100.0);
+    assert_eq!(pos.keys[1].value.as_vec3()[0], 300.0);
+}
+
+/// #1894: a muted non-uniform scale key must not force a uniform layer to pre-render; only the
+/// active keys matter, and the static value when every key is muted.
+#[test]
+fn muted_non_uniform_scale_does_not_force_prerendering() {
+    let mut p = Project::default();
+    let a = footage_item(&mut p, "/media/a.mov");
+    let mut c = Comp::new(W, H, FrameRate::new(25, 1), t(2.0));
+    let mut l = effectcraft_project::build::layer(&mut p, &c, "clip", LayerSource::Footage { item: a }, (W, H), None);
+    {
+        let scale = l.transform_mut().unwrap().get_mut("scale").unwrap();
+        scale.keys = vec![Keyframe::new(t(0.0), Value::Vec3([100.0, 100.0, 100.0])), Keyframe::new(t(1.0), Value::Vec3([50.0, 200.0, 100.0]))];
+        scale.keys[1].muted = true;
+    }
+    let lid = l.id;
+    c.layers.push(l);
+    let cid = comp_item(&mut p, "Main", c);
+    assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()), None);
+    // With every key muted the static value drives evaluation, so a non-uniform static scale
+    // still takes the flattened path.
+    let scale = p.comp_mut(cid).unwrap().layer_mut(lid).unwrap().transform_mut().unwrap().get_mut("scale").unwrap();
+    scale.keys[0].muted = true;
+    scale.value = Value::Vec3([50.0, 200.0, 100.0]);
+    assert_eq!(prerender_reason(&p, cid, lid, &ExportOptions::default()).as_deref(), Some("non-uniform scale"));
+}
+
 #[test]
 fn export_without_prerender_leaves_text_out() {
     let (p, cid) = ae_project();

crates/keyframe/src/lib.rs

@@ -15,6 +15,7 @@ pub mod value;
 
 use effectcraft_time::{TICKS_PER_SECOND, Tick};
 use serde::{Deserialize, Serialize};
+use std::borrow::Borrow;
 pub use text_doc::{BaselineOption, CharStyle, Composer, Direction, FigureStyle, FigureWidth, Kerning, LineJoin, OpenType, ParaStyle, StyleRun};
 pub use value::{FeatherPoint, Gradient, Justify, ShapePath, TextDoc, Value};
 
@@ -89,12 +90,19 @@ pub struct Keyframe {
     /// Keyframe color label: index into the label list (0 = None).
     #[serde(default, skip_serializing_if = "is_zero")]
     pub label: u8,
+    /// Muted keys stay in the list (and the UI) but evaluation skips them.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub muted: bool,
 }
 
 fn is_zero(v: &u8) -> bool {
     *v == 0
 }
 
+fn is_false(v: &bool) -> bool {
+    !*v
+}
+
 fn yes() -> bool {
     true
 }
@@ -116,6 +124,7 @@ impl Keyframe {
             spatial_continuous: false,
             roving: false,
             label: 0,
+            muted: false,
         }
     }
     pub fn hold(mut self) -> Keyframe {
@@ -320,16 +329,16 @@ fn v3(v: &Value) -> [f64; 3] {
 /// tangent is a sixth of the way from the previous key to the next, the in tangent its mirror, and
 /// key times play no part. An end key uses its one neighbour, so the path leaves the first key
 /// and enters the last one toward the neighbouring key instead of with no tangent.
-fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
+fn auto_spatial<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
     if i >= keys.len() || keys.len() < 2 {
         return ([0.0; 3], [0.0; 3]);
     }
-    let a = v3(&keys[i.saturating_sub(1)].value);
-    let c = v3(&keys[(i + 1).min(keys.len() - 1)].value);
+    let a = v3(&keys[i.saturating_sub(1)].borrow().value);
+    let c = v3(&keys[(i + 1).min(keys.len() - 1)].borrow().value);
     let tout = [(c[0] - a[0]) / 6.0, (c[1] - a[1]) / 6.0, (c[2] - a[2]) / 6.0];
     // A side facing a key at the same position gets no tangent, so the segment between two
     // identical keys has zero length and the layer holds still (#1675).
-    let p = v3(&keys[i].value);
+    let p = v3(&keys[i].borrow().value);
     let tin = if i > 0 && a == p { [0.0; 3] } else { [-tout[0], -tout[1], -tout[2]] };
     let tout = if i + 1 < keys.len() && c == p { [0.0; 3] } else { tout };
     (tin, tout)
@@ -337,7 +346,12 @@ fn auto_spatial(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
 
 /// Effective spatial tangents of key `i` (auto or stored).
 pub fn spatial_tangents(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
-    let Some(key) = keys.get(i) else { return ([0.0; 3], [0.0; 3]) };
+    tangents_of(keys, i)
+}
+
+/// [`spatial_tangents`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn tangents_of<K: Borrow<Keyframe>>(keys: &[K], i: usize) -> ([f64; 3], [f64; 3]) {
+    let Some(key) = keys.get(i).map(Borrow::borrow) else { return ([0.0; 3], [0.0; 3]) };
     if key.spatial_auto { auto_spatial(keys, i) } else { (key.spatial_in, key.spatial_out) }
 }
 
@@ -373,18 +387,18 @@ pub fn spatial_handles(keys: &[Keyframe], i: usize) -> ([f64; 3], [f64; 3]) {
 }
 
 /// Effective temporal ease of key `i` for dimension `d` (auto-Bezier keys get the neighbour slope).
-fn effective_ease(keys: &[Keyframe], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
-    let k = &keys[i];
+fn effective_ease<K: Borrow<Keyframe>>(keys: &[K], i: usize, d: usize, spatial: bool, out: bool) -> Ease {
+    let k = keys[i].borrow();
     let list = if out { &k.out_ease } else { &k.in_ease };
     if k.auto_bezier && i > 0 && i + 1 < keys.len() {
-        let dt = secs(keys[i + 1].time) - secs(keys[i - 1].time);
+        let dt = secs(keys[i + 1].borrow().time) - secs(keys[i - 1].borrow().time);
         let slope = if spatial {
-            let a = v3(&keys[i - 1].value);
-            let c = v3(&keys[i + 1].value);
+            let a = v3(&keys[i - 1].borrow().value);
+            let c = v3(&keys[i + 1].borrow().value);
             ((c[0] - a[0]).powi(2) + (c[1] - a[1]).powi(2) + (c[2] - a[2]).powi(2)).sqrt() / dt.max(1e-12)
         } else {
-            let a = keys[i - 1].value.components();
-            let c = keys[i + 1].value.components();
+            let a = keys[i - 1].borrow().value.components();
+            let c = keys[i + 1].borrow().value.components();
             (c.get(d).unwrap_or(&0.0) - a.get(d).unwrap_or(&0.0)) / dt.max(1e-12)
         };
         return Ease { speed: slope, influence: 1.0 / 6.0 };
@@ -508,23 +522,39 @@ pub fn time_reverse(keys: &mut [Keyframe]) {
 }
 
 /// Evaluate a keyframed property at `t`. `spatial` selects motion-path semantics for 2D/3D values.
+/// Muted keys are skipped, so the active neighbours interpolate as if they were not there; `None`
+/// means every key is muted (the property's static value applies).
 pub fn evaluate(keys: &[Keyframe], t: Tick, spatial: bool) -> Option<Value> {
-    let first = keys.first()?;
+    if !keys.iter().any(|k| k.muted) {
+        return evaluate_active(keys, t, spatial);
+    }
+    // Muting is rare: skip the muted keys by reference rather than copying every key and value.
+    let active: Vec<&Keyframe> = keys.iter().filter(|k| !k.muted).collect();
+    evaluate_active(&active, t, spatial)
+}
+
+fn evaluate_active<K: Borrow<Keyframe>>(keys: &[K], t: Tick, spatial: bool) -> Option<Value> {
+    let first = keys.first()?.borrow();
     if keys.len() == 1 || t <= first.time {
         return Some(first.value.clone());
     }
-    let last = keys.last()?;
+    let last = keys.last()?.borrow();
     if t >= last.time {
         return Some(last.value.clone());
     }
-    let i = keys.partition_point(|k| k.time <= t) - 1;
-    Some(segment_value(keys, i, t, spatial))
+    let i = keys.partition_point(|k| k.borrow().time <= t) - 1;
+    Some(segment_value_of(keys, i, t, spatial))
 }
 
 /// Value inside segment `i` → `i+1` at time `t`.
 pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Value {
-    let a = &keys[i];
-    let b = &keys[i + 1];
+    segment_value_of(keys, i, t, spatial)
+}
+
+/// [`segment_value`] over stored keys or a filtered list of them (see [`evaluate`]).
+fn segment_value_of<K: Borrow<Keyframe>>(keys: &[K], i: usize, t: Tick, spatial: bool) -> Value {
+    let a = keys[i].borrow();
+    let b = keys[i + 1].borrow();
     if a.out_interp == Interp::Hold || !a.value.interpolates() {
         return a.value.clone();
     }
@@ -539,8 +569,8 @@ pub fn segment_value(keys: &[Keyframe], i: usize, t: Tick, spatial: bool) -> Val
     if is_spatial {
         let p0 = v3(&a.value);
         let p3 = v3(&b.value);
-        let (_, out_t) = spatial_tangents(keys, i);
-        let (in_t, _) = spatial_tangents(keys, i + 1);
+        let (_, out_t) = tangents_of(keys, i);
+        let (in_t, _) = tangents_of(keys, i + 1);
         let seg = SpatialSeg::new([p0, [p0[0] + out_t[0], p0[1] + out_t[1], p0[2] + out_t[2]], [p3[0] + in_t[0], p3[1] + in_t[1], p3[2] + in_t[2]], p3]);
         let len = seg.length();
         let f = if lin_out && lin_in || len <= 1e-12 {
@@ -617,6 +647,7 @@ pub fn set_key(keys: &mut Vec<Keyframe>, key: Keyframe) -> usize {
             k.spatial_continuous = old.spatial_continuous;
             k.roving = old.roving;
             k.label = old.label;
+            k.muted = old.muted;
             keys[i] = k;
             i
         }

crates/keyframe/src/tests.rs

@@ -395,3 +395,60 @@ proptest::proptest! {
         proptest::prop_assert!((-1e-9..=10.0 + 1e-9).contains(&v));
     }
 }
+
+#[test]
+fn muted_keys_are_skipped_by_evaluation() {
+    let mut keys =
+        vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), Keyframe::new(s(1.0), Value::Scalar(100.0)), Keyframe::new(s(2.0), Value::Scalar(300.0))];
+    let at = |keys: &[Keyframe], t: f64| evaluate(keys, s(t), false).unwrap().as_f64();
+    assert!((at(&keys, 0.5) - 50.0).abs() < 1e-9);
+    assert!((at(&keys, 1.5) - 200.0).abs() < 1e-9);
+    keys[1].muted = true;
+    // The 0 → 300 segment now spans 0 → 2 s.
+    assert!((at(&keys, 0.5) - 75.0).abs() < 1e-9);
+    assert!((at(&keys, 1.0) - 150.0).abs() < 1e-9);
+    assert!((at(&keys, 1.5) - 225.0).abs() < 1e-9);
+    for k in &mut keys {
+        k.muted = true;
+    }
+    assert!(evaluate(&keys, s(0.5), false).is_none());
+}
+
+#[test]
+fn muted_key_automation_uses_the_active_neighbours() {
+    let mut keys = vec![
+        Keyframe::new(s(0.0), Value::Vec2([0.0, 0.0])),
+        Keyframe::new(s(1.0), Value::Vec2([50.0, 100.0])),
+        Keyframe::new(s(2.0), Value::Vec2([100.0, 0.0])),
+    ];
+    for k in &mut keys {
+        k.auto_bezier = true;
+        k.in_interp = Interp::Bezier;
+        k.out_interp = Interp::Bezier;
+    }
+    let all = keys.clone();
+    let mut active = keys.clone();
+    active.remove(1);
+    keys[1].muted = true;
+    for t in [0.0, 0.25, 0.5, 1.0, 1.5, 1.75, 2.0] {
+        assert_eq!(evaluate(&keys, s(t), true), evaluate(&active, s(t), true), "{t}");
+    }
+    // The muted auto-Bezier key no longer bulges the motion path.
+    assert_ne!(evaluate(&keys, s(0.5), true), evaluate(&all, s(0.5), true));
+}
+
+#[test]
+fn mute_round_trips_and_survives_value_replacement() {
+    let mut k = Keyframe::new(s(0.0), Value::Scalar(1.0));
+    let json = serde_json::to_value(&k).unwrap();
+    assert!(json.get("muted").is_none(), "false is the default and is skipped");
+    k.muted = true;
+    let json = serde_json::to_value(&k).unwrap();
+    assert_eq!(json["muted"], serde_json::json!(true));
+    let back: Keyframe = serde_json::from_value(json).unwrap();
+    assert!(back.muted);
+    let mut keys = vec![k];
+    set_key(&mut keys, Keyframe::new(s(0.0), Value::Scalar(2.0)));
+    assert!(keys[0].muted);
+    assert_eq!(keys[0].value, Value::Scalar(2.0));
+}

crates/lottie/src/anim.rs

@@ -73,9 +73,22 @@ fn is_spatial(p: &Property) -> bool {
 }
 
 /// Export a property as a Lottie animatable property (`{a, k}` plus `x` for expressions).
-/// `label` names the property in warnings.
+/// `label` names the property in warnings. Muted keys are omitted: Lottie has no mute state, and
+/// the remaining keys carry the animation the renderer shows.
 pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Json, label: &str) -> Json {
-    let mut out = if p.keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, p, conv)}) };
+    let muted = p.keys.iter().any(|k| k.muted);
+    if muted {
+        ex.warn(format!("{label}: muted keyframes are not exported"));
+    }
+    let active: Vec<Keyframe>;
+    let keys: &[Keyframe] = if muted {
+        active = p.keys.iter().filter(|k| !k.muted).cloned().collect();
+        &active
+    } else {
+        &p.keys
+    };
+    let mut out =
+        if keys.is_empty() { json!({"a": 0, "k": conv(&p.value)}) } else { json!({"a": 1, "k": export_keys(ex, keys, is_spatial(p), p.hold_only, conv)}) };
     if let Some(e) = p.expr.as_ref().filter(|e| e.enabled && !e.text.trim().is_empty()) {
         if ex.include_expressions {
             out["x"] = json!(e.text);
@@ -86,20 +99,18 @@ pub(crate) fn export_prop(ex: &mut Ex, p: &Property, conv: &dyn Fn(&Value) -> Js
     out
 }
 
-fn export_keys(ex: &Ex, p: &Property, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
-    let keys = &p.keys;
-    let spatial = is_spatial(p);
+fn export_keys(ex: &Ex, keys: &[Keyframe], spatial: bool, hold_only: bool, conv: &dyn Fn(&Value) -> Json) -> Vec<Json> {
     let mut out = Vec::with_capacity(keys.len());
     for (i, k) in keys.iter().enumerate() {
         let mut o = json!({"t": r6(ex.tb.frame(k.time)), "s": wrap(conv(&k.value))});
         if i + 1 == keys.len() {
-            if k.out_interp == Interp::Hold || p.hold_only {
+            if k.out_interp == Interp::Hold || hold_only {
                 o["h"] = json!(1);
             }
             out.push(o);
             continue;
         }
-        if k.out_interp == Interp::Hold || p.hold_only || !k.value.interpolates() {
+        if k.out_interp == Interp::Hold || hold_only || !k.value.interpolates() {
             o["h"] = json!(1);
             out.push(o);
             continue;

crates/lottie/src/tests.rs

@@ -878,3 +878,21 @@ fn external_images_are_local_or_skipped() {
     assert_eq!(std::path::Path::new(&paths[0]), base.join("images").join("a.png"));
     assert_eq!(r.warnings.iter().filter(|w| w.contains("is not imported")).count(), assets.len() - 1, "{:?}", r.warnings);
 }
+
+#[test]
+fn muted_keys_are_omitted_from_the_export() {
+    let (mut p, cid) = setup();
+    let mut l = solid_layer(&mut p, cid, [0.0, 1.0, 0.0], 20, 20);
+    let mut b = Keyframe::new(s(1.0), Value::Scalar(100.0));
+    b.muted = true;
+    l.props.prop_mut("transform/opacity").unwrap().keys = vec![Keyframe::new(s(0.0), Value::Scalar(0.0)), b, Keyframe::new(s(2.0), Value::Scalar(300.0))];
+    push(&mut p, cid, l);
+    let (q, nc, warnings, json) = roundtrip(&p, cid, &ExportOptions::default());
+    assert!(warnings.iter().any(|w| w.contains("muted keyframes")), "{warnings:?}");
+    // Lottie has no mute state: the two active keys carry the 0 → 300 animation.
+    assert_eq!(json["layers"][0]["ks"]["o"]["k"].as_array().unwrap().len(), 2);
+    assert_eq!(json["layers"][0]["ks"]["o"]["k"][1]["s"], json!([300.0]));
+    let opacity_at = |p: &Project, cid: ItemId, t: f64| p.comp(cid).unwrap().layers[0].props.prop("transform/opacity").unwrap().value_at(s(t)).as_f64();
+    assert!((opacity_at(&p, cid, 1.0) - 150.0).abs() < 1e-6);
+    assert!((opacity_at(&q, nc, 1.0) - 150.0).abs() < 1e-6);
+}

crates/ui-egui/src/i18n.rs

@@ -836,6 +836,7 @@ const SIMPLIFIED_CHINESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "行落下"),
     ("anim.addKeyframe", "Add Keyframe", "添加关键帧"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "切换定格关键帧"),
+    ("keys.setMuted", "Mute Keyframes", "静音关键帧"),
     ("keys.interpolation", "Keyframe Interpolation...", "关键帧插值..."),
     ("keys.velocity", "Keyframe Velocity...", "关键帧速度..."),
     ("", "Keyframe Assistant", "关键帧辅助"),
@@ -1472,6 +1473,7 @@ const TRADITIONAL_CHINESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "行落下"),
     ("anim.addKeyframe", "Add Keyframe", "新增關鍵影格"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "切換定格關鍵影格"),
+    ("keys.setMuted", "Mute Keyframes", "靜音關鍵影格"),
     ("keys.interpolation", "Keyframe Interpolation...", "關鍵影格插補..."),
     ("keys.velocity", "Keyframe Velocity...", "關鍵影格速度..."),
     ("", "Keyframe Assistant", "關鍵影格輔助"),
@@ -2105,6 +2107,7 @@ const JAPANESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "行をドロップイン"),
     ("anim.addKeyframe", "Add Keyframe", "キーフレームを追加"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "停止したキーフレームの切り替え"),
+    ("keys.setMuted", "Mute Keyframes", "キーフレームをミュート"),
     ("keys.interpolation", "Keyframe Interpolation...", "キーフレーム補間法..."),
     ("keys.velocity", "Keyframe Velocity...", "キーフレーム速度..."),
     ("", "Keyframe Assistant", "キーフレーム補助"),
@@ -2741,6 +2744,7 @@ const UKRAINIAN: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Поява рядків згори"),
     ("anim.addKeyframe", "Add Keyframe", "Додати ключовий кадр"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Перемкнути утримання ключового кадру"),
+    ("keys.setMuted", "Mute Keyframes", "Заглушити ключові кадри"),
     ("keys.interpolation", "Keyframe Interpolation...", "Інтерполяція ключових кадрів..."),
     ("keys.velocity", "Keyframe Velocity...", "Швидкість ключових кадрів..."),
     ("", "Keyframe Assistant", "Помічник ключових кадрів"),
@@ -3378,6 +3382,7 @@ const SPANISH: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Entrada de líneas cayendo"),
     ("anim.addKeyframe", "Add Keyframe", "Añadir fotograma clave"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Conmutar mantener fotograma clave"),
+    ("keys.setMuted", "Mute Keyframes", "Silenciar fotogramas clave"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolación de fotogramas clave..."),
     ("keys.velocity", "Keyframe Velocity...", "Velocidad de fotogramas clave..."),
     ("", "Keyframe Assistant", "Asistente de fotogramas clave"),
@@ -4013,6 +4018,7 @@ const PORTUGUESE: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Entrar com queda de linhas"),
     ("anim.addKeyframe", "Add Keyframe", "Adicionar quadro-chave"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Alternar quadro-chave de retenção"),
+    ("keys.setMuted", "Mute Keyframes", "Silenciar quadros-chave"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolação de quadro-chave..."),
     ("keys.velocity", "Keyframe Velocity...", "Velocidade do quadro-chave..."),
     ("", "Keyframe Assistant", "Assistente de quadro-chave"),
@@ -4655,6 +4661,7 @@ const RUSSIAN: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Появление строк сверху"),
     ("anim.addKeyframe", "Add Keyframe", "Добавить ключевой кадр"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Переключить фиксацию ключевого кадра"),
+    ("keys.setMuted", "Mute Keyframes", "Отключить ключевые кадры"),
     ("keys.interpolation", "Keyframe Interpolation...", "Интерполяция ключевых кадров..."),
     ("keys.velocity", "Keyframe Velocity...", "Скорость ключевых кадров..."),
     ("", "Keyframe Assistant", "Помощник по ключевым кадрам"),
@@ -5290,6 +5297,7 @@ const FRENCH: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Chute des lignes depuis le haut"),
     ("anim.addKeyframe", "Add Keyframe", "Ajouter une image clé"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Activer/Désactiver l'image clé figée"),
+    ("keys.setMuted", "Mute Keyframes", "Désactiver les images clés"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolation des images clés..."),
     ("keys.velocity", "Keyframe Velocity...", "Vitesse des images clés..."),
     ("", "Keyframe Assistant", "Assistant d'images clés"),
@@ -5925,6 +5933,7 @@ const GERMAN: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Zeilen fallen ein"),
     ("anim.addKeyframe", "Add Keyframe", "Keyframe hinzufügen"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Halte-Keyframe umschalten"),
+    ("keys.setMuted", "Mute Keyframes", "Keyframes stummschalten"),
     ("keys.interpolation", "Keyframe Interpolation...", "Keyframe-Interpolation..."),
     ("keys.velocity", "Keyframe Velocity...", "Keyframe-Geschwindigkeit..."),
     ("", "Keyframe Assistant", "Keyframe-Assistent"),
@@ -6561,6 +6570,7 @@ const CZECH: &[(&str, &str, &str)] = &[
     ("layer.applyTextPreset", "Drop In Lines", "Spustit řádky shora"),
     ("anim.addKeyframe", "Add Keyframe", "Přidat klíčový snímek"),
     ("keys.toggleHold", "Toggle Hold Keyframe", "Přepnout podržení klíčového snímku"),
+    ("keys.setMuted", "Mute Keyframes", "Ztlumit klíčové snímky"),
     ("keys.interpolation", "Keyframe Interpolation...", "Interpolace klíčových snímků..."),
     ("keys.velocity", "Keyframe Velocity...", "Rychlost klíčového snímku..."),
     ("", "Keyframe Assistant", "Pomocník klíčových snímků"),

crates/ui-egui/src/panels/graph.rs

@@ -48,9 +48,21 @@ struct KeyPt {
     t: f64,
     v: f64,
     sel: bool,
+    muted: bool,
     handles: Vec<Handle>,
 }
 
+/// A graph key's fill and edge colours: muted keys stay visible and selectable, dimmed.
+fn key_colors(t: &Tokens, edge: Color32, k: &KeyPt) -> (Color32, Color32) {
+    let fill = match (k.muted, k.sel) {
+        (true, true) => t.keyframe_selected.gamma_multiply(0.5),
+        (true, false) => Color32::from_gray(0x70),
+        (false, true) => t.keyframe_selected,
+        (false, false) => Color32::from_gray(0xe0),
+    };
+    (fill, if k.muted { edge.gamma_multiply(0.4) } else { edge })
+}
+
 struct Curve<'a> {
     layer: &'a Layer,
     prop: &'a Property,
@@ -153,7 +165,7 @@ fn curves<'a>(app: &EffectcraftApp, comp: &'a Comp, ectx: &EvalCtx, tm: TMap, pl
                     let dt = e.influence * dur * if out_side { 1.0 } else { -1.0 };
                     let (hv, show) = if speed { (e.speed.abs(), true) } else { (k.value.components().get(d).copied().unwrap_or(0.0) + e.speed * dt, !spatial) };
                     let bezier = if out_side { k.out_interp == Interp::Bezier } else { k.in_interp == Interp::Bezier };
-                    if ks && show && (bezier || speed) {
+                    if ks && !k.muted && show && (bezier || speed) {
                         handles.push(Handle { out: out_side, t: kt + dt, v: hv, speed: e.speed, dur });
                     }
                 }
@@ -162,7 +174,7 @@ fn curves<'a>(app: &EffectcraftApp, comp: &'a Comp, ectx: &EvalCtx, tm: TMap, pl
                 } else {
                     k.value.components().get(d).copied().unwrap_or(0.0)
                 };
-                keys.push(KeyPt { idx: i, time: k.time, t: kt, v, sel: ks, handles });
+                keys.push(KeyPt { idx: i, time: k.time, t: kt, v, sel: ks, muted: k.muted, handles });
             }
             out.push(Curve { layer: l, prop: pr, dim: d, color, pts, keys, editable: !spatial });
         }
@@ -522,9 +534,9 @@ pub(crate) fn show(app: &mut EffectcraftApp, ui: &mut egui::Ui, p: &egui::Painte
                 }
             }
             // The key itself.
-            let col = if k.sel { t.keyframe_selected } else { Color32::from_gray(0xe0) };
+            let (col, edge) = key_colors(&t, c.color, k);
             pc.rect_filled(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, col);
-            pc.rect_stroke(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, Stroke::new(1.0, c.color), StrokeKind::Outside);
+            pc.rect_stroke(Rect::from_center_size(kp, vec2(7.0, 7.0)), 0.0, Stroke::new(1.0, edge), StrokeKind::Outside);
             let kr = Rect::from_center_size(kp, vec2(11.0, 11.0));
             let kresp = ui.interact(kr, egui::Id::unique(("gkey", uid, d, k.idx)), Sense::click_and_drag());
             app.auto.add(&format!("timeline.graph.key.{uid}.{d}.{}", k.idx), kr, &c.prop.name);

crates/ui-egui/src/panels/timeline.rs

@@ -4111,6 +4111,7 @@ fn key_context_menu(app: &mut EffectcraftApp, g: &mut Rw, rc: &RowCtx<'_>, prop:
             ("Keyframe Interpolation…", "keys.interpolation", json!({})),
             ("Keyframe Velocity…", "keys.velocity", json!({})),
             ("Toggle Hold Keyframe", "keys.toggleHold", json!({})),
+            (if k.muted { "Unmute Keyframes" } else { "Mute Keyframes" }, "keys.setMuted", json!({"muted": !k.muted})),
             ("Rove Across Time", "keys.interpolation", json!({"roving": !k.roving})),
             ("-", "", json!({})),
             ("Easy Ease", "keys.easyEase", json!({})),
@@ -4203,6 +4204,8 @@ fn key_paint(g: &Rw, rc: &RowCtx<'_>, k: &effectcraft_engine::keyframe::Keyframe
         None if ks => t.keyframe_selected,
         None => t.keyframe,
     };
+    // Muted keys stay visible and editable but no longer drive the value.
+    let kcol = if k.muted { kcol.gamma_multiply(0.35) } else { kcol };
     if k.roving {
         // Roving keys: a small dot (their time follows their neighbours).
         gp.circle_filled(c, 2.5, kcol);

crates/ui-egui/src/panels/viewer_overlays.rs

@@ -360,31 +360,36 @@ pub(crate) fn motion_path(
         }
         let v = k.value.as_vec3();
         let s = to_scr(v);
-        // Auto-Bezier keys show handles on a side the path leaves straight too (a two-key path's
-        // ends), to drag it into a curve; Linear keys (no tangents) show none.
-        let (tin, tout) = if k.spatial_auto {
-            effectcraft_engine::keyframe::spatial_handles(&pos.keys, i)
-        } else {
-            effectcraft_engine::keyframe::spatial_tangents(&pos.keys, i)
-        };
-        for (out, tg) in [(false, tin), (true, tout)] {
-            let has = (out && i + 1 < pos.keys.len()) || (!out && i > 0);
-            if !has || (tg[0] == 0.0 && tg[1] == 0.0) {
-                continue;
+        let selected = sel.contains(&KeyRef { layer: l.id, prop: pos.uid, time: k.time });
+        // A muted position key is off the motion path: no tangents, and a dimmed point.
+        let kc = if k.muted { col.gamma_multiply(if selected { 0.55 } else { 0.35 }) } else { col };
+        if !k.muted {
+            // Auto-Bezier keys show handles on a side the path leaves straight too (a two-key path's
+            // ends), to drag it into a curve; Linear keys (no tangents) show none.
+            let (tin, tout) = if k.spatial_auto {
+                effectcraft_engine::keyframe::spatial_handles(&pos.keys, i)
+            } else {
+                effectcraft_engine::keyframe::spatial_tangents(&pos.keys, i)
+            };
+            for (out, tg) in [(false, tin), (true, tout)] {
+                let has = (out && i + 1 < pos.keys.len()) || (!out && i > 0);
+                if !has || (tg[0] == 0.0 && tg[1] == 0.0) {
+                    continue;
+                }
+                let h = to_scr([v[0] + tg[0], v[1] + tg[1], v[2] + tg[2]]);
+                painter.line_segment([s, h], Stroke::new(1.0, kc));
+                painter.circle_filled(h, 3.0, kc);
+                let side = if out { "out" } else { "in" };
+                app.auto.add(&format!("viewer.motionPath.{}.{i}.{side}", l.id.0), Rect::from_center_size(h, vec2(8.0, 8.0)), "Spatial tangent");
+                hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: h, tangent: Some(out), value: v, p2c });
             }
-            let h = to_scr([v[0] + tg[0], v[1] + tg[1], v[2] + tg[2]]);
-            painter.line_segment([s, h], Stroke::new(1.0, col));
-            painter.circle_filled(h, 3.0, col);
-            let side = if out { "out" } else { "in" };
-            app.auto.add(&format!("viewer.motionPath.{}.{i}.{side}", l.id.0), Rect::from_center_size(h, vec2(8.0, 8.0)), "Spatial tangent");
-            hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: h, tangent: Some(out), value: v, p2c });
         }
         let r = Rect::from_center_size(s, vec2(7.0, 7.0));
-        if sel.contains(&KeyRef { layer: l.id, prop: pos.uid, time: k.time }) {
-            painter.rect_filled(r, 0.0, col);
+        if selected {
+            painter.rect_filled(r, 0.0, kc);
         } else {
             painter.rect_filled(r, 0.0, Color32::from_black_alpha(140));
-            painter.rect_stroke(r, 0.0, Stroke::new(1.0, col), StrokeKind::Inside);
+            painter.rect_stroke(r, 0.0, Stroke::new(1.0, kc), StrokeKind::Inside);
         }
         app.auto.add(&format!("viewer.motionPath.{}.{i}", l.id.0), r.expand(2.0), "Position keyframe");
         hits.push(KeyHit { layer: l.id, prop: pos.uid, time: k.time, pos: s, tangent: None, value: v, p2c });