@@ -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
 
@@ -62,6 +62,12 @@ public class Keyframe {
      * keyframes. A value {@code <= 0} means "unspecified": the viewer's timepoint is left untouched.
      */
     public int timepoint = -1;
+    /**
+     * Viewer (canvas) size in pixels at capture, or {@code -1} if unspecified. The viewer transform is
+     * in screen pixels, so it depends on the canvas size: see {@link #transformFor(int, int)}.
+     */
+    public int width = -1, height = -1;
+
     /**
      * Per-source display settings (levels and LUT color), keyed by 0-based source index. Interpolated
      * between keyframes for sources present in both; sources absent from the map are left untouched.
@@ -162,6 +168,8 @@ public Keyframe(final String serialized) {
         this.frames = parsed.frames;
         this.timepoint = parsed.timepoint;
         this.display.putAll(parsed.display);
+        this.width = parsed.width;
+        this.height = parsed.height;
     }
 
     public Keyframe(final AffineTransform3D transform, final double dCam, final double nearClip,
@@ -219,13 +227,66 @@ private String getAccelNameSerialized() {
         return getAccelName().replace(' ', '_');
     }
 
+    /**
+     * Returns a copy of the viewer transform adjusted to a canvas of the given size. Mirrors what the
+     * viewer does when resized (the scene center stays at the canvas center): the translation is
+     * shifted by half the size difference. The transform is returned unchanged if this keyframe has
+     * no recorded size.
+     *
+     * @param canvasWidth  the current canvas width in pixels
+     * @param canvasHeight the current canvas height in pixels
+     * @return a new transform
+     */
+    public AffineTransform3D transformFor(final int canvasWidth, final int canvasHeight) {
+        final AffineTransform3D t = transform.copy();
+        if (width > 0 && height > 0) {
+            t.set(t.get(0, 3) + 0.5 * (canvasWidth - width), 0, 3);
+            t.set(t.get(1, 3) + 0.5 * (canvasHeight - height), 1, 3);
+        }
+        return t;
+    }
+
+    /**
+     * 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).
+     * {@code transform=d0,d1,...,d11|cam=dCam,near,far|visible=a;b;c|accel=name|frames=N|t=N|size=WxH|display=i:min,max,#RRGGBB;...}
+     * (the timepoint, size 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,9 +297,12 @@ 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 (width > 0 && height > 0) sb.append("|size=").append(width).append('x').append(height);
         if (!display.isEmpty()) {
             sb.append("|display=").append(display.entrySet().stream().map(e -> {
                 final SourceDisplay d = e.getValue();
@@ -290,6 +354,12 @@ public static Keyframe fromString(final String s) {
             final int frames = Integer.parseInt(parts.getOrDefault("frames", "60"));
             final Keyframe kf = new Keyframe(t, dc, nc, fc, vis, accel, frames);
             kf.timepoint = Integer.parseInt(parts.getOrDefault("t", "-1"));
+            final String sizeStr = parts.getOrDefault("size", "");
+            if (!sizeStr.isBlank()) {
+                final String[] wh = sizeStr.split("x");
+                kf.width = Integer.parseInt(wh[0].trim());
+                kf.height = Integer.parseInt(wh[1].trim());
+            }
             final String dispStr = parts.getOrDefault("display", "");
             if (!dispStr.isBlank()) {
                 for (final String entry : dispStr.split(";")) {
 
@@ -83,6 +83,8 @@ Keyframe capture() {
         if (ann != null && ann.isVisible()) actors.add("annotations");
         final Keyframe kf = new Keyframe(viewer.getViewerTransform(), cam[0], cam[1], cam[2], actors, 0);
         kf.timepoint = viewer.getCurrentTimepoint();
+        kf.width = viewer.getViewerWidth();
+        kf.height = viewer.getViewerHeight();
         final ConverterSetups setups = viewer.getConverterSetups();
         if (setups != null) {
             for (int i = 0; i < srcs.size(); i++) {
@@ -152,6 +154,33 @@ private void showAndWait(final AffineTransform3D t, final int timepoint,
         });
     }
 
+    /**
+     * Creates the animator interpolating between two transforms. The animator is probed at both ends: if
+     * it does not reproduce the keyframes (e.g., because it adds the center offset {@code cX/cY} to the
+     * translation, shifting the whole scene), the inputs are pre-shifted to compensate.
+     */
+    private static SimilarityTransformAnimator animatorFor(final AffineTransform3D a, final AffineTransform3D b,
+                                                           final double cX, final double cY) {
+        SimilarityTransformAnimator animator = new SimilarityTransformAnimator(a, b, cX, cY, 0);
+        final double[] d0 = offset(animator.get(0), a);
+        final double[] d1 = offset(animator.get(1), b);
+        if (Math.abs(d0[0]) > 1e-3 || Math.abs(d0[1]) > 1e-3 || Math.abs(d1[0]) > 1e-3 || Math.abs(d1[1]) > 1e-3) {
+            animator = new SimilarityTransformAnimator(shifted(a, d0), shifted(b, d1), cX, cY, 0);
+        }
+        return animator;
+    }
+
+    private static double[] offset(final AffineTransform3D actual, final AffineTransform3D expected) {
+        return new double[] { actual.get(0, 3) - expected.get(0, 3), actual.get(1, 3) - expected.get(1, 3) };
+    }
+
+    private static AffineTransform3D shifted(final AffineTransform3D t, final double[] delta) {
+        final AffineTransform3D copy = t.copy();
+        copy.set(t.get(0, 3) - delta[0], 0, 3);
+        copy.set(t.get(1, 3) - delta[1], 1, 3);
+        return copy;
+    }
+
     private static boolean saveFrame(final Component canvas, final File dir, final int index) {
         final BufferedImage bi = new BufferedImage(canvas.getWidth(), canvas.getHeight(),
                 BufferedImage.TYPE_INT_RGB);
@@ -181,16 +210,24 @@ void render(final List<Keyframe> keyframes, final String outputDir) {
             throw new IllegalArgumentException("Cannot create output directory: " + outputDir);
 
         final Component canvas = viewer.getViewerCanvas();
-        final int cX = canvas.getWidth() / 2;
-        final int cY = canvas.getHeight() / 2;
+        // Use the viewer's own notion of its size (the one its transform is centered on), which
+        // is not necessarily the size of the canvas component, and adjust keyframes captured at another size
+        final int vw = viewer.getViewerWidth();
+        final int vh = viewer.getViewerHeight();
+        final int cX = vw / 2;
+        final int cY = vh / 2;
+        final AffineTransform3D[] transforms = new AffineTransform3D[keyframes.size()];
+        for (int k = 0; k < transforms.length; k++) {
+            final Keyframe kf = keyframes.get(k);
+            transforms[k] = kf.transformFor(vw, vh);
+        }
         int globalFrame = 0;
         try {
             for (int k = 1; k < keyframes.size(); k++) {
                 final Keyframe from = keyframes.get(k - 1);
                 final Keyframe to = keyframes.get(k);
                 final int nFrames = to.frames;
-                final SimilarityTransformAnimator animator = new SimilarityTransformAnimator(
-                        from.transform, to.transform, cX, cY, 0);
+                final SimilarityTransformAnimator animator = animatorFor(transforms[k - 1], transforms[k], cX, cY);
                 final boolean interpolateT = from.timepoint > 0 && to.timepoint > 0;
                 // Visibility and cam/slab snap at keyframe boundaries
                 applyState(from);
@@ -210,7 +247,7 @@ void render(final List<Keyframe> keyframes, final String outputDir) {
             }
             final Keyframe last = keyframes.getLast();
             applyState(last);
-            showAndWait(last.transform, last.timepoint, last.display);
+            showAndWait(transforms[transforms.length - 1], last.timepoint, last.display);
             if (save) {
                 Thread.sleep(100); // allow final render
                 saveFrame(canvas, dir, globalFrame);
@@ -223,8 +260,11 @@ void render(final List<Keyframe> keyframes, final String outputDir) {
             SNTUtils.log("Movie render failed at frame " + globalFrame + ": " + e.getMessage());
             return;
         }
-        if (save)
-            System.out.println("Movie: " + (globalFrame + 1) + " frames saved to " + dir.getAbsolutePath());
+        if (save) {
+            VideoInstructions.write(dir, 30, "frame_%05d.png");
+            System.out.println("Movie: " + (globalFrame + 1) + " frames saved to " + dir.getAbsolutePath()
+                    + " (see " + VideoInstructions.FILE_NAME + " to assemble the video)");
+        }
         else
             System.out.println("Playback complete: " + (globalFrame + 1) + " frames");
     }
 
@@ -0,0 +1,79 @@
+/*-
+ * #%L
+ * Fiji distribution of ImageJ for the life sciences.
+ * %%
+ * Copyright (C) 2010 - 2026 Fiji developers.
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/gpl-3.0.html>.
+ * #L%
+ */
+
+package sc.fiji.snt.viewer;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+
+/**
+ * Writes the instructions on how to assemble a recorded image sequence into a video using ffmpeg.
+ * Shared by {@link Viewer3D} and the {@link Bvv}/{@link Bdv} keyframe recorder.
+ */
+final class VideoInstructions {
+
+    static final String FILE_NAME = "-build-video.txt";
+
+    private VideoInstructions() {
+    }
+
+    /**
+     * Writes {@value #FILE_NAME} into the folder of the image sequence. If the file cannot be written,
+     * the instructions are printed to the console instead.
+     *
+     * @param dir          the folder holding the image sequence
+     * @param fps          the frame rate of the video
+     * @param inputPattern the ffmpeg input pattern of the frames, e.g., {@code frame_%05d.png}
+     */
+    static void write(final File dir, final int fps, final String inputPattern) {
+        final String text = build(dir, fps, inputPattern);
+        try {
+            Files.writeString(new File(dir, FILE_NAME).toPath(), text);
+        } catch (final IOException e) {
+            System.out.println(text);
+        }
+    }
+
+    static String build(final File dir, final int fps, final String inputPattern) {
+        final StringBuilder sb = new StringBuilder(
+                "The image sequence can be converted into a video using ffmpeg (www.ffmpeg.org):\n");
+        sb.append("  cd \"").append(dir).append("\"\n");
+        sb.append("  ffmpeg -framerate ").append(fps).append(" -i ").append(inputPattern)
+                .append(" -vf \"crop=trunc(iw/2)*2:trunc(ih/2)*2,format=yuv420p\" video.mp4\n\n");
+        sb.append("- The crop filter trims at most 1 pixel so that width and height are even, as required\n");
+        sb.append("  by yuv420p. Remove it if your frames already have even dimensions\n\n");
+        sb.append("- Parameters that can be added in front of crop in the comma-separated list of -vf \"\" options:\n");
+        sb.append("  hflip          flip sequence horizontally\n");
+        sb.append("  vflip          flip sequence vertically\n");
+        sb.append("  transpose=0    90 degrees counterclockwise and vertical flip\n");
+        sb.append("  transpose=1    90 degrees clockwise\n");
+        sb.append("  transpose=2    90 degrees counterclockwise\n");
+        sb.append("  transpose=3    90 degrees clockwise and vertical flip\n\n");
+        sb.append("- To use all images in a folder use e.g.:\n");
+        sb.append("  ffmpeg -framerate ").append(fps)
+                .append(" -pattern_type glob -i \"*.png\" -vf \"(...)\" video.mp4\n\n");
+        sb.append("Alternatively, ImageJ built-in commands can also be used, e.g.:\n");
+        sb.append("\"File>Import>Image Sequence...\", followed by \"File>Save As>AVI...\"");
+        return sb.toString();
+    }
+}