Animating on Twos: Training Keyframe-Animation Adapters on a Pretrained Video Model

Alvdansen Labs
Minta Carlson, Timothy Bielec
August 2026

Figure. What the method is for. A cut from a vertical short in progress: an overhead of her walking to the mushroom, the face in shadow, the blade coming up, and the jump back. Sev
Figure 1. What the method is for. A cut from a vertical short in progress: an overhead of her walking to the mushroom, the face in shadow, the blade coming up, and the jump back. Several shots, the artist's keys, the adapters carrying the drawings between them.

Abstract

Large pretrained video models can render photoreal motion and, increasingly, illustrated motion. They are nonetheless poor animators. The failure is easy to miss, because every individual frame can look right. What breaks is the motion style: the physics of how a drawing moves. It drifts between and even within generations, sliding without warning between vector interpolation, digital easing, anime limited-animation, and traditional hand-drawn cadence. In hand-drawn animation, motion style is a load-bearing storytelling channel. It is the instrument and the actor; the exact nature of how a character performs physically in a scene in large part defines them.

This paper describes a methodology for teaching one such model, the open-weights MiniMax H3 (a 33-billion-parameter video diffusion transformer), to animate in a consistent and cross-stylistic hand-drawn cadence, using small LoRA adapters trained from a private hand-drawn animation corpus. We work backwards from how animators actually key a scene rather than from what the model finds conveniently on distribution, and arrive at three sibling adapters: next keys (hero), inbetweens (tween), and short held sequences (sequence), distinguished by how many reference drawings each is conditioned on and what the distance between those drawings is asked to mean.

We also give a portable caption dialect built from real animation vocabulary, a chained subset-rotation training schedule, and the exact tensor surgery required to make a conventionally-trained LoRA apply to this model's fused attention projections.

Finally we argue that the standard video-generation metrics are blind to the one axis that matters here, cadence, and describe the cadence and comparison instrumentation we built instead. That instrumentation has a hard limit: it measures the magnitude of motion, never its quality, and the quality judgement stays with a human.

This is a methodology paper: a working process and its instrumentation, with the validated, in-progress, and still-open parts marked as such.

The adapters are available. All three — hero, tween, and sequence — are published at huggingface.co/alvdansen/h3-keyframe-animation, converted and ready to load. The model card carries the conditioning contract for each, the inference settings that produced the figures in this paper, and the caption dialect of §5, which is the actual interface to them. Read it before the first render: the three ways these adapters fail are all silent, and the card leads with them. The adapters modify MiniMax H3, whose own license binds you directly and is not ours to grant.

1. Introduction

The animation this paper is about is the classic, hand-drawn, cel kind: the tradition of classic anime or golden age with rich, organic flowing scenes. Or the Saturday morning cartoons we grew up with that had a warmth and glow you hardly ever see on screen anymore. It is some of the most beautiful work the medium has produced, and some of the most expensive. A hand-drawn film is built drawing by drawing. At the standard cadence of twos, a single second of screen time is twelve frames, and a feature is tens of thousands of them. The labor shows up in the schedule: on The Boy and the Heron, the most expensive Japanese film ever produced, a team of roughly sixty animators finished about one minute of film a month. Costs like that are why the form has thinned out. U.S. studios have all but abandoned hand-drawn features, and only a handful reach theaters worldwide in a given year.

The form is also more popular than it has been in years. Over half of Netflix's roughly 325 million subscribers watched anime in 2025, some 8.9 billion hours of it, and the global anime market, around 38 billion dollars, is growing near 9 percent a year. Audiences want more of this work than the economics of making it can supply.

The keys are the smaller part of that cost. A lead animator draws the extremes of a motion, the poses that hold the acting; the bulk of the work is the inbetweening that connects them, drawing after drawing, in one consistent hand. That inbetweening is also what the industry has spent decades sending offshore: roughly ninety percent of American television animation is produced in Asia, the drawing labor shipped to studios in South Korea, India, and the Philippines. That is the pressure this work is aimed at. If a model could carry the inbetweens in the artist's own line and cadence while the artist keeps the keys, the labor would stay with the studio that authored the work, an independent one could compete with a large budget, and more stories in more styles could actually get made.

A video model that produces a beautiful five-second clip is not, on that evidence, an animation tool. Animation is a craft with its own physics. Motion is built from held drawings that change on a rhythm (ones, twos, threes), with anticipation, overshoot, drag, and settle placed deliberately, and the spacing between drawings carries as much meaning as the drawings themselves. A model can render every individual frame in a convincing illustrated style and still animate badly, because the failure lives in the timing between frames rather than in any single frame.

We chose the substrate deliberately, and we should say plainly that MiniMax H3 is an excellent model. MiniMax's earlier video models showed an unusual facility with illustrated motion, at a point when community attention was drifting toward other systems as they pulled ahead on general benchmarks. We suspected before running it that H3 would be strong at animation on that lineage alone, and it is. What makes it the right substrate is the combination: a model this capable, with animation evidently treated as a first-class training target, released as open weights. The animation space has not had both at once before, and everything in this paper depends on having them.

Figure. An earlier MiniMax (Hailuo) generation. The facility with illustrated motion was visible in the lineage well before H3.
Figure 2. An earlier MiniMax (Hailuo) generation. The facility with illustrated motion was visible in the lineage well before H3.

The facility is real, and it is also slightly overfit and underdeveloped, in the same way our Forgetting on Purpose work documents for 2D illustration on Qwen Image, where a distinctive style trends toward the model's own bias [6]. H3 carries a good deal of baked-in animation language, yet not enough of it can be reliably controlled for clean interpolation, and it still takes liberties on style, defaulting in most cases to a particular digital look. Those are the gaps a finetune can close, which is the whole reason the model rewards training rather than replacing.

Our practical starting point was a blunt observation from production use: likeness is excellent, style-likeness is strong, and motion style drifts and generalizes. Across a series of shots meant to cut together, the physics of the movement would wander between vector-smooth, digitally-eased, anime-limited, and traditionally hand-drawn, sometimes within a single generation. This is the same asymmetry that shows up everywhere in generative video: cinematographic language ("dolly in," "rack focus") is honoured, while traditional-animation language ("on twos," "hold, then snap") is only sometimes respected. If motion style is the thing that drifts, motion style is the first thing a fine-tune has to lock.

Why a finetune, rather than waiting for a larger model to solve it? Our hypothesis, developed in §2.3, is that cadence survives pretraining poorly for a structural reason: no standard metric can see it, and a frame-wise training objective quietly prefers the smooth blend that cadence forbids. If that holds, the problem does not dissolve with scale, because more data does not help when nothing scores the axis. A small dataset built so that cadence is explicit in the examples, paired with a human who can actually judge the result, addresses precisely what the large-scale process leaves out.

One framing point governs how the results should be read. Everything here comes from a single training run per adapter. We did not retrain, tune against outcomes, or build the dataset around this test; the corpus is a hand-drawn collection that already existed and was assembled for other purposes. What follows is therefore the floor of the method rather than its ceiling, which is the part we find most promising: the obvious improvements, a purpose-built dataset, cadence-targeted selection, ordinary hyperparameter search, are all still on the table and none of them have been tried.

This paper makes three contributions:

  1. A use-case-first adapter design. Rather than one "animation LoRA," we derive three adapters directly from how animators key a scene: the natural next hero key, the inbetween that advances one step, and the short held sequence. We structure the whole approach around the claim that the design axis that matters is the conditioning contract (how many reference drawings, and what their separation means) rather than any change to the network. The three also let us test the limits of minimum frame count and how much each contract differs in real practice. That mattered for a specific reason: we needed to surface whether the model was attaching a meaningful relationship to the tokens it was given, or still working from a narrow inherited bias.
  2. A cadence-aware evaluation stance. We show why the off-the-shelf video and image metrics (pixel distance, PSNR/SSIM, CLIP similarity) are structurally blind to animation cadence, describe the held-frame instrumentation we use in their place, and state its limit plainly: it measures how much something moved, not whether the movement reads. The quality verdict is human, and we designed the review apparatus around that fact.
  3. What it takes to make any of it work. Two practical pieces, both of which are prerequisites rather than niceties. The first is the tensor surgery: a block-diagonal weight construction that lets a standard separately-projected LoRA apply to a model with fused QKV, the alpha bookkeeping that decides whether it applies at the intended strength, and the pruned-versus-unpruned distinction that decides whether it applies at all. Anyone loading the adapters we describe needs this. The second is a catalogue of silent failures, the ways this pipeline returns confident wrong output without raising an error, each with a cheap control that catches it.

Throughout, we treat the base model as a fixed, powerful, and somewhat alien substrate whose conveniences are not our goals. The model wants long clips where we need two-to-five-frame keyframe gaps. It fuses projections that our training tools keep separate. It rewards a live-action prompt vocabulary that would pull the work out of illustration entirely. In each case the use case is the requirement, and the model is the thing that gets bent to it.

2. Why Hand-Drawn Animation Is Hard for a Video Model

2.1 Motion style is a physics of movement

The axis that drifts is a physics of movement with (at least) four attractors: vector (smooth constant-velocity interpolation), digital (eased, tweened, motion-graphics timing), anime (limited animation: few drawings, long holds, snap-and-settle), and traditional hand-drawn (full or partial animation with hand-timed spacing). These are behaviours of the denoiser over time, and no adjective selects them the way "watercolor" selects a look. A video model trained overwhelmingly on live-action and interpolated-motion footage carries a strong prior toward the vector/digital end. This pull toward a smooth, digital default recurs across models, which points at a shared cause rather than one vendor's choices. We give our hypothesis for what that cause is in §2.3. Asked to animate, MiniMax H3 slides toward that prior between shots, and sometimes mid-shot. Each individual frame can still render in a plausible drawn style, so the drift is easy to miss frame-by-frame and obvious in motion. That is exactly why it survives naive review.

Figure. The traditional attractor, held. One 22-frame window from sequence, collapsed to its ten unique drawings, each held two frames. Every individual frame here would look equal
Figure 3. The traditional attractor, held. One 22-frame window from sequence, collapsed to its ten unique drawings, each held two frames. Every individual frame here would look equally plausible on ones; the cadence is what distinguishes them, and it is the thing being learned.

2.2 The range gap: the useful region is off-distribution

Working backwards from the craft exposes a structural mismatch between what keyframe animation needs and what the model was trained to produce.

The model emits clips whose frame count follows a fixed law, frames = 17n + 5, giving a shortest legal clip of 5 frames and a trained range of roughly 124–362 frames (about 5–15 seconds at 24 fps).

Keyframe animation works at a completely different granularity. How many inbetweens sit between two keys is not a fixed number; it is a decision recorded on a spacing chart, set per action, where fewer inbetweens read as fast and snappy and more read as slow and controlled. What is consistent is the order of magnitude. A pair of keys is separated by a handful of drawings, and in our own practice the working gap for hero keys is two to five frames. Even taking a generous reading of the craft, where a slow move might carry a dozen inbetweens, the gap is single digits to low double digits.

Figure. The working gap, drawn. A whole hero beat resolves into five drawings, the order of magnitude the craft actually works at — against a model whose shortest legal clip
Figure 4. The working gap, drawn. A whole hero beat resolves into five drawings, the order of magnitude the craft actually works at — against a model whose shortest legal clip is five frames and whose trained range does not begin until 124.

The model's floor is 124. The entire useful region therefore sits at or below the model's shortest legal clip and roughly 25–60× below the bottom of its trained range. The need and the trained regime barely overlap, which makes this a structural mismatch well beyond a tuning problem at the edge of the distribution.

Two honest routes follow, and we name both rather than pretend the gap away:

The harvest route works, though it is awkward. Given a long runway, a pretrained model fits the action to the runway, so the frame at a genuine key-to-key distance from the start can land anywhere from a tenth of a second to over two seconds in. There is no fixed frame index to grab; the position has to be measured and searched for, and where it lands is itself a finding about the model's pacing. (§9 records that the short-length training route is, at time of writing, blocked below 22 frames by a decoder limitation in one inference path, and that the adapter's own trained clip length and the renderable clip length on that path are presently disjoint. That is an open problem.)

The tween adapter (§3.1) is our answer to this. We train the model to advance by a single small step, so a longer generation slows to only a few distinct drawings and the next key sits reliably inside it. That turns the harvest from a search into a read.

2.3 Nothing measures cadence, which may be why the models never learn it

The instruments most readily available measure the wrong thing. Pixel frame-difference measures position, not motion language: a cut from anime-on-twos to smooth digital interpolation scores as perfectly continuous, because the pixels line up. PSNR and SSIM underperform perceptual measures on line art. CLIP similarity rewards hue agreement, whereas for hand-drawn identity hue drift is often permissible and value-rank collapse is the real failure. None of these sees cadence at all. An evaluation stack assembled from defaults will therefore certify a broken result, with no sign that anything went wrong.

That is a problem for our own evaluation, and §7 describes what we built instead. It also suggests something larger, which we offer as a hypothesis rather than a finding.

The hypothesis: cadence is hard to learn at scale because nothing scores it, and the objective quietly prefers the alternative. Consider what a frame-wise training objective rewards. When the model is uncertain about what the next drawing should be, the lowest-error output is the average of the possibilities, and the average of two drawings is a soft blend between them. Smooth interpolation is that hedge. Animating on twos requires the opposite behaviour: hold one drawing exactly, then commit to a discrete jump. A model that splits the difference between holding and jumping produces a small continuous drift, which scores better frame-by-frame than committing to either, while being wrong as animation. The objective rewards the hedge, and no benchmark downstream penalizes it, so at no point in training or model selection does the smooth default get punished.

If that is right, it explains the pull toward smooth, digital motion we see across models (§2.1), and it carries a practical consequence: this is not primarily a data-volume problem. Adding more hand-drawn footage to a pretraining corpus does not obviously fix an objective that prefers the blend and a scoreboard that cannot see the difference. It also explains why finetuning is the lever we reach for. A small, deliberately built dataset can make cadence explicit in the data itself, holding each drawing exactly two frames so the hedge is not what the examples demonstrate (Appendix E). A narrow distribution gives the model less room to fall back on its prior. And a human grading the result supplies the judgement the metrics cannot, which is why §7.4 treats the animator's eye as part of the instrument rather than a limitation of it.

One thing has changed recently enough to be worth marking. This methodology was not available on previous generations of open models. What the current wave of open-weight omni models provides is the specific combination it needs: strong illustrated-motion priors already in the weights, multiple conditioning paths that accept reference drawings as first-class input, joint handling of the modalities a production actually carries, and weights open enough to adapt and inspect. Earlier open models were missing at least one of those, usually the conditioning, and the approach had nowhere to attach. The gaps we describe in this paper are real, and they sit on top of a foundation that finally supports the work.

We have not run the experiment that would confirm this, and §9 lists the control that would begin to.

3. Working Backwards From How Animators Key

3.1 Three adapters, one design axis

We did not set out to train "an animation LoRA." We set out to support the three distinct acts an animator performs when keying a scene, and let those acts define the adapters. The result is three siblings that share one architecture and differ in their conditioning contract: how many reference drawings each receives, and what the distance between those drawings is asked to mean.

The shape of this comes from an artist-first premise. Animation is unusual among screen crafts in that authorship has always sat with the people who draw. Directors in this medium overwhelmingly come up through the craft, through key animation, layout, and storyboard, often after many years at a desk drawing by hand. There are exceptions, including directors who arrive from live action, but the dominant path runs through the drawing.

That background is a technical qualification, not a credential. Animators study movement: how weight transfers, how a limb drags behind the body, how long a pose holds before it breaks. Their particular skill is directing movement from stills, choosing which few drawings imply a motion and where to place them so the eye fills in the rest. A model that removes them removes the only person who can specify that, and no one behind them is trained to take over. So we designed for an animator at the desk. They draw the keys, the extremes that carry the acting, and the adapters take the labor between. Every conditioning contract below answers a question an animator already asks.

Figure. The sequence act: one window, filled. The drawings the adapter produces between the window's first drawing and its own natural end, held on twos.
Figure 5. The sequence act: one window, filled. The drawings the adapter produces between the window's first drawing and its own natural end, held on twos.
Adapter The act it supports Conditioning What the second reference's distance means
hero Draw the natural next hero key 1 reference, the current hero key No second reference. Where the action goes next is the question being asked; showing the model a destination would be showing it the answer.
tween Draw the next inbetween, advancing the motion one small step 2 references: a rolling current frame, plus the beat's distant end extreme, held fixed for the whole chain Far, deliberately. The end extreme provides context: it tells the next inbetween which way to lean, without being the thing to interpolate to.
sequence Surface a short, self-contained held sequence already latent in the model 2 references: the window's first drawing and the window's own natural end One window to fill: a complete keyframed clip on twos.
Figure. The hero contract: one reference, the current hero key. Untrained fl2va (left) against the final checkpoint (right), same input and same seed.
Figure 6. The hero contract: one reference, the current hero key. Untrained fl2va (left) against the final checkpoint (right), same input and same seed.
Figure. The tween contract: two references, a rolling current frame and the beat's distant end extreme held fixed. Untrained fl2va (left) against the final checkpoint (right), same
Figure 7. The tween contract: two references, a rolling current frame and the beat's distant end extreme held fixed. Untrained fl2va (left) against the final checkpoint (right), same inputs and same seed.
Figure. The sequence contract: two references, the window's first drawing and its own natural end. Untrained fl2va (left) against the final checkpoint (right), same inputs and same
Figure 8. The sequence contract: two references, the window's first drawing and its own natural end. Untrained fl2va (left) against the final checkpoint (right), same inputs and same seed.

Two consequences follow.

The reference count is fixed per adapter. Each adapter is trained under exactly its contract. Supplying the wrong number of references (a second reference to hero, or a near reference to tween where the fixed far extreme belongs) does not throw an error. It silently conditions the model outside the regime it was trained in and quietly degrades the result. The graph builder enforces the contract, so it is not left to the caller's discretion.

Teach a task versus surface a behaviour. hero and tween teach the model a mapping it does not reliably have: given these drawings, produce the next one. sequence works differently. Hand-drawn-looking held animation already exists somewhere in the base distribution, and the adapter's job is to make the model surface it more consistently, to steer rather than teach. sequence therefore gets its own caption dialect (§5), and a different expectation at review time: a surfacing adapter should converge early and change little across its late checkpoints, where a teaching adapter keeps moving. Whether sequence's final window has gone flat is one of the things the convergence grid in §7.3 shows.

3.2 The base model, briefly

The substrate is MiniMax H3, an open-weights ~33-billion-parameter dense, single-stream video diffusion transformer (50 blocks, hidden width 5376, 56 attention heads of 128). It renders up to 768p locally at 24 fps and jointly generates audio through the same blocks. It ships as CFG-distilled checkpoints: guidance is baked into the weights, so there is no negative branch (a fact that governs the entire prompt dialect in §5). Its attention projections are fused into a single qkv_proj per block, and its adaptive-layernorm timestep conditioning is factorized into a compact table-plus-bottleneck rather than a dense per-block modulation. These two structural facts dominate the training engineering in §6 and Appendix B.

Two distinctions in the model's plumbing are easy to conflate, so the terms are fixed here. First, two conditioning paths exist and do not share slots: a reference-conditioning path that accepts N soft reference images, and a first/last-frame path that accepts hard endpoints. The adapters in this paper are driven through the reference-conditioning path. Second, the model ships in several weight partitions and quantizations. The adapters are trained against the unpruned reference-partition checkpoint (the one whose adaptive-layernorm branch is present in full, §6.3) and transferred onto the serving checkpoint at inference. We rely on that transfer in practice but have not independently measured it (§9).

One measurement about those partitions shapes how we read the model's behaviour. We compared the reference-conditioning partition against the first/last-frame partition tensor by tensor, and the reference partition is a fine-tune of the other, not an independently trained model. The relative distance between them is about 2.8% at the median, where two independently trained partitions would sit near √2. Their configuration files and tensor indices are byte-identical. The distribution of the change says more than its size: the tensors that moved most are the query and key projections in a narrow band of late blocks, plus the adaptive-layernorm projection, which is what you would retune to make a model accept reference tokens, while the attention norms barely move at all.

That reading explains something we kept noticing in practice. Reference conditioning behaves less like a separate capability and more like a thin layer over the same underlying motion model, which is why the behaviours we want are so readily surfaced through it and so quickly locked back in by a small adapter. (A related question, whether an adapter trained on one partition can then continue onto the other, follows naturally from this and remains unproven, §9.)

3.3 From image-edit to video

The design was validated before it reached a video model. We first built hero and tween as adapters on Qwen-Image-Edit, an image-edit model that generates one next keyframe at a time from the previous drawing, on the same chained schedule and caption dialect used here. The prototype confirmed the method: the conditioning contracts and the captions did their jobs, and the outputs were good enough to establish the approach. The limit was consistency. An image-edit model regenerates each keyframe and re-encodes it as the input to the next, so small losses accumulate down the autoregressive chain, and identity and line held for only a few steps before drifting. A video model keeps a whole clip coherent in a single generation and supplies real inbetween frames, and that is what carried the work to MiniMax H3 and to longer frame counts.

The move also forced a rethink of hero and tween. On an image-edit model, a training example is a still, and the target is simply the next drawing. A video model has no such thing: the shortest legal clip is five frames, so there is no way to hand it a single image as a target. Our answer was to build those examples as a uniform freeze, the same drawing repeated across all five frames, which encodes to two latent frames and keeps both references at full fidelity (§6.2). That constraint is why hero and tween train at a different frame bucket than sequence.

4. Conditioning Mechanics and the Silent-Failure Catalogue

Everything in this section shares a property: it fails quietly. The pipeline runs, produces a confident well-composed clip, and is wrong. In a conditioned generation stack the loud failures take care of themselves; the ones that cost real time and money are the ones that never raise.

4.1 The conditioning contract, exactly

The reference path's autogrow slots take flat, dotted keys at the node's top level: ref_images.ref_image_0, ref_images.ref_image_1, and so on. This matters because the two nearby spellings both fail in instructive ways:

One node setting is load-bearing: the reference-resize mode must be max (the full high-resolution reference pipeline). Under match (shrink references to the output's pixel area) identity comes out soft, and the failure then looks like a training problem when its cause is configuration.

The two conditioning paths also treat aspect ratio differently, which bites when reference and output aspect disagree: on the first/last path the first frame is stretched to the output aspect and the last frame is center-cropped, so a mismatched aspect distorts the two endpoints differently. Author keyframes at the generation size. The reference path preserves aspect and is the safer default.

4.2 The six silent failures

Each entry below is a failure we hit, the reason it does not throw, and the cheap control that catches it.

  1. Conditioning attached to nothing (the nested-key trap above). Why silent: the malformed structure is ignored and generation proceeds unconditioned. Control: run a zero-reference generation first, every session, at the same prompt and seed. Three independent tells separate live from dead conditioning at matched resolution: sampling rate (a dead run is measurably faster, because it skips the reference pipeline), frame-difference against the zero-reference control (near-zero when dead, large when live), and, when audio is in play, output loudness. If a referenced run matches its zero-reference control, the conditioning is dead. This costs one cheap generation per session.

  2. An adapter that loads but applies nothing (§6.3). Why silent: the framework does not warn on unmatched adapter keys, so a name mismatch between the adapter and the fused model reads as "a weak LoRA." Control: a --verify pass that counts matched target modules (we require every one), plus an A/B at matched seed with the adapter on and off. A real adapter moves a large, obvious fraction of pixels; a dead one moves essentially none.

  3. A metric that scores a moving clip as frozen (§7.2). Why silent: a comparison metric run on mismatched paper tone, or with a saturated line mask, returns "no change" for a clip that plainly moves. Control: look at the picture. We caught this one by eye: the first frame showed a book fanned open and the harvested frame showed it shut, against a reported change of zero. The fix aligns the paper tone first and bails if the mask saturates.

  4. A guard that fires after the expensive work is done. Why silent: a duration/parameter check that reads its limits off the wrong object passes at submit time and only raises after tens of gigabytes of model loading and a full denoise. Control: validate the guard against a cheap synthetic case before committing a real run; assert on the object the value is actually read from, since it can differ from the one it is set on.

  5. Corrupted reference frames that look plausible. Why silent: an end-reference staged as a zoomed sub-crop (a close-up of one hand where the full frame belonged) is a perfectly valid image; the conditioning is wrong while nothing is malformed. Control: compare staged inputs against the original source rather than the staging copy, because the staging step is where the corruption entered.

  6. A phantom subject injected by an unconditional prompt block. Why silent: a prompt assembler that unconditionally appends a fixed block describing a recurring subject, regardless of whether the current shot contains that subject, will describe a character into a scene that has none, and the model dutifully draws them. Control: read the assembled prompt before theorizing about model behaviour. The character was in the prompt all along.

The through-line: run the controls every time. A zero-reference control on every session, a verify-and-A/B on every adapter, an eyes-on-the-picture pass on every metric verdict. Each control is cheap relative to the failure it catches.

5. The Caption Dialect

A caption here is the inference interface. Whatever the adapter is trained to read is what a user later types to drive it, so the caption schema is a design decision about the tool's controls. Three properties hold across all three adapters.

Content rides in on the image; the text names the craft. No character, show, or franchise name ever appears in a caption. Identity enters through the reference image; naming a specific design in the text channel binds that design into the words and is precisely the leakage we avoid. The caption describes subject-type, medium, motion, and framing in general terms and lets the reference carry the rest.

Every token is positive. Because the checkpoints are CFG-distilled, there is no negative branch: every word written is a positive token. "A dot, never two, never three" injects two and three next to dot and yields the failure it meant to forbid. The dialect therefore contains no negations at all: state the desired condition and stop. (This is specific to this model class.)

Craft vocabulary, used only where true. Animation terms (drag, settle, follow-through, anticipation, weight shift, leading edge, and above all "on twos") act as real anchors, used only where they are literally true of the clip and never as invented trigger tokens. "On twos" appears because the clip genuinely holds each drawing two frames; it is never a lie the model is asked to reconcile.

Figure. Eleven drawings, each held two frames, on clean line. The on-twos rhythm the caption names in Subject and the Action honours.
Figure 9. Eleven drawings, each held two frames, on clean line. The on-twos rhythm the caption names in Subject and the Action honours.

The three portable shapes (full templates in Appendix D):

Figure. The step-size lever at work. Eight unique drawings advancing one step at a time toward a far extreme that never moves under them. The modal hold here is three frames rather
Figure 10. The step-size lever at work. Eight unique drawings advancing one step at a time toward a far extreme that never moves under them. The modal hold here is three frames rather than two — a slower reading of the same beat.

Two levers recur. Medium is a hard, character-for-character lever. It is one of a small fixed set of strings (e.g. clean line on white, flat black-and-white animatic, flat cel colour on white), chosen by eye and kept byte-identical, because it selects the output type and any drift in the string drifts the type. The reason clause on Camera is the active ingredient. A camera constraint stated with its reason ("a low three-quarter angle, so the silhouette stays readable") is honoured where the bare angle is ignored. Preserve constrains only the axis it names, so name every axis you care about, or the failure moves to the one you left out.

6. Training the Adapters

6.1 The chained schedule: forgetting as regularization

The adapters are trained on a chained subset-rotation schedule. The dataset is split into disjoint batches sampled round-robin (stems[i::3] under a fixed seed, so each batch samples the whole distribution rather than a contiguous slice). Each batch is trained for a fixed number of steps. A final full-set consolidation pass then reintroduces the complete dataset to repair whatever the per-batch passes overshot. The mechanism is deliberate: each phase warm-starts the adapter from the previous phase but with a fresh optimizer at step zero, and that fresh optimizer on a new disjoint batch is the forgetting, a periodic and controlled discarding of batch-specific memorization that acts as regularization. (Each phase needs its own output directory, or the trainer resumes optimizer state instead of warm-starting, and the mechanism is lost.) One lap is batch_a / batch_b / batch_c / full; the run is three laps. This schedule is a video-model application of a chained-training pattern the authors published separately for small-dataset image LoRAs; we treat it here as an inherited method rather than a claim.

6.2 Hyperparameters and the deliberate exceptions

The recipe is intentionally close to a known-good small-dataset image recipe, with a short list of deliberate deviations for video:

Knob Value Note
LoRA rank / alpha 64 / 64 Rank = alpha keeps the applied scale exactly 1.0 (§6.3). A cold start (no warm-start from any existing adapter) warrants the higher rank.
Learning rate / optimizer 5e-5 / adamw-8bit, constant Parity with the image recipe.
Reference dropout 0.0 House default is 0.2; here the references are the geometry of the answer, so they are never dropped.
Precision / batch / seed bf16 / 1 / 42 Parity.
Checkpoint cadence every 50 steps, never pruned This model cannot sample in-loop in the current setup (§9), so dense checkpointing is the only way to recover a review series after the fact.
Schedule length 3 laps × 4 phases × 1,000 = 12,000 steps All three adapters completed three laps.

Two video-specific subtleties matter. Frame bucket by adapter: hero and tween are trained as a 5-frame "still", five identical frames forming a uniform freeze that encodes to two latent frames. This keeps the packed sequence well under the accelerator ceiling and lets both references ride at full fidelity. sequence trains at 22 frames (eleven drawings on twos). The cache-encode length and the render/validation length are different numbers and must not be conflated; conflating them is a documented crash. Train against the unpruned reference-partition weights. The training checkpoint must be the one whose adaptive-layernorm branch is present in full, because an adapter trained against the full model may not fully land on a pruned repack where that branch has been dropped (§6.3, Appendix B).

6.3 Making the adapter apply: fused QKV, alpha, and pruning

Three things independently determine whether a trained adapter does anything at all, and all three fail silently when wrong.

Fused QKV (the core surgery). Standard LoRA training tools produce adapters with separate query/key/value projections (to_q, to_k, to_v). This model fuses them into one qkv_proj. Loaded raw, not one key matches and the adapter does nothing, with no error raised. Fusing does more than concatenate the up-projections: each of Q/K/V has its own down-projection, so a naively stacked up-matrix would apply the wrong down-matrix to two-thirds of the output. The exact construction is stacked-down, block-diagonal-up:

A_fused = [A_q ; A_k ; A_v]              (3r × in)
B_fused = diag(B_q, B_k, B_v)            (3·out × 3r)
B_fused @ A_fused = [B_q A_q ; B_k A_k ; B_v A_v]   (exact)

This takes a rank-r adapter to 3r on the fused attention entry, which is the minimal exact form and not a capacity change. The corresponding key renames for the output and MLP projections follow (Appendix B). We verify every conversion: all target modules must match, and an on/off A/B at matched seed must move a large fraction of pixels.

Alpha. The applied strength of a LoRA is alpha / rank. Trained here with rank = alpha = 64, the scale is exactly 1.0, so emitting no alpha key is correct and strength 1.0 is the trained strength. It should not be walked back at inference. An adapter that only behaves at reduced strength is a symptom to investigate rather than a knob to turn.

Pruned versus unpruned. The adaptive-layernorm timestep conditioning is factorized in the architecture (the compact table-plus-bottleneck of §3.2). Pruning drops that adaptive-layernorm branch in some inference repacks. It does not remove the model's trainability, so pruned checkpoints still train. An adapter only applies where its target modules survived the prune. Train (and, ideally, run) against the unpruned reference-partition weights, where the branch is present in full, and keep adapters on attention and MLP, where they survive either way.

7. Evaluation

7.1 A cadence metric, because pixel distance is blind

Cadence is the one axis that must be measured, and it is exactly the one frame-difference cannot see. We instrument it directly with a held-frame run-length measure: over a clip, the modal length of a run of near-identical frames is 1 for smooth/ones, 2 for twos, 3 for threes. Two implementation points are load-bearing. First, the "near-identical" threshold must be relative to each clip's own step distribution, because a held drawing still wobbles slightly from codec and VAE noise and a fixed epsilon reads threes as ones; we split at a fraction of the clip's own high-percentile step size. Second, the measure is meaningless below ~8 frames, so it does not apply to the shortest clips. This metric turns "did the cadence hold, or did it slide off twos" into a number instead of an argument.

Figure. What the held-frame measure counts. Eleven distinct drawings recovered from 22 frames at a modal run length of two: on twos, as a number rather than an argument.
Figure 11. What the held-frame measure counts. Eleven distinct drawings recovered from 22 frames at a modal run length of two: on twos, as a number rather than an argument.

7.2 Comparison, done correctly

Comparing a generated frame to a reference drawing has two traps we hit and fixed:

Figure. Line art is where the distance metric earns its keep. Eight drawings on clean line — the medium in which a one-pixel shift destroys thin-line overlap and a Chamfer di
Figure 12. Line art is where the distance metric earns its keep. Eight drawings on clean line — the medium in which a one-pixel shift destroys thin-line overlap and a Chamfer distance still reports the truth.

7.3 An honest baseline and a served grid

The baseline is the untrained first/last-frame path, the tool a practitioner would actually reach for to inbetween two drawings, run on the same unpruned checkpoint as the trained adapters. The review apparatus is a convergence grid. Per probe, it shows the input drawing(s), the untrained baselines, and a row of checkpoints across the final consolidation window. The grid is served locally and streamed rather than embedded, because a page of ~120 clips will not survive being inlined, and it is frame-stepped by seeking to interval midpoints so each cell shows a representative frame rather than the first. The grid samples the final 250 training steps at 50-step granularity, a convergence view of whether the last consolidation phase is still moving or has settled.

Why so much of the probe set is black-and-white linework. Two failures showed up in the baseline beyond the excess of motion and the difficulty with real interpolation. The third was colour: given clean black-and-white linework, the untrained path would frequently recolor it, introducing tone and fill that the drawing never had. We leaned into that. A good part of the probe set is deliberately straight linework, because it is the hardest case in both directions. It is the hardest to fake, since there is nothing to hide a wrong line behind, no rendering or texture to carry a frame that is drawn badly. It is also the hardest for a model to hold, since it demands consistent line weight and closure with no tolerance for the smear that colour work absorbs. MiniMax H3 is a strong model and it shows the same weakness. Choosing the hardest medium as the standing test is what keeps the evaluation honest.

7.4 What the metrics do not do

The cadence and distance metrics measure the magnitude and rhythm of motion. They do not measure whether the motion is good. In direct use, a pass scored well on every automated measure and was a washed-out blur. A first-frame pass the metrics scored as a full success graded, to the animator's eye, as roughly half-successful, because "moved by the right amount on the right rhythm" is not "reads as the next beat." We added a sharpness check after the blur incident, but no metric here sees picture quality, and we stopped pretending otherwise. The human grades the picture; the metrics triage which clips are even worth grading. The review grid is built around that division of labour: it exists to put the right frames in front of a person quickly, and does not itself render a verdict. Relatedly, training loss is near-meaningless at this dataset scale and is not used to rank checkpoints.

The travel measure has a narrow job. It works well as a training-time instrument: across checkpoints it tells us whether the amount of motion is converging toward the band real keys occupy, which is a question about the run rather than about any one clip. It is nowhere near complex or nuanced enough to grade clips or to automate selection in an animation pipeline. Deciding whether a drawing is the right next drawing involves weight, arc, silhouette, and intent, none of which a travel number encodes. At this stage the metric steers the training; the animator picks the takes.

8. Results: Reading the Convergence Grid

This section reports the one result that does not require the human grading pass, a measurable reframing of the objective, and then describes how the served grid is read for the part that does. The per-adapter picture-quality verdict comes from an animator's grading pass over the grid, in progress at time of writing, and is deliberately not pre-stated. Per §7.4, the metrics triage and the animator grades.

Where the testing is concentrated. Most of our evaluation so far targets sequence. It is the adapter that produces a finished clip rather than a single harvested drawing, so it exercises cadence directly and is the one where the surfacing premise either holds or fails. hero and tween are trained to the same schedule and appear in the same grid, but their testing is less developed, and a fuller pass on both is work we still owe. Read the results below with that weighting in mind.

The measurable result: standardize the amount of motion. The objective, stated precisely, is to make the amount of motion standard, which goes beyond the easier question of whether the model can draw a next key at all. This is a claim the instrumentation can settle without a quality judgement. We measure travel, the key-to-key distance each clip actually moves relative to its target, with the medium-appropriate distance of §7.2 (Chamfer for line, changed-pixel for colour). The untrained first/last baseline produces a spread across probes of roughly an order of magnitude, from well under target to several times it, whereas real hand-drawn key pairs occupy a far tighter band of about 3×. The untrained model lands a frame at the target distance surprisingly often; what it cannot do is land it consistently. Pulling that spread down toward the band real keys occupy is the trained adapters' explicit job, and a quantity the grid backs directly. (These travel figures come from that distance measurement. They are unrelated to the internal partition-comparison figure in §3.2, which is not cited here.)

Figure. The same cadence on a different style. Seven drawings of a line-art creature held on twos, at the opposite end of the range from flat cel colour.
Figure 13. The same cadence on a different style. Seven drawings of a line-art creature held on twos, at the opposite end of the range from flat cel colour.

Consistency across styles. One result is already clear from review across the probe set: the trained adapters hold a consistent hand-drawn cadence across styles, from clean line to flat colour, where the untrained baseline slides between looks. It comes with one caveat, and a reasonable one. Inputs follow the conventions the dataset was built on: the subject on a white ground, the composition focused on what is moving, drawn in a traditional layered style. Those conventions come straight from animation-native production, so we count the caveat as a fair cost of a method born from that data. We think the same approach could reach the more complex layout structures of anime, where multiple planes and held backgrounds carry the composition.

How the grid is read for everything else. The grid places, for each probe and each of the three adapters, the untrained first/last baseline beside a row of late-training checkpoints, over held-out probe drawings that include the animator's own art and in-distribution controls. Read top to bottom, a healthy result shows the baseline producing an inert or off-cadence inbetween and the trained checkpoints producing motion that (a) advances by a plausible key-to-key amount, (b) holds the intended cadence, staying on twos instead of sliding to smooth, which the held-frame metric of §7.1 turns into a per-clip number, and (c) reads as the animator's line rather than the model's default illustration bias. Read left to right across the consolidation window, a converged adapter shows the last phase settling rather than still visibly changing checkpoint to checkpoint; this is also the check on the surfacing expectation of §3.1 (a surfacing adapter's late checkpoints should have gone flat). The graded pass ties these readings to the picture and supplies the per-adapter verdict. The magnitude result above stands independently of it.

