MiniMaxDirector
Upscale — the second stage. The
Upscale switch in the
Upscale group renders the
clip as usual, then enlarges the latent and refines it. Off, nothing below it
runs and the graph is exactly the one-pass director render.
The order matters: render first, look at it, and only then pay for the resolution. Flip Upscale
on and queue the same graph again — nothing upstream changed, so ComfyUI serves stage 1 from its
cache and only the upscale and the refine pass cost anything. That cache lives in the running
ComfyUI, so a restarted pod re-renders stage 1 (identically — same seed, same graph).
| what happens |
|---|
| off | one sampling pass at the canvas size, straight to the video |
| on | that same pass, then a latent upscale and a short refine at the bigger size |
The node's
mode is
megapixels, and
megapixels is the size you land on, not a
multiplier — the canvas defaults to 1344×768, which is 1.03 MP, so 2.0 is a bit under 1.5× per
side. It must be larger than the canvas; the node refuses to shrink.
align 32 is a pixel
grid, and 32px is one 2-latent step: it keeps both latent axes even, which is what the DiT's 2×2
patching wants.
keep_proportion off for the same reason — with it on only the width lands on
the grid and the height follows the aspect ratio, which can round to an odd latent row.
H3's latent holds picture and sound together, and the upscaler takes a plain video latent —
handed the joint one it raises
'NestedTensor' object has no attribute 'dim'. So the branch
splits the audio off (
Separate AV Latent), upscales the video, and joins them again
(
Concat AV Latent) before the refine pass. Both are core ComfyUI nodes, and it is the same
wiring the pack's own example workflows use.
The refine pass is an 8-step schedule split at step 4, so it starts at sigma 0.9231 and takes 4
steps down. That is a real second render at the larger size — **it costs time and VRAM, not just
the 691MB upscaler**. Fewer refine steps is cheaper and softer; more is slower and sharper.
The upscaler is
LBH-123-AI's H3 latent upscaler,
working directly on H3's 24-channel latents so nothing round-trips through the 5B VAE. Days old
at the time of writing, and unproven at our sizes — check the result before trusting it with a
long clip.
The pack rewrote itself on 2026-08-19:
H3LatentUpscalerNodeMegapixels was deleted and
MinimaxH3LatentUpscaler3D took its place, with align moving from latent units to pixels. The
onstart pins the clone to a commit for that reason — an unpinned one broke this graph on a pod
mid-day.
This one branch is the graph's only third-party dependency, and this pod already has it. Off a
pod it is
git clone https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler.git in
custom_nodes, plus
minimax_h3_latent_upscaler_3d_fp16.safetensors in
models/latent_upscale_models/. Without it ComfyUI opens this graph with a Missing Node Types
dialog and one red node — expected, and harmless while Upscale is off.
---
Speed — one toggle. The
Turbo switch in the
Speed group picks the render mode;
nothing else in the graph changes.
| Turbo | steps | sampler | LoRA | for |
|---|
| off | 20 | res_multistep | none | the take you keep |
| on | 4 | euler | minimax_h3_ref2v_turbo_4step_v0.1 | drafts, about a fifth of the GPU time |
The turbo LoRA is
lightx2v's Ref2VA 4-step distillation
(docs:
ModelTC/Minimax-H3-Turbo). It is distilled
for
4 steps at 544p on the shifts H3 already defaults to (video 12 / audio 3), so leave
strength at
1.0, the scheduler on
simple, and the step count where the toggle puts it.
Ref2VA turbo is a
v0.1 preview — audio and fast motion are its weak spots, and the
distillation was trained against the bf16 base while this bundle runs the pruned int8 one.
Switch Turbo off for a final render.
---
Lay out shots on the
Director node's timeline; it compiles them into the single
structured prompt MiniMax H3 reads, and keeps the clip on a length H3 accepts
(
length % 17 == 5 at 24 fps).
Why that rule: the model denoises a latent whose time axis is a row of slots, and the
video VAE packs 17 frames into 5 of them (after a 5-frame head worth 2). A length off the
lattice would need a fraction of a slot. So 124 f is legal, 130 f is not, and only 8s,
25s and 42s land on whole seconds.
• Two panels beside the director show what was built and what the linter thinks, both
updating as you type rather than after a run -- a warning that arrives after the
render arrives after the cost.
• Drop an image on a shot with
Add Image; it becomes
<Picture 1> automatically.
• Models: the H3 bundle (ref2va unet, Qwen3-VL text encoder, video + audio VAEs).
• The title bar carries the pack version and build date at its right end.
The three prompt buttons
| Button | Track | Makes |
|---|
| Add Video Prompt | MAIN | what happens on screen |
| Add Sound Prompt | AUDIO | what is heard -- H3 generates it, no file |
| Add Camera Prompt | CAMERA | how the camera moves |
Add Image / Add Audio / Add Video attach a real file instead, and the prose is given
a
<Picture n> /
<Audio n> /
<Video n> token pointing at it. With a block selected that
carries no file yet, the file lands on that block; otherwise it gets a block of its own.
An attached
audio or video takes the span it actually runs for -- the file is measured
before its block is placed -- bounded by the block after it and by the end of the clip.
Files, under the transport row beneath the tracks, opens the list of every file the
clip carries -- the ones on blocks, with the token they compile to, and the ones on no
block at all, shown dashed.
Its
+ file adds a file the clip carries with no moment of its own -- any of the three
kinds, taken from the file. A block says "this stretch of the video is about this file" and
compiles as
(appears in [Shot n]); a face to be carried onto whoever is on screen is about
no stretch, and putting it on a block cuts the clip at a seam the model then acts on. An
unplaced file is numbered with the rest, described on a card, and written into any prompt by
its chip. Drag it out of the list onto a track and it becomes an ordinary block at the frame
you dropped it;
x takes it off the clip. Every chip drags, placed or not: an unplaced file
moves onto the track, one already on a block is
copied, which is how the same
photograph is used in two shots without going back to disk for it.
Copying, and the keyboard
Clear empties the piece: every block, the global prompt, the music and every card on
WHO & WHAT. One undo step puts the timeline back; the cards do not come with it.
| Key | Does |
|---|
Cmd/Ctrl+A | select every block on every track |
Delete | remove the selected blocks |
S | split them at the playhead |
Cmd/Ctrl+C · Cmd/Ctrl+V | copy the selection, paste it at the playhead keeping its spacing |
Cmd/Ctrl+Z | undo |
The playhead
The red line is where every Add button puts its block -- click the empty part of a track
to move it, or drag the scrubber. If it is standing inside a block there is no room, so
the new one goes on the end instead.
• Dragging a block or its edge
snaps to the playhead and to the edge of every other
block, on any track, within a few pixels -- so a cue can start exactly where a shot does.
•
S cuts the selected blocks in two at the playhead. The second half keeps the prose
and drops any attached file, so the same picture is never in the prompt twice.
• Zooming with
+ /
- recentres the view on it.
The clip settings, left to right
| Field | What it does |
|---|
duration | Length of the whole piece, in frames. Type anything and it snaps up to the lattice; the arrows step a whole slot. Zero or empty means the clip follows its content. Shortening it brings the tracks inside: the block nearest the end loses its overhang, one that no longer starts inside the clip is squeezed to ten frames and the block in front gives up that much, and a block with nowhere left to stand is removed -- its file staying on the clip, in the Files list. |
= ... s | The same length in seconds. Read-only -- see below. |
frame rate | Always 24. H3 has no other rate, so this is shown, never chosen. |
width / height | Output resolution, in multiples of 32. Mirrors of the node's own widgets. |
default resize | How large a reference picture is sent to the model, for every picture that does not answer for itself on its own FILE row. match scales them to the output size; max keeps them larger, which holds a face or a logo together better and costs more time. |
renders ... | Speaks only when rounding changed the number: renders 124 f = 5.17s · 120 f rounded up. Silent when what you typed is what H3 renders, which is now the ordinary case. |
A block that grows the clip -- added, dragged past the end, or given a longer
length --
takes the lattice padding itself, so the timeline is exactly what will be generated and no
frame of the output is left without a shot describing it. The editor opens at
fit, with
the whole clip on screen.
The tabs
The panel under the toolbar shows one of four things, and remembers which one across a
reload, along with the block that was selected:
TIMELINE (the tracks and the selected block's fields),
WHO & WHAT (one card
per thing the prompt names, with the count on the tab) and
GLOBAL (the two clip-wide
prompt boxes). Those three are where the piece is written, so they sit together on the left.
IMPORT / EXPORT, at the right-hand end of the row, is what you do with the piece once it
is written.
The node is exactly as tall as whatever panel is open -- nothing here is a fixed height that
clips. The card list is the one exception: drag the grip in its bottom-right corner, or the
node's own corner while WHO & WHAT is open, and the height you set is stored on the node and
comes back with the workflow.
Import and export
IMPORT / EXPORT holds the whole piece as one JSON -- the timeline, the cards on WHO & WHAT
and the clip's own
width,
height and default resize -- with four buttons:
Save file
opens the browser's own save dialog -- the folder and the name are yours, and it suggests
minimax-director-<date>.json --
Load file reads one back,
Copy puts the same JSON on
the clipboard, and
Paste opens a box -- press Cmd/Ctrl+V in it and the piece loads as it lands, which is one action and no browser permission popup. Firefox and Safari have
no save dialog and download the file instead; the line beside the buttons names what was
written either way.
A load replaces the node -- timeline, cards and settings -- and asks first when there is
anything to lose. Cmd/Ctrl+Z puts the timeline back; the cards are a document of their own and
the undo stack does not hold them, exactly as Clear says.
The JSON names the files, it does not carry them: a picture's filename, never its pixels. So a
load ends by asking this ComfyUI which of the named files it actually has, and lists the ones
it does not with an
Upload button -- pick them from disk and every block pointing at each
name is re-pointed at the uploaded copy. The same check runs whenever the tab is opened, so a
workflow somebody sent you says what it is missing without being imported at all.
A file this ComfyUI does not have is drawn in red wherever it appears -- the block, the chip
under the prompt, its row in
Files, and the card's face and
from -- with the count on the
tab itself,
IMPORT / EXPORT · 1 missing. Red means broken here; amber still means unfinished.
While one is missing the panels are locked, and clicking one flashes the blocks whose file is gone. Three things stay
live because they are the ways out:
re-upload -- in the middle of the block itself, where
the picture would be, and on the file's row in
Files -- and
Delete and
Clear for when
the answer is that the block should go. Any file off disk will
do for a re-upload -- renamed on disk is the usual reason one goes missing.
The run is refused as well, before a frame is sampled, naming the files and what to do about
them. That is the check that holds: the lock is a browser drawing a warning, and a queue from
another tab or from the API never sees it.
The segment panel, under the timeline
Select a block first -- with nothing selected there is nothing to edit and the fields are
not on screen. Everything here edits that block.
| Field | What it does |
|---|
SEGMENT PROMPT | What happens in this block. On MAIN it becomes the shot's sentence; on AUDIO the sound; on CAMERA a note added to the move. |
start / end / length | The block's span in frames. Editing end moves the right edge and leaves the start alone -- the same edit as dragging the right grip. |
line / faces / how / language | MAIN blocks only. One row per spoken line, + line for another -- see below. |
off-screen / carries over | Two switches on a dialogue row: a voiceover, and a line that runs past the cut. |
enter with / on-screen text | MAIN blocks. How the cut into this shot is written, and any words visible in frame. |
SUBJECTS chips | One chip per numbered card, thumbnail and token, then one per file on the timeline (<Picture n>, <Audio n>, <Video n>) drawn dashed. Click it and the token is written into SEGMENT PROMPT at the caret. |
motion / strength / speed | CAMERA blocks only. Motion type, how far the framing travels, how fast. |
describes / used as / keep file | Blocks carrying a file only. See the next section. |
set width & height | Picture blocks only. Takes the clip's width / height from that file's resolution, scaled down to a size H3 renders. Nothing else moves those two fields. |
detach media | Removes the file, keeps the block and its prose. |
Select several blocks and the panel becomes a selection panel: only the fields that
apply to all of them (
motion /
strength /
speed,
enter with,
used as,
keep file), each starting on
leave as is.
same length and
close the gaps are
always there -- a frame count means the same thing on every track. For shots there are
two more:
merge into one shot, which is what MiniMax asks for when a cut only changes
the distance, and
make the speech continuous, which writes one sentence across the
cuts.
Frames first, seconds after, everywhere: the playhead clock reads
48 f = 2.00s and the
selected block
Start: 0 f | End: 96 f | Length: 96 f = 4.00s. Frames are what the
document stores and what H3 is given; seconds are the translation. Every number box --
start,
end,
length,
duration,
width,
height,
same length -- takes effect on Enter or when you leave it, not as you type, so one can be cleared and retyped without the half-finished number being read and refused; what lands in the box afterwards is what was actually set. Enter finishes any field and leaves it, prompt boxes included, and leaving a box flattens what is in it: paste a paragraph and it collapses to one line, because one line is what the compiled prompt carries.
A dialogue row with nothing typed in it dims -- the row and its background both -- because
the compiler ignores it until it has words. Along a block's bottom edge sit its chips: the
file it carries (
IMAGE · face.jpg), and one per transfer taken out of that file,
FACE -> SPEAKER, amber
FACE -> ? while nobody has been named to receive it.
The
GLOBAL tab holds the two fields set once for the whole piece:
| Field | What it does |
|---|
GLOBAL PROMPT | Style and scene constants for the whole clip. Compiles into the opening of Shot 1. |
GLOBAL MUSIC | Score only the audience hears, as instrumentation, tempo and dynamics -- not mood words. Empty compiles to non_diegetic_music: N/A. |
Paste freely. Line breaks are structure in the compiled prompt --
subject_definitions and
retention_analysis list one entry per line, and a blank line starts a new field -- so every box is flattened to a single line on the way out. A paragraph pasted from a document arrives as one sentence, not as a subject nobody wrote.
Why seconds are read-only. Every greyed
= ... s box is a reading, not an input. A
second is 24 frames wide, so a block typed as
1.08 came back as 26 frames and was shown
as
1.08 again -- the number actually set was never on screen. The clip is written in
seconds and cut in frames, and only one of those can be the field you edit.
Dialogue
H3 makes the voice and the picture in one pass, and the guide's form for it is exact:
The young woman with a quiet, breathy voice (S1) says: <d>[English] I get off at the next station.</d>
The editor writes it for you, and splits it the way the work actually splits: **who the
people are
is written once in the WHO & WHAT tab, and a block only says who talks and
what they say**.
WHO & WHAT is one card per thing the prompt has to name -- usually a person, but equally
a costume, a prop, a place or a style, which fill in the same card with the voice row left
empty. Several cards may point at one file: that is how a single photograph names several
things, each numbered separately.
S1…Sn is a
speaker -- who says a line; any card with a voice.
<Subject 1…n> is a
subject -- a person, a costume, a prop, a place, a look the model must keep. A card is
one only with a file
and a description; without a file there is nothing for the prompt
to point at, so it can only be a voice. Both tokens are MiniMax's, and a card can be one,
the other, or both.
The block's FILE row lists the subjects drawn from that file, one per line, with
edit
beside each and
+ another card underneath -- which is how a single photograph names a
person, their coat and the room behind them.
The subject chips write the token for you. They sit along the bottom of the prompt box
itself -- every numbered card a chip, its file's thumbnail beside
<Subject 2> suit;
clicking one splices the token into the box above it where the caret is, and a chip that
box already names is lit. GLOBAL PROMPT carries the same strip. Typing the number by
hand is the alternative, and getting it wrong is silent -- the prompt cites a subject that
does not exist and nothing on screen says so.
Name a subject in every shot it appears in. That is how one basket stays one basket
across a cut, rather than three descriptions of a basket: the same
<Subject 1> written into
all three shots, by chip. The compiler follows -- its line in
retention_analysis reads
(appears in [Shot 1], [Shot 2] and [Shot 3]) instead of naming only the shot its file sits
on, and without it the model is told the basket belongs to one shot and is free to invent
another for the next.
The files have chips too, dashed, after the subjects:
<Picture 2> face.jpg,
<Audio 1> voice.mp3,
<Video 1> clip.mp4, one per file on the timeline. The compiler
writes a file's token into its own block's line; pointing at it from anywhere else -- a
recording the mouth has to follow, a picture a later shot refers back to -- is what these
are for.
| Field | What it does |
|---|
name it | A short name, yours, so the faces on a dialogue row are readable. |
from | Which file on the timeline this subject is drawn from, and the only place that file is described. The binding is what makes a face and a voice one person; the card then shows the <Subject n> badge the prompt will use. |
keep it | How much of the subject survives, compiled as subject_retention. Not the block's keep file: the photo may be fully_preserved while the face taken out of it is an attribute_transfer onto somebody else. |
onto | Who receives that transfer. Shown only for attribute_transfer: pick another character or a shot's subject from the list, or type a receiver only the shot describes. Picking a card writes its name and compiles as that card's <Subject n>, which is the only way the model knows a person. Empty means the model is told to move a face and never told where. Picking a card writes the replacement into three places, which is the shape a working identity swap uses. The card keeps its own <Subject n> -- it is what the video shows where the receiver's own feature was -- and carries the attribute_transfer marker itself: <Subject 2> ... replaces <Subject 1>'s face only, mapped onto the same position and framing at every moment. The receiver's line then lists what its picture does supply, names the replaced region as excluded, and reads partially_preserved however the card is set -- a person whose face is replaced is content still used with some characteristics changed, which is the guide's own definition of that marker. The shot opens with the replacement rather than mentioning it after the scene is drawn. Describe the receiver without the feature being replaced, its hair included: preserved including the head it has, the model is told to keep that head and to replace it, and it keeps it. |
| what it is | For a card with a file. Becomes their line in subject_definitions. |
| how they sound | Age, gender, pitch, timbre, accent, on screen or off. H3 fixes the voice from this, so an empty one is a voice nobody chose and the linter says so. |
motion from | A second file for the same person, supplying how they move. A still says nothing about a walk. |
voice from | Take the timbre from a recording instead of describing it. The signal is never copied -- only the voice and delivery are followed. |
A card that is doing nothing looks like it. A card counts when it names a file
and
says what that file is -- that is a
<Subject n> -- or when it describes a voice something
actually speaks. Short of either, the compiled prompt is byte-for-byte what it would be
with no card there, so the card goes flat: transparent, dashed, dimmed, with the reason in
amber across it and the same line in
report.
| The card says | Because |
|---|
| this card compiles to nothing | no file and no voice: it is neither a subject nor a speaker |
nothing is written about <Picture 1> yet | a file is picked, but with nothing said about it the card takes no number |
| nobody speaks this card's lines | it has a voice, and no shot's dialogue row ticks its face |
| no file: this card gives a voice and nothing else | fine, and deliberate -- a speaker with no photograph |
Two badges say the rest.
<Subject n> is what the prompt will call this card, and a hollow
no <Subject> where it would be means no file was picked. A green
[Shot n] says where
the card is heard, which is otherwise only visible from the TIMELINE tab.
Add adds a card;
they speak switches dialogue off for the whole clip --
every row and every
<d> at once, cards kept. The voice row goes with them, `voice
from
included, and so does the Sn` badge: with nobody speaking a timbre reference
instructs nothing and the compiler drops it, and no card is called by a speaker number. Describing the same speaker two different
ways in two shots used to be possible; to the model that reads as two people wearing one
label.
On the block:| Field | What it does |
|---|
line | The words themselves, sent verbatim -- never translated, punctuation kept. |
| faces | Who says it: click a face from WHO & WHAT. Two lit on one row is the guide's (S1,S2) -- the same words spoken by both at the same instant. |
how | How it is performed. Becomes the verb: says, whispers, shouts, answers -- free text, used as written. |
language | Names the language of the words; it does not translate them. |
off-screen | A voiceover. Writes MiniMax's exact phrase and the clause it requires after every one -- that the lips stay closed. Forget the second half and the model animates a mouth to match. |
carries over | The line does not finish in this block. <scenetrans> on both sides of the cut, or <cutoff> when the clip simply ends underneath it. |
+ line adds another row, so one block can hold a conversation: a line each, spoken in
turn, compiled as one
<d> apiece. It goes dead -- dashed and dimmed, with the reason in
amber -- while a row on the block still has no words, since the compiler ignores that row
and a second empty one adds a second nothing. The red bin at the end of a row removes it -- the same
delete button the subject cards carry.
Clicking a face hands the line to that person alone; hold Cmd or Ctrl to add another, and another -- the row says so beside the faces, and any number of them can say the words at once.
Three readings, kept apart on purpose: a
chorus is one row with two faces, a
conversation is two rows, and an
argument -- overlapping speech with no agreed
words -- is neither. Write that one in the segment prompt and put the sound in an AUDIO
cue; there is nothing for H3 to quote.
Attached files:
used as,
describes and
keep file
used as -- what the file is
for. The picker offers only what the file could sensibly be: a picture gets reference, storyboard and the three frame anchors; a video gets reference, continue from and edit; a recording gets reference alone, and with nothing to choose the control is not drawn. A document already holding some other combination keeps it, shown until you change it. It decides the task type the summary opens with, and
the guide wants every relationship named:
| Used as | Task type it produces |
|---|
reference | reference generation -- guidance for a character, scene, style or camera move |
storyboard | reference generation -- a plan of the framing, not content: is a storyboard reference for [Shot 1], defining viewpoint, subject placement, and shot order |
first frame / keyframe / last frame | keyframe completion -- a concrete frame of the target video, not a picture of something: is the first frame of [Shot 1], and retention_analysis names the role again |
continue from | video continuation |
edit | video editing |
Only
first frame and
last frame have an input on the model.
keyframe is the same idea one step weaker: MiniMax's guide counts it as a frame anchor, but the core node takes exactly two stills --
first_frame and
last_frame -- so a picture that should be a frame in the
middle has nothing to be plugged into. That block's image travels with the references and the prompt asks for the placement in words --
<Picture 1> ([Shot 2] keyframe) where a reference would read
(appears in [Shot 2]). An end is a guarantee, the middle is a request the model follows loosely.
A keyframe is fitted to the clip, not the other way round. A block used as
first frame
or
last frame carries a
fit picker beside
keep file.
crop, the default, scales
the picture and cover-crops it from the centre: proportions survive, an edge is lost.
stretch hands it over untouched, which is what ComfyUI does on its own -- every pixel
kept, the picture squashed. A picture already of the clip's shape is untouched either way;
when the shapes disagree the report names both sizes and what it cost. To keep the whole
picture, give the clip the picture's shape, or attach the file as a
reference -- that
path scales without cropping and lets the model compose the rest of the frame around it.
The settings row's
default resize sizes reference
pictures only -- a reference video is sized
by its own rule, a keyframe by
fit. It stays live whatever the clip carries. A picture in the Files list counts before it is placed: it reaches the model in the same reference list as one on a block. A picture answers for itself with its own
resize, offered both on its row in Files and on a block's FILE row -- it belongs to the file, so both write the same thing. The clip's value is only for the pictures that say nothing:
max on the face you have to keep,
match on the mood board behind it.
What it trades is detail against time. A reference picture becomes tokens the model reads beside the prompt, and those tokens are re-read at every sampling step -- more pixels, finer detail, more time.
match shrinks it to about the clip's pixel count: fast, enough for a scene, a style, a mood.
max allows 2048 px on the short side: slower, and what keeps a face the same face. Neither enlarges a picture or changes its proportions.
default resize does not touch width and height. The clip used to take the shape of the first reference picture whenever it said
match; now a picture block carries
set width & height beside
detach media, which does it on request -- for a keyframe too, which is what the crop warning asks for.
An attached audio adds
audio reuse or
audio reference depending on its
keep. Several
at once combine:
[keyframe completion + video continuation + audio reuse].
A segment holding a real file switches the prompt into H3's full-reference format -- six
sections instead of three -- and gets its own row of fields.
describes -- read-only, and there is no box here. What a file
is is written once, on
a subject card, and this line shows that card's sentence beside the
<Subject n> it
became with a link to the WHO & WHAT tab. Until you add one it reads `nothing describes this
file yet`, and the linter says the same: an unnamed reference is one H3 has to guess at.
Why not a box on the block? Because a file used to define something is cited
inside that
thing's definition rather than given a line of its own -- MiniMax's own rule -- so a second
box here would have been a field the prompt threw away, which is exactly how it behaved.
One file, one description.
A frame anchor carries no description box. The picture goes to the vision encoder with the prompt (
clip.tokenize(prompt, images=...) in core's
nodes_minimax_h3.py), so saying what is in it tells the model nothing it cannot see -- and every source for such a sentence is wrong somewhere: a filename says nothing, and the shot's own prose is the motion across the shot, which a
last frame does not contain. An anchor names the frame it is, in
subject_definitions and in
retention_analysis alike. Cards still work on one.
keep file -- how much of the file survives into the video. One per file, always; it
also sits on the block itself, bottom right. A subject card drawn
from this file carries
its own
keep it for the thing, which may differ. The sentence it produces lands in
retention_analysis, as
<Picture 1> (appears in [Shot 2]): fully_preserved - the raccoon, ...| Value | Means |
|---|
fully_preserved | copy it -- same subject, same look, unchanged |
partially_preserved | keep the subject, let pose, angle or lighting change |
attribute_transfer | take one trait -- a face, a colour, a texture -- onto something else |
weak_reference | MiniMax's own words: only broad similarity in style, category, composition or atmosphere. Nothing literal |
These are H3's own words, not ours. It reads them as instructions, so a wrong one is worse
than a vague
describes:
fully_preserved on a style reference asks the model to reproduce
the whole frame.
What a reference video actually carries. Motion, reliably. Grain, grade and fine texture,
not -- and where a clip's grade does land it overrides the light your words asked for, so a
sunny scene in the prompt beside an evening clip on the reference list is a fight your words
tend to lose. Ask for a film stock in words and keep the video for movement. The same trap in
miniature:
fully_preserved on a photograph taken at dusk brings the dusk along with the
animal;
partially_preserved keeps the animal and lets the light change.
A video's own soundtrack is a passenger. It is wired in beside the frames and numbered
whether or not you wanted it, so the compiler leaves it out of the prompt entirely unless
something you wrote names its token -- a clip attached for its motion is not a clip whose
sound you asked for. Named, it is described as the audio in that file, never in the words you
wrote about the picture. A clip used as a continuation or a frame anchor keeps its entry:
carrying the sound over is the point there.
An audio file is graded in its own words, because H3's format defines a different set
for sound:
fully_copy (reproduce this recording),
partially_copy,
reference (only the
timbre or texture is followed),
weak_reference. The picker follows the file, so there is
nothing to get wrong.
No marker copies the file's samples into the clip. A reference audio is encoded into
the conditioning, and the soundtrack that comes back is the one the sampler produced and
VAEDecodeAudio decoded --
fully_copy asks H3 to re-perform the recording, and how close
it lands is the model's business. To ship the recording itself, wire it into
CreateVideo
in place of the decoded audio.
A card that reaches the prompt as nothing is called out too: a card names a file, which
makes it a
<Subject n>, or describes a voice, which becomes the words in front of
(S1).
With neither, the compiled prompt is byte-for-byte what it would be with no card there, and
the row on screen says so. The reverse is called out too: a voice nobody speaks with, where
no line names that card's
S -- an instruction about how somebody sounds, applied to
nothing.
Subjects live on subject cards. Point a card's
from at a file and it becomes a
<Subject n> of its own, tracked apart from the picture it came from:
<Subject 1> is the man's face, from <Picture 2>.
That separation is what a face swap needs. The picture stays a
weak_reference -- you do
not want the whole frame back -- while the card's
keep it is
attribute_transfer onto
the person in another shot. The shot then mentions
<Subject 1> rather than
<Picture 2>,
because naming both asks for two different things at once.
onto on the card names who receives the face, and the block carrying the picture shows
the move as a chip. A picture whose only job is defining somebody gets no
<Picture n>
entry of its own: MiniMax's guide asks for it cited inside the
<Subject n> line instead.
An image used as a
first frame or
keyframe keeps its entry either way -- it is a real
frame of the video, whoever else it defines.
The block's FILE row shows that definition read-only, labelled with the
<Subject n> it
became and linked to the card. When the role does keep the file an entry -- a frame anchor,
an edit source -- the card's sentence fills that in as well.
Camera moves
A move is three choices, the way MiniMax documents it:
motion type,
amplitude,
speed. H3 reads prose, not enum values, so the three become one sentence.
| Motion | Sentence sent to the model |
|---|
— in words | nothing -- the note is the whole camera line |
static | The camera holds a static shot. |
zoom_in / zoom_out | The camera zooms in / out. |
dolly_in / dolly_out | The camera pushes in / pulls out. |
pan_left / pan_right | The camera pans left / right. |
truck_left / truck_right | The camera trucks left / right. |
tilt_up / tilt_down | The camera tilts up / down. |
pedestal_up / pedestal_down | The camera rises straight up / lowers straight down. |
orbit | The camera moves in an arc around the subject. |
tracking | The camera follows the moving subject. |
pov | The camera takes the subject's point of view. |
roll_cw / roll_ccw | The camera rolls clockwise / counterclockwise. |
handheld / shake_strongly | The camera shakes slightly / strongly. |
A zoom and a push-in are not the same move: a zoom changes the focal length with the
camera standing still, a push-in moves the camera body. The model knows the difference.
amplitude (small / large) and
speed (slow / fast) are added when set -- *The camera
pushes in with small amplitude at slow speed.* Both default to medium and normal, which
the guide writes by leaving them out, so those options add nothing on purpose.
A note typed into a camera segment is appended after the sentence, so write it as a
continuation rather than a sentence of its own. Camera work is its own block because a
move can straddle a cut -- merging it into the shot line would silently pick a side.
What the linter now checks
report warns, never refuses: a description outside the
350-500 words MiniMax asks
for on a generation task; two adjacent shots that describe the same thing at a different
framing (the guide asks for a camera move, not a cut); an empty AUDIO track, because
overall_soundscape: N/A tells H3 the clip is
completely silent; a voice reference
asked to be copied; more reference material than H3 takes -- 9 images, 3 videos, 3 audio,
15s of video and of audio, 12 files in all; a picture outside 256-5760px or outside a 0.4-2.5 ratio -- that one and a clip outside 2-15s are
refused when the file is picked, before anything is placed, and the three media buttons go dim once
their bucket is full;
a line marked
carries over with nothing after it; and a guessed word
where the guide wants
[unclear].