nexu-io/openmotion / skills/openmotion-recreate
openmotion-recreate
VerifiedRecreate a reference video (a link or file) as the user's own film with OpenMotion: rebuild it as an editable OpenMotion project and hand it over open in the editor, keeping the original content or swapping in the user's copy, brand and assets. This includes small edits to the user's own finished video when no editable project for it exists. "Make one like this" and "I want this feel" both count as recreation. In a workspace with the user's product material, a bare link alone means "make one like this for us". References that also contain portraits, product photography, live-action or AI footage, narration or music are in scope: those parts use configured media generation while the structure stays editable. Not for only analysing or discussing a video. Use openmotion-director when the reference is only inspiration for an original film, openmotion-template-to-video for an existing template, openmotion-production for edits to an existing editable OpenMotion project, and openmotion-video-to-template for a reusable template package.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 15.7 KB |
| agents/openai.yaml | config | 136 B |
| assets/reconstruction.js | script | 14.7 KB |
| references/rebuild.md | markdown | 3.9 KB |
| references/reconstruction.md | markdown | 22.6 KB |
| references/rendering.md | markdown | 8.7 KB |
| references/verify.md | markdown | 6.2 KB |
| scripts/measure_frame.mjs | script | 9.6 KB |
| scripts/measure_motion.py | script | 8.2 KB |
| scripts/observe_marks.py | script | 10.7 KB |
| scripts/register_motion.py | script | 8.4 KB |
| scripts/vision-tools.mjs | script | 2.9 KB |
references/reconstruction.md
View on GitHub# Reconstruct a difficult visual system
This page continues [rebuild](rebuild.md) for openmotion-recreate. Read it before authoring a passage that has any of the following: dense multi-shot work split into units for coordinated integration; an unfamiliar visual mechanism, such as camera travel over a surface, a changing silhouette, content flowing inside a fixed boundary, repeated marks or particles, a scene breaking apart or reforming, or localized flashes and distortion; or movement whose rebuilt output still differs from the reference after a repair. Passages that the rebuild steps already reproduce do not need it.
Use source-analysis and implementation guidance during default creation, followed by the single focused preview pass in [recreation delivery](verify.md). Detailed local validation and further visual repair follow an explicit review or revision request.
## Plan shot and action units
For a dense multi-shot film, organize reconstruction into locally reviewable units near shot or action boundaries. Keep coupled actions together, and include neighboring reference frames so an entrance or exit can cross a unit boundary. Choose unit lengths from the action and dependencies. A unit can contain several fast cuts or one continuous move.
Keep independent shots with different visual mechanisms as distinct units, including when they will share one final source module. When units outnumber available worker slots, queue the remaining units and reuse workers after their current unit is implemented. Return the source, timing and known gaps for integration. Include output comparisons when review is requested.
Use separate workers for independent units when the host supports delegation and the task authorizes it. A single Agent follows the same local process sequentially. Keep one coordinator responsible for the root timeline, shared resources and soundtrack. Give each worker disjoint source files. Save integrated changes through the existing revision-protected project workflow.
Make the unit brief concrete enough to execute. Supply the following information in working notes or the worker task.
| Input | What the maker needs |
|---|---|
| Requested result | The user's content, changes, duration and editable deliverable, with any locked decisions |
| Reference interval | Local reference path, fps, dimensions, source start/end frames and neighboring action context |
| Available inputs | Supplied assets, reusable source and known limitations, plus visible discrepancies already established by comparison |
| Ownership | Which objects, text, transient effects and files belong to this unit, and which are shared |
| Integration | Coordinate space, global-to-local time mapping, asset paths, entry points and shared typography |
| Return | Editable source, asset mapping, timed observations and known gaps; output comparisons for requested review |
For each independent mechanism, use existing notes to connect source observations to material, geometry and timed controls. Resolve the recognizable form, surroundings, texture, feature-size distribution, density and exposure together in the first implementation. Preserve a suitable recovered material through its observed motion. Use supported source-field correspondence, local-coordinate transport or deformation for detailed changing contents. Procedural geometry takes its shape and appearance parameters from the source. Choose a method that represents the important intermediate state as well as the clear pose. Carry source identities, coordinate offsets and known gaps into integration.
Keep reused implementation and newly reconstructed work identifiable. Account for a reused object's different scales, cameras, occluders and text states in the implementation. Respect the supplied-input boundary when the task calls for an independent experiment.
## Turn observations into driving data
The [reusable texture and particle renderer](rendering.md) implements complete-region transport and sprite-based release with motion exposure. Use it for matching mechanisms, passing the current reference's materials, source observations and editable timing controls.
For an unfamiliar or inaccurate unit, describe its defining form and action, then follow recognizable features through the reference. Keep a compact record of source frame/time, feature or object, screen position, size, orientation, pose and visibility. Use relative distances and occlusion to distinguish common camera movement, part movement and deformation. Mark uncertain observations, including measurements contaminated by overlapping text or objects.
Cover the features responsible for the passage's motion, including changes inside otherwise stationary objects. Compare internal feature travel with the enclosing boundary at corresponding times. Keep content replacement, scrolling, geometric displacement and brightness variation distinguishable. Retain observed holds and stationary relationships. Resolve ambiguous movement with short consecutive-frame sequences or reliable tracking, and carry occlusion or tracking uncertainty into the model choice.
Fast or repetitive content can match a neighboring repeat across a sparse frame gap and underestimate travel. Begin with adjacent decoded frames, follow recognizable features and check the accumulated path before fitting a longer interval. Keep displacement units, coordinate scale and elapsed time explicit when deriving velocity. Inspect the tracked feature's own region separately from nearby stationary structure.
Use the installation's Node executable for these commands. Complete ZIPs provide `runtime/node/bin/node` on macOS and `runtime/node/node.exe` on Windows. The managed entry works from source, installed bundles and flat Skills using their installation metadata. First use downloads verified platform assets into the installation cache. Complete platform ZIPs include those assets for offline preparation. Repeated use reuses the completed environment. Use `node "<skill directory>/scripts/vision-tools.mjs" prepare` to prepare or retry explicitly. For additional source analysis/material scripts, use the same entry with `python <script.py> [arguments]`. User-installed Python and uv are unnecessary. Vision helpers support macOS 13+ arm64 and Windows 11+ x64. Respect host execution/network permissions and report preparation failures instead of silently claiming measurements.
Measure source travel before assigning velocities for each trackable local region. The optional motion helper accepts a reference alone for observations before authoring. Invoke it through `scripts/vision-tools.mjs`, which prepares the installation-managed, pinned Python, NumPy and headless OpenCV environment. Choose a continuous interval with recognizable features and inspect its samples and point pairs.
```sh
node "<skill directory>/scripts/vision-tools.mjs" measure reference.mp4 --start <seconds> --end <seconds> --roi <x,y,width,height> --out source-motion.json
```
The source-only report has `comparisonPerformed: false` and `output: null`. Fit controls from the observed displacement and elapsed time in the declared coordinate scale. For an explicitly requested detailed review, supply both videos to compare the same region. Preserve unresolved source observations explicitly. Default creation uses the focused preview pass in [recreation delivery](verify.md).
Convert those observations into timed controls the renderer actually reads. Keep the connection from observation to model parameter and source function inspectable. Depending on the passage, the useful record may be landmark coordinates, per-part keyframes, camera matrices, shape states, correspondence fields or per-line text bounds. Record direction/speed changes, extreme poses, fastest travel and settling. Add observations where interpolation remains uncertain.
| Observed change | An editable way to encode it | Source constraints to encode |
|---|---|---|
| Camera travel over a surface | Match stable landmarks across views, fit transforms and interpolate the camera over a spatial material | Motion extremes, perspective, registration residuals and newly revealed areas |
| Parts moving relative to one another | Shared parent/camera transform plus part-local paths and occlusion order | Relative distances and overlap at intermediate times |
| Content flowing inside a stable boundary | Transport a recovered material in local coordinates, or interpolate aligned source content fields, with clipping and timed state controls | Boundary position, texture and mark structure, internal feature travel, update cadence and newly exposed material |
| Changing silhouette or surface | Timed shape states, skeleton or mesh with correspondence between recognizable parts | Intermediate pose, volume, holes and changing visibility |
| Text assembling or leaving | Per-line or per-glyph reveal, travel, spacing, compression, opacity and blur curves | First visibility, readable hold, fastest expansion and final disappearance |
| Streaks, flash or scan distortion | Separate time envelopes with observed direction, extent, affected layers and recovery | Frames immediately before, during and after the event in the complete layer stack |
Match the temporal behavior of content inside a fixed boundary. Continuous scrolling uses local-coordinate motion or aligned field interpolation between observations. Discrete refreshes use their observed update cadence. When tracking mixes stationary and moving content, follow a recognizable moving feature across adjacent source frames or derive correspondence within its own region. Use its displacement and elapsed time to set the movement, preserving the enclosing stationary structure.
A changing silhouette needs controls for its internal change. If one spatial sample plus a global transform fits the endpoints but misses an intermediate pose, add a constraint at that time and revise the representation that failed. Connect the same recognizable parts through time. Correct unreliable correspondence around occlusion, repaired text or disappearing features by changing anchors, masks, state grouping or the model. Check estimated motion against the visible travel before limiting it.
For a form made of repeated marks or particles, separate a clean shape or brightness field from the mark renderer. The following construction is useful when the reference exposes a recoverable underlying form.
1. Use distinguishable colour, brightness or edges to derive an occupancy or brightness field for each observed state. Choose observations from the changing form and group continuous states on each side of a cut.
2. Mask independently changing overlays and inspect paired source/cleaned fields. Check whether the mask removed bright subject details, a hole or a thin appendage. Repair the affected region using available observations or revise the mask, keeping uncertain reconstruction visible in the notes.
3. Encode the cleaned fields in common coordinates. For a tonal form, contours at several brightness levels can preserve its interior and holes. A skeleton, control mesh or other shape model may better fit the observed structure. Save the source time with each state and declare coordinate and displacement units.
4. Establish corresponding parts between neighboring states in each continuous group, using reliable landmarks, manual anchors or available tracking/flow methods. Check the correspondence on the cleaned fields, especially at repaired or occluded regions.
5. At query time, select the surrounding states and warp their fields toward that time using the correspondence. Blend aligned values, then sample the resulting field to drive mark placement, area or opacity. Keep material, deterministic variation, text and transient effects separately addressable. Inspect the field and styled output at intermediate times, and add a state or revise correspondence where the form fails.
Calibrate the field-to-mark transfer in the rendered picture. A field sampled from already dim, sparse marks can lose brightness and coverage again when used as mark opacity or area. Compare the cleaned field, isolated marks and complete composite at matched times. Adjust field strength, mark coverage and material separately while preserving thin features, holes and the observed background. Inspect clean held states as well as blur-heavy movement.
Choose state count, extraction method, correspondence and control resolution from the reference and the host's available tools.
When a scene breaks apart or reforms, follow recognizable regions from the intact scene into the transition. Record when each region releases, what texture or shape remains visible, its travel direction and how the intact material disappears. Derive fragments or marks from the participating content and keep their initial coordinates consistent with its last intact state. Choose fragment shape, grouping, velocity and lifetime from consecutive reference frames. When individual marks cannot be tracked reliably, model the evolving spatial density, brightness and directional streaks with timed fields and supported correspondence. Reliable surviving tracks can omit fast, blurred or disappearing features. Check the evolving spatial distribution and streak geometry alongside the tracked trajectories. Compare release, peak spread and decay against the intact-to-transition handoff in the complete composite.
Use the source transition's first visible change, peak spread and decay to set the fragment model before implementation. Obtain typical bright-mark size, largest coherent fragment or hole, edge softness, colour and directional streak extent at delivery scale. Keep source-sampling pitch, release-group size and visible fragment size separately controllable. Sample brightness and texture from the participating material, and derive visible size, coverage, velocity and lifetime distributions from those source states. Maintain the observed relationship between remaining intact structure and released fragments throughout the handoff.
For spatially localized flashes, tearing or distortion, record the affected bounds and layers through each pulse. Fit its onset, peak and recovery from consecutive source frames, including clear intervals between pulses. Give local bands or regions their own displacement, exposure and visibility controls when their behavior differs. Inspect these bounds in the complete composite so an added glow or repeated whole object cannot conceal a mismatched local effect.
For camera movement or surface deformation, prepare enough spatial material to cover the revealed area. Align useful views of the same structure when available. Check overlap for doubled edges and check the sampling boundary for gaps or stretched pixels. If blending imperfectly aligned views produces double structure, select a reliable source for that region and use other views to fill uncovered areas, or adjust seams and visible regions. Recheck intermediate and extreme camera positions. Use a more suitable projection, layers or geometry when one plane cannot preserve the observed relationships. Preserve weakly supported intervals in the review notes.
Fit camera travel from stable scene landmarks at corresponding times. For a textured plane, the bundled registration helper can measure anchor-to-frame homographies. Choose times within one continuous shot and exclude independently changing overlays. Use the managed entry below, with the directory containing this Skill's `SKILL.md`.
```sh
node "<skill directory>/scripts/vision-tools.mjs" register reference.mp4 --anchor <anchor seconds> --times <comma-separated seconds> --out camera-observations.json
```
Optional `--roi x,y,width,height` and repeatable `--exclude x,y,width,height` use original pixels. The report records decoded timestamps, full-frame pixel matrices, inlier point pairs, residuals and spatial support. Inspect that support across the intended plane and compare projected landmarks in intermediate output. Unresolved samples return a failing exit code and carry their reason. Resolve the cut, mask, observation or representation before using those samples. Apply supported matrices to the renderer in the declared coordinates, and verify material coverage throughout the camera path.
## Prepare material in its actual use states
Verify the chosen material and geometry at a clear representative pose at their eventual screen scale. Preserve characteristic edge structure, texture, internal geometry and layering. When a procedural approximation loses those features, choose a supported local material or a more faithful editable representation, then recheck its motion.
Look through the available reference for a clear, unobstructed view of the same object before repairing an occluded one. Compare pose and lighting before using that view. When removing text or overlays, inspect the cleaned shape before stylizing it. Check bright subject details, holes, anti-aliased glyph edges, shadows, underlines and restoration seams. Use the background's structure to choose the repair method.
When isolating an object, preserve the stationary structures crossing or surrounding it. Fit masks to the actual shape and depth ordering. Register other useful views to recover newly exposed material before repairing a large region. Check the reassembled scene at a matched time, including the background, object attachments and overlapping foreground. Correct shifted perspective, erased structure or patch boundaries before extending the animation.
Inspect the material when the covering text or object has left, after requested content changes, and in every reused view. Follow the mask or material back to its source when a ghost moves with the subject. Preserve independently changing elements as separate source controls.
## Validate and repair the local implementation
Use this section when review or visual revision is explicitly requested. A review-only or evaluation-only task reports findings for the inspected version. Source repair follows an authorized revision request.
Use the pinned seekable preview or targeted native captures to iterate on the actual unit source. Compare reference and output at equal scale and corresponding times. Include observed states, intermediate times, extreme poses, the fastest displacement and entry/exit boundaries. Read back feature positions, size ratios, angles, relative distances or visible widths from the output using the same method as the reference. Review the timed sequence to assess acceleration, holds, reversals and recovery.
For each defining change identified above, locate the source control and compare its actual effect in the output. Check both moving features and their stationary anchors. If a changing region was flattened into a fixed crop, recover its missing local control before refining its appearance. If neighboring states overlap as double images, align or deform their corresponding features before blending. Recheck direction, distance, cadence and disappearance through the affected interval.
An animated source parameter can be hidden by an opaque material, a clip, an overlay or a later paint operation. Compare the fully composited output region before accepting that control. For trackable local movement, use the bundled motion helper through the managed entry below. It follows adjacent decoded frames through continuous reference/output intervals. Reuse it for this check before writing another tracker, and inspect its correspondence and uncertainty.
```sh
node "<skill directory>/scripts/vision-tools.mjs" measure reference.mp4 output.mp4 --start <seconds> --end <seconds> --roi <x,y,width,height> --out visible-motion.json
```
Choose a region belonging to the moving feature and measure its stationary anchor separately. Coordinates use each video's original pixels. Supply `--output-roi` when the output needs different coordinates. The report includes decoded times, displacement samples, travel span, retained features and point pairs. A possible-suppression warning flags travel below half the reference span once reference movement exceeds the helper's jitter floor. This warning or unresolved tracking returns a failing exit code. Inspect the actual travel values, tracked features and layer stack before deciding the cause. Small motion, changing content, occlusion and mixed movement can invalidate the comparison. Timing, direction and semantic fidelity require visual review, including when the diagnostic returns successfully.
Run the planned [appearance measurements](verify.md#2-measure-the-selected-checkpoints) on preview captures selected for this requested visual review. The frame measurer accepts an exact reference frame and a preview PNG with `--ref-frame <source index> --frame 0`. Keep the capture's time, resolution and source revision explicit. Collect findings by source control. For a revision request, fix independent defects together. Reinspect affected moments and neighboring states. Keep measured and visually estimated controls distinguishable.
Calibrate light, density, edges and material on the established motion. For exposure sampling, check preserved brightness and high-frequency marks for repeated copies or comb-like gaps. Adjust temporal sampling or directional integration when needed, and match the observed streak direction, extent and clear hold. Keep frame-specific flash peaks and recovery explicit. Inspect later text and post-processing layers for marks that alter a flash after it is drawn.
Return the working source and actual comparison evidence with the brief's time range, asset identities, shared dependencies and remaining differences. Keep generation scripts consistent with the final corrected source when they are part of the handoff. For an authorized revision, use local captures for targeted fixes, then follow [export and requested review](verify.md).
Check every planned unit against its defining action and brief transient events before marking it ready for integration. When an independent visual reviewer is available and authorized, give them the reference and actual local output with the requested changes. Keep the review focused on visible differences. Feed concrete failed intervals back into the unit's source repair and recheck them in the integrated film.
## Integrate the units
Import shared media once and connect the returned paths. Preserve each unit's global-to-local clock and coordinate transforms. A background ownership boundary can differ from a foreground element's first visible frame. Coordinate overlaps explicitly so an outgoing title and incoming logo can coexist as the reference shows.
For requested review or revision, inspect the integrated project across joins and repeated appearances, including pose, direction, speed, exposure, text and layer ordering. Capture the final composite for short events. Recheck every affected use after replacing a shared asset or renderer, and bind the evidence to that source or export version. Play the integrated sequence at normal speed and check the single soundtrack through the existing delivery workflow.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |