# Editing with DaVinci Resolve

**Documentation preview. Resolve application verification is incomplete.**
This download is a preparation kit, **not a Resolve project**. It contains
original layered stills, reproducible asset code, recipe specifications and
offline timing helpers. It does not contain a `.drp`, a `.dra`, application-exported
Fusion setups, or Resolve-rendered examples. Do not infer those deliverables
from the existence of this ZIP.

The accompanying website supplies bounded official-source evidence. This kit
contains no source-film pixels, OpenAI branding, copied demonstration data,
private application code or talking-head recordings. A neutral fixture is not
proof of a real product capability.

## Environment gate

The research workstation is Ubuntu 24.04.4 LTS, Linux x86_64, with no Resolve
installation, no attached desktop session and no verified GPU render environment.
No accessible remote Resolve installation was found. **Tested Resolve version,
edition, operating system and output codecs: none.** `ACCEPTANCE.json` records
each missing application check separately.

The construction reference is Blackmagic Design's **Resolve 21 Reference Manual**,
published July 10, 2026. The official software catalog inspected September 5 lists
21.0.4 Free and Studio updates dated August 5, 2026. This is a documentation/release
observation, not an installed-version claim or a request to upgrade an existing
project library. Before executing, record Help/About (or the application About
menu on macOS), edition, OS, GPU, driver, attached display and the manual supplied
with that installation. Reconcile any different controls before continuing.

Needed access: an authorized interactive GPU workstation with Resolve, a
disposable local project library, permission to export and render the neutral
fixtures, and a desktop-control channel or a human editor. Use Free where
possible. No recipe deliberately selects Studio effects, third-party plugins,
Magic Mask, Speed Warp, AI tools or external-script access. Free compatibility
and actual codec availability still require testing. Do not purchase Studio just
to complete this guide without separate authorization.

## First ten minutes in the UI

These are **manual-checked construction instructions, not an executed test**.
Names and values must be confirmed in the chosen application.

1. Unzip into a short neutral folder such as `ResolveStudies`. Install the two
   bundled DejaVu fonts using the OS font manager, then reopen Resolve. If font
   installation is unavailable, document an installed sans-serif substitute and
   re-check every title's line break, baseline and width. The fixture PNG text is
   already rasterized; only native Text titles need installed fonts.
2. In Project Manager, show Project Libraries. Add Project Library → Create and
   create a **new Local library**, not a production library. Create a project
   named `ResolveStudies_DocumentationPreview`. No supplied `.drp` is available
   to import in this release.
3. Before importing media, open File → Project Settings. Master Settings:
   1920×1080, square pixels, timeline and playback rate **30**, progressive.
   Color Management: **DaVinci YRGB**, not color-managed; Timeline color space
   **Rec.709 Gamma 2.4**. Do not apply grades, LUTs, output transforms, HDR or
   automatic color management. These are chosen baseline settings, not source
   production settings. Record what the actual UI permits.
4. Media page: import the complete `media/` directory. PNGs are 1920×1080; preserve
   their raster and alpha. Clip Attributes → Data Levels: Full for these RGB
   fixtures. Inspect transparent overlays over `shell.png`; do not mistake a
   black viewer background for opaque black pixels. Any alpha correction must
   be recorded and checked at the edge, not guessed from the file extension.
5. Create bins `01_OriginalMedia`, `02_Recipes`, `03_Sequence`. Edit page → Media
   Pool right-click → Create New Timeline. Name each timeline exactly as listed
   in `recipes.json`; set start timecode **01:00:00:00**. Use the project frame
   rate and raster. The twelve recipe timelines and `S01_Original_Study_52s` are
   specifications to construct, not timelines already present in this kit.
6. Follow the selected recipe's track table. Intervals are half-open. Set clip
   durations numerically with Change Clip Duration; enable snapping and ensure
   adjacent endpoints have no one-frame gap or overlap. Native stills and
   generators have no temporal handle requirement. Real captures need actual
   recorded handles, not repeated frames masquerading as source footage.
7. Scrub each listed boundary, then play at normal speed. Wait for cache if
   necessary. A cached or proxy preview does not prove final export fidelity.
   Make the first test at full raster before using reduced preview resolution.

## Source, timeline and local frame coordinates

- **Source-video time:** the delivered original's PTS in seconds and zero-based
  decoded frame index. Source rates include 24000/1001, 30 and 60. Use the
  source evidence ledger's actual PTS, not an assumed `frame / 30` conversion.
- **Timeline timecode:** this kit proposes 30/1 fps, non-drop-frame,
  `HH:MM:SS:FF`, starting at `01:00:00:00`. Frame 90 is `01:00:03:00`.
- **Recipe-local frames:** zero-based; a 150-frame recipe occupies `[0,150)`
  and its last visible frame is 149. A keyframe at 30 and another at 60 span
  30 frame intervals, not 31. Track and control tables use this recipe clock.
- **Clip-local frames:** subtract that clip's recipe In from the recipe frame.
  For example, the title-cut context clip begins at recipe frame 90: recipe
  frame 100 is clip-local frame 10 and timeline `01:00:03:10`. Add the clip's
  timeline start to a clip-local frame to find its timeline position. Do not
  keyframe a short overlay at an impossible clip-local frame 100.

For Fusion, establish a new Fusion Composition with local range 0 through
`duration−1`. Confirm the current-time field. If the actual comp begins at a
different frame number, add that offset to **every** listed key. Timeline
timecode, MediaIn source time and Fusion current time are different controls.
Do not reset a source clip's frame range blindly.

For stills dragged from the Media Pool into a Fusion Composition, inspect
MediaIn's Global In/Out. Set them to the composition's first and last included
frame (normally 0 and `duration−1`). The manual explains that extending this
range adjusts Hold First/Last Frame. Holding an original still is appropriate;
holding a real application capture or presenter can misrepresent events and is
not authorized by these fixture instructions. Check the final comp frame for
missing media after every duration change. Reference: manual PDF p. 1386.

## Geometry and spline contract

All stills are 1920×1080, square pixels, even when most of the image is
transparent. Asset design coordinates are **top-left pixels**, x right and y
down. The outer window is `[192,108,1536,864]`. The scroll viewport is
`[336,210,1248,620]`. Do not crop the transparent canvas during asset replacement.

Fusion normalized image coordinates use x right, y up, with `(0.5,0.5)` at the
center. A pixel rectangle `[left,top,width,height]` becomes:

```text
Center.X = (left + width/2) / 1920
Center.Y = 1 - (top + height/2) / 1080
Width = width / 1920
Height = height / 1080
```

The fixed viewport therefore uses Center `(.5,.518518519)`, Width `.65`,
Height `.574074074`. Rectangle Soft Edge and Corner Radius are zero; Solid on,
Invert off. Transform Pivot is `(.5,.5)`, Size 1 and Angle 0 unless stated.
Leave Reference Size normalized. A 240-pixel upward content move adds
`240/1080` to Transform Center.Y. The effect mask belongs on the **Merge after
the content transform**; the shell is the stationary background. The blue
Transform mask is an effect mask, not a replacement for this compositing order.

Edit Transform uses linked Zoom and pixel translations around the centered
anchor. With source/timeline raster matched, bring source focus `(x,y)` to the
output center using `Position.X = zoom*(960-x)` and
`Position.Y = zoom*(y-540)`. Anchor Point remains `0,0`; positive translation Y
is upward. The text generator's layout Position is a different control from
the clip's Video → Transform Position. Do not enter text-layout coordinates
into Transform.

For basic Text generators, explicitly set both Alignment and Anchor; a centered
paragraph does not by itself define the anchor of its bounding box. This kit
keeps Title-panel Position at `(960,540)` and uses Settings → Transform for
offset placement. With a Left/Center anchor, Transform `(-576,-60)` places the
block's left center at top-left output pixel `(384,600)`. A Center/Center anchor
with Transform `(0,0)` centers a title. Set Drop Shadow Opacity 0, Stroke Size 0
and Background Opacity 0; leave text Zoom 1 and Rotation 0. Reference: manual
PDF pp. 1220–1222. Four successive input states use duplicates of the same
native title, avoiding a switch from native font metrics to a raster text plate.

For a different focus, rectangle or frame, use the offline helper rather than
rounding by eye (all examples assume the full 1920×1080 canvas):

```bash
python3 tools.py focus --x 1180 --y 600 --zoom 1.8
python3 tools.py rectangle --left 336 --top 210 --width 1248 --height 620
python3 tools.py timecode --frame 100
```

The focus command returns a coverage check and exits nonzero when centering
the target would uncover an edge. For a fully opaque full-frame source at
zoom ≥1, legal translations satisfy `abs(Position.X) <= (zoom−1)*960` and
`abs(Position.Y) <= (zoom−1)*540`. This check does not inspect transparent
content, product chrome or text sharpness. A focus at `(1700,900)` with zoom
1.8 would uncover 564 pixels on the right and 216 below. Do not apply it as a
safe crop. Choose a legal translation and accept an off-center target, choose
a different crop/technique, or recapture with more surrounding content. If
changing zoom, recompute both translations and verify readability. Do not
auto-clamp silently while continuing to claim the target is centered.

Continuous animations use explicitly selected **Linear** interpolation as a
simple unfitted default; hard cuts are adjacent clips, not splines. In Edit,
show the Keyframe/Curves Editor and the exact parameter channels. In Fusion,
show Spline, select the animated channel and its endpoint keys, then choose
Linear. Center animation may expose a Path modifier and displacement spline:
check the spatial path as well as its timing. No overshoot, extra path points,
looping, motion blur or default auto-easing is intended. A later fidelity pass
may choose a different curve and must record the deliberate change.

The inspected manual's Text+ Write On paragraph has direction wording that
needs an application check. This release does not guess that API/control's
behavior. The input recipe uses discrete editable word states instead.

## Assemble the 52-second study

`sequence.json` specifies 1560 frames and the exact portion of each recipe used.
This is a silent original editing study, not a product demo or an approved
all-hands presentation. Build the sequence by copying the **underlying clips
and Fusion compositions** from recipe timelines, not their flattened renders.
Place each group at its listed start frame. Preserve local keyframe timing
when copying; recheck all trimmed excerpts. Recipe markers are not guaranteed
to copy with clips. Add sequence markers independently.

The sequence moves through premise, context, focus, input, a new chapter,
selection, navigation, result arrival, reading, a request recap in a new
container, a label and a quiet end. The result reveal's final state continues
unchanged into the reading hold. Other context changes are intentional cuts,
not falsely advertised geometric handoffs.

Generate a marker reference with:

```bash
python3 tools.py self-test
python3 tools.py verify-kit
python3 tools.py markers --output marker-reference.csv
```

The CSV is **not an assumed Resolve import format**. In the Edit page, deselect
all clips, move the playhead to the listed timeline timecode and press `M` to
add a timeline marker, then `M` again to edit its name, color, duration and note.
With a clip selected you can create a clip marker instead; confirm placement.
Use Blue for chapters, Yellow for actions, Green for reading, Red for the
playback cue and Purple for the ending. Colors are chosen semantics, not
source conventions. Markers are editorial notes and should not be burned in.

Choose Edit for sequencing, hard cuts, simple transform keys, titles, independent
overlay tracks and holds. Choose Fusion for a fixed viewport around moving
content, selection/content registration under an outer transform, or layered
result masks. Do not create a Fusion composition merely to make a hard cut.

## Adapt without destroying the edit

Replace Media Pool assets or the specific MediaIn nodes while preserving the
full-frame canvas, pixel aspect, alpha and known landmark. MediaIn names are
labels, not guaranteed asset bindings. Check each node's actual input image.
Change the last static interval when changing shot duration. Do not apply
Change Clip Speed to an entire title/action/hold sequence: that changes typing,
travel and reading time together. If a shorter shot cannot fit its action and
complete-result hold, change the editorial choice or source selection.

For real captures: verify the actual interaction, retain an uncut capture,
record its source-time In/Out and any omitted interval, and preserve state
order. A jump in footage alone does not tell you the application's original
wait duration. **Compressed waits are a coverage gap in this chapter**, not a
validated recipe. Do not infer a speed factor or put a fake spinner into the
fixture to suggest a performance measurement.

## Pair with an actual recording later

The recording—not script length—supplies speech anchors, pauses and ending
performance. Obtain a transcript with timestamps derived from that recording.
This kit has no paired recording, so all actual speech-anchor, manual-delay,
wave and pause fields remain **unset**.

Keep two files: the supplied talking head plays through OBS, with its audio
routed through the virtual microphone; the separate silent presentation plays
through Google Slides. Do not composite the talking head into these studies,
duplicate narration, or add music. Future real product demos require inspecting
the product's current local instructions, exports and runtime before planning
or capturing the demo. A historical catalog is not runtime verification.

Let the presentation start at shared time 0. Its recognizable content cue is
`C`; measured reaction plus startup delay is `R`; the recording starts at
`S = C+R`. Recording timestamp `h` belongs at presentation time `S+h`.
Record `C`, rehearsed `R`, and intended `S` explicitly. Never assume `R=0`.

