@@ -873,9 +873,8 @@ protected static void registerCommandFinderAccelerator(final InputMap sntIMap, f
         sntAMap.put(actionKey, commandFinder.getToggleVisibilityAction());
     }
 
-    /** Auto-incrementing counter for keyframe identifiers (K hotkey) */
-    private static final java.util.concurrent.atomic.AtomicInteger keyframeCounter =
-            new java.util.concurrent.atomic.AtomicInteger(1);
+    /** Script-ready lines of the keyframes captured with the K hotkey since the last reset */
+    private final List<String> capturedKeyframes = new ArrayList<>();
 
     /**
      * Registers SNT's viewer keybindings shared by Bvv and Bdv: {@code M} (marker), {@code H}
@@ -933,9 +932,10 @@ protected void registerSntKeybindings(final InputMap sntIMap, final ActionMap sn
     }
 
     /**
-     * Registers the {@code K} hotkey that captures a {@link Keyframe}: the script-ready line is
-     * printed to the console and copied to the clipboard. Same {@code sntIMap}/{@code sntAMap}
-     * constraints as {@link #registerCommandFinderAccelerator}.
+     * Registers the keyframe hotkeys: {@code K} captures a {@link Keyframe} and appends it to a running
+     * script-ready {@code kfs} block that is printed to the console and copied to the clipboard, and
+     * {@code Shift+K} clears that block. Same {@code sntIMap}/{@code sntAMap} constraints as
+     * {@link #registerCommandFinderAccelerator}.
      *
      * @param sntIMap the viewer's own SNT-overlay {@link InputMap}, not yet installed
      * @param sntAMap the matching {@link ActionMap}, not yet installed
@@ -946,18 +946,32 @@ protected void registerKeyframeCapture(final InputMap sntIMap, final ActionMap s
             @Override
             public void actionPerformed(final ActionEvent e) {
                 try {
-                    final int id = keyframeCounter.getAndIncrement();
-                    final String scriptLine = String.format("kf%02d = new Keyframe(\"%s\")", id,
-                            captureKeyframe());
-                    System.out.println(scriptLine);
-                    showViewerMessage("Keyframe #" + id + " captured");
+                    final String line = String.format("    new Keyframe(\"%s\")\n\t.frames(60).accel(\"symmetric\"),",
+                            captureKeyframe().toString(false));
+                    final String block;
+                    synchronized (capturedKeyframes) {
+                        capturedKeyframes.add(line);
+                        block = "def kfs = [\n" + String.join("\n", capturedKeyframes) + "\n]";
+                        showViewerMessage("Keyframe #" + capturedKeyframes.size() + " captured (copied)");
+                    }
+                    System.out.println(block);
                     java.awt.Toolkit.getDefaultToolkit().getSystemClipboard()
-                            .setContents(new java.awt.datatransfer.StringSelection(scriptLine), null);
+                            .setContents(new java.awt.datatransfer.StringSelection(block), null);
                 } catch (final Exception ex) {
                     SNTUtils.log("Keyframe capture failed: " + ex.getMessage());
                 }
             }
         });
+        sntIMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_K, InputEvent.SHIFT_DOWN_MASK), "snt-clear-keyframes");
+        sntAMap.put("snt-clear-keyframes", new AbstractAction() {
+            @Override
+            public void actionPerformed(final ActionEvent e) {
+                synchronized (capturedKeyframes) {
+                    capturedKeyframes.clear();
+                }
+                showViewerMessage("Captured keyframes cleared");
+            }
+        });
     }
 
     /**
@@ -1411,6 +1425,12 @@ protected JComponent tracingStatusRow(final Actions actions, final AbstractTrace
     }
 
     protected class Actions {
+        private GuiUtils guiUtils;
+        // State for hide-annotations (H key) press/release tracking
+        float lastClippingDistance = 100f;
+        private boolean hideActive;
+        private boolean pathsWereVisible;
+        private boolean annotationsWereVisible;
 
         Action loadSettingsAction() {
             return new AbstractAction("Load Settings...", IconFactory.menuIcon(IconFactory.GLYPH.IMPORT)) {
@@ -1468,13 +1488,6 @@ public void actionPerformed(final ActionEvent e) {
                 }
             };
         }
-        private GuiUtils guiUtils;
-        // State for hide-annotations (H key) press/release tracking
-        float lastClippingDistance = 100f;
-        private boolean hideActive;
-        private boolean pathsWereVisible;
-        private boolean annotationsWereVisible;
-
 
         /**
          * Creates an {@link Action} that calls {@code onToggle} with the toggle button's
 
@@ -219,13 +219,47 @@ private String getAccelNameSerialized() {
         return getAccelName().replace(' ', '_');
     }
 
+    /**
+     * Sets the transition length (chainable, for scripts).
+     *
+     * @param frames number of frames of the transition into this keyframe
+     * @return this keyframe
+     */
+    public Keyframe frames(final int frames) {
+        this.frames = frames;
+        return this;
+    }
+
+    /**
+     * Sets the easing type by name (chainable, for scripts).
+     *
+     * @param name the easing name, see {@link #setAccel(String)}
+     * @return this keyframe
+     */
+    public Keyframe accel(final String name) {
+        setAccel(name);
+        return this;
+    }
+
     /**
      * Serializes this keyframe to a single-line string:
      * {@code transform=d0,d1,...,d11|cam=dCam,near,far|visible=a;b;c|accel=name|frames=N|t=N|display=i:min,max,#RRGGBB;...}
      * (the timepoint and display entries are omitted if unspecified).
      */
     @Override
     public String toString() {
+        return toString(true);
+    }
+
+    /**
+     * Serializes this keyframe, optionally leaving out the timing entries ({@code accel} and
+     * {@code frames}), e.g., when they are set separately through {@link #frames(int)} and
+     * {@link #accel(String)}.
+     *
+     * @param includeTiming whether to include the {@code accel} and {@code frames} entries
+     * @return the serialized keyframe
+     */
+    public String toString(final boolean includeTiming) {
         final StringBuilder sb = new StringBuilder("transform=");
         final double[] m = transform.getRowPackedCopy();
         for (int i = 0; i < m.length; i++) {
@@ -236,8 +270,10 @@ public String toString() {
         // Sanitize actor names: replace ';' to avoid breaking the delimiter
         sb.append("|visible=").append(visibleActors.stream().map(a -> a.replace(';', '_'))
                 .collect(Collectors.joining(";")));
-        sb.append("|accel=").append(getAccelNameSerialized());
-        sb.append("|frames=").append(frames);
+        if (includeTiming) {
+            sb.append("|accel=").append(getAccelNameSerialized());
+            sb.append("|frames=").append(frames);
+        }
         if (timepoint > 0) sb.append("|t=").append(timepoint);
         if (!display.isEmpty()) {
             sb.append("|display=").append(display.entrySet().stream().map(e -> {
 
@@ -5,24 +5,30 @@
  * # Workflow
  * 1. Open your data in SNT's BVV or BDV
  * 2. Navigate to a view you like and press 'K' to capture a keyframe.
- *    Each press prints a line to the console, e.g.:
- *      kf00 = new Keyframe("transform=...|cam=...|visible=...|accel=symmetric|frames=60")
- *    The line is also copied to the clipboard.
+ *    Each press appends a line to a running 'kfs' block that is printed to the console and
+ *    copied to the clipboard, e.g.:
+ *      def kfs = [
+ *        new Keyframe("transform=...|cam=...|visible=...")
+ *          .frames(60).accel("symmetric"),
+ *      ]
  * 3. Repeat for each viewpoint (rotate, zoom, toggle channels, adjust slab, annotations, etc.)
- * 4. Paste all captured keyframes into this script, set the output directory, and run it.
+ *    Press Shift+K to discard the captured keyframes and start over
+ * 4. Paste the block into this script (replacing the 'kfs' definition below), adjust the frames
+ *    and accel of each keyframe, set the output directory, and run it.
  *
  * # Keyframes and Keyframe Options
  *
  * A keyframe stores viewer transform (rotation/zoom/pan), camera depth and slab clipping (BVV only),
  * timepoint, display levels and LUT colors (both interpolated between keyframes), visible
  * channels/paths/annotations, easing curve, and the number of frames for the transition into that
- * keyframe. A serialized keyframe looks like this:
- *   kf01 = new Keyframe("transform=0.8,-0.6,0,100,0.6,0.8,0,-200,0,0,1.0,-300|cam=2000,800,800|visible=vol:Ch1;vol:Ch2;paths|accel=slow_start|frames=90")
+ * keyframe. A captured keyframe looks like this:
+ *   new Keyframe("transform=0.8,-0.6,0,100,0.6,0.8,0,-200,0,0,1.0,-300|cam=2000,800,800|visible=vol:Ch1;vol:Ch2;paths")
+ *       .frames(90).accel("slow_start")
  *
- * You can adjust per-keyframe properties after capture:
+ * Edit the trailing calls to adjust the transition into each keyframe:
  *
- *   kf.frames = 90          // transition length (default 60: 2s at 30fps)
- *   kf.setAccel("slow_end") // see acceleration mode
+ *   .frames(90) // transition length (default 60: 2s at 30fps)
+ *   .accel("slow_end") // see acceleration modes
  *
  * Acceleration modes (cosine-based easing curves):
  *   "symmetric"        Ease in and out equally (smooth start and stop)
@@ -34,50 +40,37 @@
  *
  * Tips:
  *  - "slow_end" may work well for approaching a structure; "slow_start" for pulling away.
- *     "symmetric" is likely the safest default for most transitions
+ *  - "symmetric" is likely the safest default for most transitions
  *  - The 'frames' value of the first Keyframe is ignored since it is the starting pose
+ *  - See the 'Recipes' section below for functions that edit recorded keyframes
  */
 
 
 // Retrieve the most recently created Bvv (or Bdv) instance
 def viewer = Bvv.getInstance() ?: Bdv.getInstance()
 
 if (viewer == null) {
-    println "ERROR: There is no active Bvv or Bdv instance"
-    return
+	println "ERROR: There is no active Bvv or Bdv instance"
+	return
 }
 
-// Paste your captured keyframes here (press K in the viewer to capture each one):
-// kf00 = new Keyframe("...")
-// kf01 = new Keyframe("...")
-// kf02 = new Keyframe("...")
-
-// Then list them in playback order:
+// Paste the keyframes block copied by the K key here (in playback order):
 def kfs = [
-    // kf00,
-    // kf01,
-    // kf02,
+	// new Keyframe("...")
+	//     .frames(60).accel("symmetric"),
+	// new Keyframe("...")
+	//     .frames(60).accel("symmetric"),
 ]
 
-// Recipe: flip the movie vertically. A plain Y mirror cannot be interpolated between keyframes, so
-// this rotates 180 degrees about the screen X axis instead (same result for a 2D slice). Uncomment
-// to use:
-// def flipY = { kf, height ->
-//     def f = new AffineTransform3D()
-//     f.set(1, 0, 0, 0,
-//           0, -1, 0, height, // y' = -y + height (mirror about the canvas center)
-//           0, 0, -1, 0)      // z' = -z keeps the transform a proper rotation
-//     kf.transform.preConcatenate(f)
-// }
-// kfs.each { flipY(it, viewer.getViewerCanvas().height) }
+// Optional edits of the keyframes above (see Recipes below), to be applied before playback/rendering:
+// kfs.each { flipY(it, viewer.getViewerCanvas().height) } // flip vertically
 
 if (kfs.isEmpty()) {
-    println "ERROR: No keyframes defined. Press K in the viewer to capture keyframes,"
-    println "  then paste them above and add them to the kfs list."
-    return
+	println "ERROR: No keyframes defined. Press K in the viewer to capture keyframes,"
+	println "  then paste the copied block above."
+	return
 }
 
-
 def dryRun = true // Set to false to save animation sequence instead of live preview
 if (dryRun) {
 
@@ -90,7 +83,7 @@ if (dryRun) {
 	// viewer.playback(kfs[1..3])  // equivalent using Groovy list slicing
 
 } else {
-	
+
 	// Render to image sequence. Defining first the output directory
 	// (replace it with your preferred file path)
 	def outputDir = new File(System.properties['user.home'], "Desktop/snapshots").tap { mkdirs() }
@@ -99,6 +92,21 @@ if (dryRun) {
 	println "  ffmpeg -framerate 30 -i ${outputDir}/frame_%05d.png -c:v libx264 -pix_fmt yuv420p movie.mp4"
 }
 
+// Recipes below
+
+/**
+ * Flip the movie vertically. A plain Y mirror cannot be interpolated between keyframes, so this rotates 180 degrees
+ * about the screen X axis instead (same result for a 2D slice). Call it on each keyframe before
+ * playback/rendering (see 'kfs.each' above)
+ */
+def flipY(kf, height) {
+	def f = new AffineTransform3D()
+	f.set(1, 0, 0, 0,
+		0, -1, 0, height, // y' = -y + height (mirror about the canvas center)
+		0, 0, -1, 0) // z' = -z keeps the transform a proper rotation
+	kf.transform.preConcatenate(f)
+}
+
 
 // Imports below
 import sc.fiji.snt.viewer.Bvv