9. Limitations and Open Problems

What follows is what a reader should discount, weighted toward the things that would change how the method performs in someone else's hands.

This is one shot, and it is the floor. The single most important qualifier is also the most encouraging one. Everything reported here comes from one training run per adapter. We did not retrain, did not tune hyperparameters against results, did not curate the dataset toward this test, and did not iterate on a failure and rerun. The corpus is a good hand-drawn animation collection that already existed; it was not assembled to make this work. There is no reason to think these adapters are near the ceiling of the method, and several obvious moves remain untried, including a dataset built deliberately for the task, cadence-targeted example selection, and simple hyperparameter search. Read the results as a lower bound on what the approach can do.

Resolution is below delivery. The open weights top out lower than finishing work requires, so the method proves out at a resolution short of what a production would ship. This is the most immediate practical barrier to using it as-is (§9.1).

Whether cadence survives the latent round trip is unresolved, and it is a real risk to the sequence premise. The sequence approach rests on an on-twos hold surviving encode and decode. If the model's temporal compression aggregates frames such that a two-frame hold falls below the latent's temporal resolution, no conditioning strategy recovers it, and the failure would look like ordinary smoothness rather than like a broken premise. That measurement was still running when this was written.

How much of the cadence comes from the caption is untested. "On twos" appears in the training captions, and it is often but not always present at inference. We have not run the control that separates the two, so we cannot say how much of the held cadence is the adapter and how much is the prompt reasserting it. That ablation is cheap and we should run it.