Let `H` be actual recording duration, `T` the onset of its recorded ending
wave/pause, `E<=H` the observed end of usable performance, `Q` its last required
speech anchor (OBS calls it `L`), `P` presentation end, and `B>0` the required
operator buffer. Reuse the OBS worksheet and its observed reaction range:

```text
C + Rmax + max(T,Q) <= P <= C + Rmin + E - B
presentation: [0, P)
talking head: [S, S+H)
```

Use the actual final visual proof completion as an additional lower bound if
it occurs after `S+Q`. Opening lead-in and ending buffer are separate. File
duration alone cannot decide which playback ends first.

The helper can check known values, but cannot derive them from nonexistent
footage. Unknown reaction/usable-tail values block readiness; file duration is
not usable performance. For an **invented arithmetic example only**, `C=3`, `R=.7`, `H=E=60`,
`T=57`, `Q=56`, `B=2` permits presentation end from 60.7 through 61.7 seconds:

```bash
python3 tools.py playback --cue 3 --delay .7 --head-duration 60 \
  --tail-start 57 --tail-end 60 --proof-end 56 --presentation-end 61 --buffer 2 \
  --reaction-samples .7 .7 .7
```

If the recorded tail is absent or the interval is empty, raise it in the single
consolidated storyboard/demo review. Do not invent a wave, freeze a face or
cut speech to fit. Review also establishes the actual export format and Slides,
OBS and meeting playback behavior. Get approval before final presentation
production; these research fixtures do not grant that approval.

The three identical example delays are invented. Actual cold/warm starts and
attendee-side lip-sync/presentation checks follow the OBS runbook; three trials
are a proposed practice, not a guaranteed bound. `--post-wave-start` and
`--post-wave-end` add a whole-wave-after-presentation requirement when needed.
`H=786.133333, T=773.7, E=780.6, Q=773.14, B=2` rejects a source-equivalent
end at `784`; an end at `774` retains `6.6` usable seconds, not `12.13`.

## Export the editable work from Resolve

These steps are pending, not evidence that exports already exist.

- Save the project. File → Export Project creates a `.drp` with project data;
  it is not a media bundle. Name it `ResolveStudies.drp`.
- Project Manager: right-click the project → Export Project Archive. Include
  **Media Files**; exclude Proxy Media and Render Cache for this fixture
  archive. The `.dra` is a directory, not merely a file extension to attach
  to a ZIP. Preserve its directory structure when compressing for transport.
- In each reusable Fusion graph, save appropriate selected-node settings via
  Settings → Save As, and use File → Export Fusion Composition for the whole
  graph. The manual describes `.comp` export converting MediaIn/MediaOut to
  Loader/Saver; that can carry filesystem paths. Inspect every export and
  rebind media in the clean test. Never assume a `.comp` is a portable `.drp`.
- Use only a neutral staging root and original assets. Scan project data,
  settings, LUT/still references, metadata, archive contents and filenames for
  personal directories, identities, private hosts and credentials before
  publishing. A public PNG-only kit does not prove a future binary project is
  clean. Do not edit binary `.drp` contents to sanitize them: rebuild/export
  from the neutral library, then inspect again.

## Import, relink, preview and test a clean library

Once actual exports exist, switch to a **second disposable Local library**.
Project Manager → Import imports `ResolveStudies.drp`; the media may need
relinking. Alternatively right-click an empty Project Manager area → Restore
Project Archive and select the `.dra`. Keep this test separate from the
authoring library. Temporarily make the authoring media location unavailable
to expose accidental absolute-path dependencies; do not delete the originals.

For offline media, select the relevant Media Pool clips and use Relink Selected
Clips to point to the restored `media` root. Inspect matching filename, raster,
frame rate and duration. Do not accept a similarly named wrong file. Confirm
all twelve editable timelines and the assembly, named nodes, text fonts,
transparent overlays, clip lengths, keyframes and timeline markers. Preview
each recipe at 1× and inspect the exact key boundaries.

## Deliver-page export contract

Choose the actual environment first. The official July 2025 **Resolve 20**
codec table is an older OS/edition reference, not proof of Resolve 21 capability.
It lists H.264/H.265 restrictions on Linux; do not assume a Free Linux MP4 path.
Record the codec options in the installed Deliver page before selecting them.

For an environment that actually offers MP4/H.264: Deliver → Custom Export,
Single Clip, Export Video on, format MP4, codec H.264, 1920×1080, 30 fps,
progressive, automatic keyframes, profile High if available, quality restricted
to 20,000 Kb/s as a chosen starting value. Export Audio **off**, not merely a
muted track. Advanced: no proxy, optimized-media or render-cache substitution;
Data Levels Auto with verified output; Color Space Tag Rec.709 and Gamma Tag
Gamma 2.4 if available. Record the exact encoder and options actually used.