The objective hypothesis in §2.3 is a hypothesis. We argue that a frame-wise objective rewards a smooth hedge over a discrete hold, and that this is part of why cadence survives pretraining so poorly. Confirming it needs held-frame cadence measured across several base models on matched prompts, and a cadence-aware training signal compared against a frame-wise one on the same data. Neither experiment is run.

One artist, one corpus, one grader. The corpus is a single private hand-drawn collection, and the quality judgements are one animator's. Whether the method transfers to another artist's line, another studio's conventions, or a style far from this corpus is untested, and it is the thing we would most want a partner studio to help settle.

Style conventions are inherited from the data. Inputs follow the conventions the dataset was built on: subject on a white ground, composition focused on what moves, traditional layered construction (§8). Work that violates those conventions is outside what we have shown.

Two narrower notes for anyone reproducing the training. The adapters were trained against one weight partition and are served on another; that transfer works in practice but we have not quantified it. And the trained clip length and the renderable clip length are disjoint on one inference path, which is a limitation of the training and inference tooling rather than of the method, and it is why the harvest-from-long route of §2.2 is what we use today.

None of these is a reason not to publish the method; each is a reason not to overclaim the outcome. The contributions in §1 stand independently of where the final grading lands.

9.1 What we want to explore next

Four questions remain open, and each needs something we cannot supply alone: a modest dataset investment and the talent to key it. We would rather pursue them with a partner studio than approximate them in-house.

Character performance. Keys and inbetweens are the mechanics of motion; performance is the acting on top of them. Audio is the obvious driver, and dialogue-heavy animation already pairs a voice track with a drawn performance, so the paired data exists as a natural byproduct of production. Whether that existing pairing can train a performance-aware adapter, and whether audio drives articulation rather than merely riding alongside it, is the question we most want to answer.

Layering. Hand-drawn production is built in layers, with characters, effects, and backgrounds held on separate planes. Our current dataset conventions flatten that (§8). The open question is whether production assets can be used as they are, layer by layer, and whether an adapter can be trained to respect a layer's role rather than treating the frame as one image.

Fidelity. The honest ceiling right now is resolution. The open weights top out lower than finishing work requires, so the method proves out at a resolution below delivery. Closing that gap, whether through the model's own higher-resolution paths or a separate finishing stage, is a prerequisite for production use rather than a refinement of it.

Anime layout structure. As noted in §8, we think the approach could extend to the more complex layouts of anime, where multiple planes and held backgrounds carry the composition. That is the natural test of whether the conditioning contracts generalize past the conventions our corpus was built on.

10. Related Work

Video diffusion and conditioning. The base model, MiniMax H3, is a recent open-weights dense video diffusion transformer with joint audio and CFG-distilled checkpoints. Our contribution lies in the practice of adapting it under a strict conditioning contract.

Inbetweening and anime motion. Flow-based and structure-guided anime inbetweening establish two results we lean on: that hand-drawn inbetweening is its own problem distinct from optical-flow interpolation, and that perceptual and line-geometry distances (LPIPS, Chamfer) beat PSNR/SSIM for anime, which is the empirical basis for §7's metric choices. Bidirectional reference attention for identity in that literature is a conceptual sibling of our fixed-far-reference tween contract.

Small-data LoRA and chained/forget-and-relearn training. The chained subset-rotation schedule (§6.1) is a video application of a chained-training method the authors published separately for small-dataset image LoRAs, itself connected to forget-and-relearn regularization. The evaluation stance carries over directly: generalization within the trained concept is the quality criterion, above fidelity to training frames.

Fused-projection adaptation. The block-diagonal construction in §6.3 / Appendix B is a general recipe for applying separately-projected LoRAs to any fused-QKV transformer, independent of this model.

The specific works this section leans on are listed in the References.

11. Conclusion

A capable video model is not, by default, an animation tool, and the gap lives in how a drawing moves rather than in how it renders a frame. Motion style drifts, the useful keyframe granularity sits off the bottom of the trained distribution, the model fuses what training tools keep separate, and the standard metrics are blind to cadence. None of these is fatal, and none is solved by wishing the use case were shaped more like the model. The method here is the opposite discipline throughout: derive the adapters from how animators key rather than from what the model finds easy; enforce the conditioning contract that each act requires; run a cheap control against every silent failure; do the exact tensor surgery that makes a conventional adapter apply to a fused model; and measure cadence directly while conceding, in the same breath, that no metric grades the picture and a human still must. The remaining open problems, chiefly whether an on-twos hold survives the latent round trip, are stated plainly as risks. What we claim is a working process and the instrumentation around it. What we do not yet claim is a benchmarked victory, and we would rather name that line than blur it.

The stake, even so, is large, and it is the reason the framing in §1 matters. Each adapter here was trained on tens to low hundreds of examples, a dataset small enough that a studio could assemble and reproduce one from its own footage inside a normal production budget. It bears repeating that this came from one run per adapter, with no retraining, no tuning against results, and a corpus that was never designed for this test. Whatever these adapters do, they do it from the floor of the method. The labor that makes hand-drawn animation rare is the inbetweening. If a model an animator finetunes on their own material at that scale can carry that labor in the artist's own hand, the training stops being a research programme and becomes a line item, one an independent studio can budget for. That is what small-dataset finetuning offers here: tooling a studio can own and reproduce, keeping the artist at the helm of the work, and with it relief from the cost that keeps this art form scarce.

There is a labor dimension as well. Because each production trains its own small dataset from its own material, building and keying that dataset is itself animation work, on owned footage with clean provenance. The sensible unit is one model per production rather than one tool trained on everyone's drawings. Some of the drawing labor that has been sent offshore for decades could come back in-house, with the artists who do it kept at the helm of the result. None of this need come at anyone's expense: the studios that already carry this labor could adopt the same methodology and take on more of it. The method points toward more animation work, and toward keeping the people who make it central.

References

  1. Hu, E. J., Shen, Y., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., Chen, W. LoRA: Low-Rank Adaptation of Large Language Models. ICLR 2022 (arXiv:2106.09685).
  2. Zhang, R., Isola, P., Efros, A. A., Shechtman, E., Wang, O. The Unreasonable Effectiveness of Deep Features as a Perceptual Metric. CVPR 2018.
  3. Chen, S., Zwicker, M. Improving the Perceptual Quality of 2D Animation Interpolation. ECCV 2022.
  4. StructInbet: Structure-Guided Inbetweening for 2D Animation. SIGGRAPH 2025. (Establishes bidirectional reference attention for identity in inbetweening.)
  5. Zhou, H., Vani, A., Larochelle, H., Courville, A. Fortuitous Forgetting in Connectionist Networks. ICLR 2022.
  6. Carlson, M., Bielec, T. Forgetting on Purpose: Generalization as the Quality Criterion for Small-Dataset LoRA Fine-Tuning. Alvdansen Labs, 2026.
  7. MiniMax. MiniMax H3. Open-weights video diffusion transformer with joint audio, 2026. https://huggingface.co/MiniMaxAI/MiniMax-H3

Appendix A: Training Configuration

Common (all three adapters). LoRA rank 64, alpha 64 (applied scale 1.0); learning rate 5e-5; optimizer adamw-8bit; constant schedule; precision bf16; batch size 1; seed 42; reference dropout 0.0; checkpoint every 50 steps, no pruning of checkpoints; base = unpruned reference-partition weights.

Schedule. One lap = four phases (batch_a, batch_b, batch_c, full) × 1,000 steps. Three laps = 12,000 cumulative steps. Disjoint batches via seeded round-robin (stems[i::3]). Each phase in its own output directory, warm-started from the prior phase with a fresh optimizer.

Per-adapter. hero: 1 reference, 5-frame still cache bucket, arc-carrying MOVEMENT. tween: 2 references (rolling near + fixed far), 5-frame still cache bucket, landing <progress> step lever. sequence: 2 references (window first + window end), 22-frame (on-twos) bucket, alignment-line caption idiom.

Frame law. Legal clip lengths follow 17n + 5; cache-encode length (5 for hero/tween, 22 for sequence) is distinct from render length and must not be conflated.

Environment. Single 48 GB workstation GPU for inference/serving, running quantized weights (the bf16 model, ~66 GB, does not fit; an 8-bit/FP8 reference-partition checkpoint plus a quantized text encoder peaks around 34 GB); cloud accelerators for training. The reference-partition weights are the largest single dependency, and the fused-QKV conversion (Appendix B) is applied to every trained checkpoint before it can be loaded for inference.

Appendix B: Fused-QKV Conversion

The model exposes one fused qkv_proj per block where standard adapters carry separate to_q / to_k / to_v. Convert by stacking the down-projections and block-diagonalizing the up-projections:

A_fused = vstack(A_q, A_k, A_v)          # (3r, in)
B_fused = blockdiag(B_q, B_k, B_v)       # (3·out, 3r)
# => B_fused @ A_fused = concat(B_q A_q, B_k A_k, B_v A_v)   exact

Accompanying key renames (source to fused model): attention output to_out.0 becomes out_proj; MLP ff.net.0.proj becomes mlp.fc1 and ff.net.2 becomes mlp.fc2. Emit an alpha key only when alpha ≠ rank; here alpha = rank, so none is emitted and the applied scale is 1.0. Verify by (a) confirming every target module matches and (b) an on/off A/B at matched seed that must move a large fraction of pixels. Rank r becomes 3r on the fused attention entry, the minimal exact form and not a capacity change.

Appendix C: Cadence and Comparison Instrumentation

Cadence (held-frame run length). Compute per-frame step magnitudes; set the "held" threshold at a fraction of the clip's own high-percentile step (not a fixed epsilon); the modal run length of held frames is the cadence (1 ones, 2 twos, 3 threes). Do not apply below ~8 frames.

Comparison. Align on modal ground/paper level before any distance; derive the ink cut from the aligned paper; bail if the resulting mask exceeds 60% of the frame. Line art: symmetric Chamfer distance on thumbnails. Colour: changed-pixel fraction on thumbnails. Add a sharpness ratio (Laplacian variance vs the reference drawing) to catch blur that the distance metrics reward. Pick the "next key" inside a harvested clip by matching the measured key-to-key distance band rather than a fixed index.

Silent-failure controls. Zero-reference generation first each session (compare sampling rate, frame-difference, and loudness at matched resolution). Adapter verify (all modules matched) plus on/off A/B. Eyes on the picture for every metric verdict.

Appendix D: Caption Templates (portable shapes)

hero / early tween (three-section). Create the next keyframe in the sequence. SCENE: <framing + subject-type + medium + props>. MOVEMENT: <what moves, how, where it lands>. STATIC: <what holds, ending with framing + ground>.

tween (five-section). … SCENE: … FIRST FRAME: <pose in the near reference>. TARGET END FRAME: <pose in the far reference, phrased as a destination, never comparative>. MOVEMENT: <one step only>, landing <progress>. STATIC: <what holds, ending with framing + ground>.

sequence (alignment-line first). Picture 1 aligns with the 0.00-second mark of the target video; Picture 2 aligns with the <computed>-second mark. Subject: <medium + subject-type + ground>, animated on twos. Action: <motion path in beat order, held drawings changing on a rhythm>. Camera: <angle/move + the reason for it>. Preserve: <every axis that must not drift>, and the on-twos rhythm.

Rules across all three: no character/show/franchise names (identity rides on the reference image); no negations (CFG-distilled, every token positive); medium kept byte-identical from a small fixed set; the Camera reason clause is the active ingredient; Preserve constrains only the axes it names; craft vocabulary only where literally true.

Appendix E: Dataset Construction (reproducible outline)

The training data is a private hand-drawn animation corpus (on the order of 17,000 frames drawn from multiple source productions). Its identity is not part of this paper, and the construction below is given so a practitioner can build an equivalent set from their own footage.

A training example. hero: a pair, a hero key and the next hero key, several drawings apart. tween: a triplet, a current frame, the beat's fixed far extreme, and the target next frame. sequence: a 22-frame clip, eleven drawings each held two frames, plus the window's first and last drawing as the two references.

Selecting distances. Define a key-to-key distance band from genuinely sparse key shots (adjacent keys, a real key-to-key gap). For every shot, pick the frame stride whose median inter-frame delta best matches that band. Dense inbetween footage contributes wide-stride pairs, and sparse key footage contributes stride-1 pairs. Measure deltas with the same medium-appropriate distances used in evaluation (Chamfer for line, changed-pixel for colour).

Quality gate. Remove in-band-but-wrong-task examples: near-empty frames, greyscale where colour is expected, global camera drift standing in for character motion, subjects too small to carry a pose, rough construction underdrawings, scale jumps or cuts, and teleporting subjects.

Making "on twos." Real hand-drawn footage is overwhelmingly on ones. On-twos sequences are made by decimation: take every second drawing and hold each for two frames (stride-2, hold-2). That is what limited animation is, and it preserves the real-time motion speed (eleven drawings × two frames = the same twenty-two frame-times the original span occupied).

Frame handling. Source cels are typically RGBA on transparent grounds; composite onto white before use (a plain RGB conversion composites onto black and reads as solid ink). Keep references at high resolution; encode freeze/held clips losslessly (lossy ringing on one-pixel line art lands directly in the Chamfer metric).

Representative sizes (this corpus, after gating). hero ≈ 42 examples (batches 15 / 14 / 13); tween ≈ 144 (48 / 48 / 48); sequence ≈ 92 clips across 31 shots (31 / 31 / 30). These are small by fine-tuning standards by design; the schedule (§6.1) and the generalization-not-memorization criterion are what make small sets viable.

Article text: CC BY 4.0. Code snippets: MIT.