If that codec is unavailable, use a supported native intermediate such as
QuickTime DNxHR HQ, if offered, with the same raster/rate and no audio. Keep
the Resolve-exported master. A separately documented FFmpeg transcode of that
master for web playback is acceptable as a derivative, never as a substitute
for a Resolve render. No codec or export is yet tested here.

For each recipe select its timeline, choose Entire Timeline and confirm the
duration equals the recipe frame count. For the assembly confirm 1560 frames,
52 seconds, last visible frame `01:00:51:29`. Add to Render Queue, then Render
All. Queue submission is not completion: check every job and open the actual
output. Render every recipe, not only the assembly. An export success does not
prove visual fidelity.

## Required acceptance before calling this complete

`VERIFICATION.md` separates preparation checks from missing application tests.
The final release needs clean-library imports, non-flattened editable timelines,
portable media and fonts, reusable exported/imported Fusion setups, twelve
Resolve-rendered recipe examples and the silent 52-second assembly.

Compare exported playback and adjacent boundary frames with the cited source
moments. Log source-measured values, implementation defaults, actual exported
values, deliberate fixture differences and defects separately. Check no black
frames, frame-count errors, content/mask drift, moving chrome, text changes,
cropped evidence, duplicated pointers or audio streams. Fix defects and rerender.

Give a fresh-context editor/agent only this guide, the resulting exports and the
documented workstation. Have them adapt **context-detail** to a new original
1920×1080 image with a different focus point, then **masked-scroll** to a new
document and a 180-pixel scroll. They must retain at least 60 complete-result
reading frames in each adapted recipe's final settled state—not in every
transitional/context state—render a new 10–15-second sequence from Resolve, and record
every human intervention. If they need missing context, fix the guide and
repeat. That exercise is **not run** while Resolve access is absent.

## Official documentation map

Links below use one-based PDF page numbers, matching the printed numbering in
the inspected Resolve 21 manual. No claim is made about OpenAI's editing tool.

- [Project import/export, pp. 78–79](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=78)
- [Local project libraries, pp. 84–87](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=84)
- [Project settings, pp. 144–154](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=144)
- [Media archives, p. 220](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=220)
- [Relinking, pp. 505–506](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=505)
- [Timeline creation, pp. 860–863](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=860)
- [Clip duration, p. 967](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=967)
- [Markers, pp. 1037–1040](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=1037)
- [Titles, pp. 1212–1227](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=1212)
- [Edit transforms, pp. 1246–1247](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=1246)
- [Edit keyframes and curves, pp. 1291–1303](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=1291)
- [Fusion composition interchange, p. 1390](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=1390)
- [Node settings, pp. 1470–1471](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=1470)
- [Fusion splines, pp. 1604–1610](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=1604)
- [Merge connections, p. 2264](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=2264)
- [Rectangle masks, pp. 2540–2542](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=2540)
- [Fusion transforms, pp. 2929–2930](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=2929)
- [Deliver, pp. 4174–4223](https://documents.blackmagicdesign.com/UserManuals/DaVinci_Resolve_21_Reference_Manual.pdf#page=4174)
- [Older OS/edition codec table, July 2025](https://documents.blackmagicdesign.com/SupportNotes/DaVinci_Resolve_20_Supported_Codec_List.pdf)

## Helpers and dependencies

`tools.py` uses Python 3.11+ standard library only. Run it in a normal terminal,
not the Resolve console. It checks frame math, marker references, file hashes
and supplied playback numbers. It calls **zero Resolve/Fusion APIs** and does
not control the application. `build_assets.py` optionally regenerates the PNGs
with the bundled fonts and pinned Pillow version; it produces stills, not
reference animations. Install its dependency in a virtual environment:

```bash
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt
.venv/bin/python build_assets.py
```

No external Python/Lua Resolve helper is promised until every API is checked
against Developer/Scripting documentation shipped with the **tested** version.
Do not substitute a web gist, assume Free accepts external scripting, or
assume unattended rendering. Core construction remains UI-driven.

`dependency-manifest.json` inventories the download with hashes, licensing and
explicit missing deliverables. Verify the supplied kit before editing it;
changed assets should produce expected hash differences. No fonts or media
are fetched at runtime. See `LICENSE.txt` and `fonts/LICENSE.txt`.