Style Consistency: Look-Locking So Every Shot Matches Across Generators

Let's do the news, and I'll be honest with you up front. The frontier video labs were quiet this window. We're talking June nineteenth through twenty-third, twenty twenty-six, and the big names, Google's Veo and Gemini Omni, ByteDance's Seedance, Kuaishou's Kling, Alibaba's HappyHorse and Wan family, OpenAI's Sora, plus Runway, Luma, and MiniMax, none of them shipped a new model or a new version in this exact stretch. So this is a quiet-week roundup. The genuinely fresh stuff lives in the secondary tier, and the lead item is a benchmark.

That benchmark is called WBench. Meituan's LongCat team, working with Fudan University, open-sourced a multi-turn benchmark for interactive video world models. And by interactive world model, I mean the playable, real-time class of system you can steer, not just a clip generator you prompt once and walk away from. WBench runs two hundred eighty-nine test cases across more than a thousand interaction rounds, and it evaluates twenty-two of these world models on five dimensions and twenty-two metrics. Things like navigation, actions, viewpoint control, and how well a model supports or resists what you tell it to do. The team claims it lines up well with human ratings. It became an official Hugging Face benchmark on June first with ready-to-evaluate videos from HY-World 1.5 and Kling 3.0, and inside this window the leaderboard picked up two new entries: LingBot-World, the fast variant, on the seventeenth, and DreamX-World, a five-billion-parameter model, on the eighteenth. If you care about comparing the playable world-model class instead of one-shot generators, this is the standardized yardstick to watch. Pull the live leaderboard.

Same team, second item, smaller. LongCat-AudioDiT. It's an open-source zero-shot voice-cloning and text-to-speech model, shipping in a one-billion and a three-and-a-half-billion size. The interesting bit is that it models directly in waveform latent space, dropping the usual mel-spectrogram and vocoder stages, and it claims new state-of-the-art for voice cloning. For us, that's an open option for dubbing or scoring a cut without paying per character.

Then the standing leaderboard check, and please hear this as a snapshot that reshuffles every month, not a ranking carved in stone. On the Artificial Analysis Video Arena right now, text-to-video without audio is led by Alibaba's HappyHorse 1.0, around twelve ninety-one Elo, with Dreamina Seedance 2.0 at 720p close behind. Add audio and HappyHorse and Seedance are basically tied. Image-to-video without audio is led by Seedance 2.0 at 720p. But a competing arena puts Kling v3 on top of plain text-to-video, and that disagreement is the whole point. Boards disagree. On price, as background that churns: Veo 3.1 runs about three cents a second with native audio, Seedance 2.0 Fast around nine cents at 1080p, Wan and Grok near five cents in the budget tier, and Gemini Omni still has no public per-second pricing. Bench on your own shots.

Okay. Today we're talking about style consistency. Some people call it look-locking, and I like that name because it tells you exactly what the job is. You're locking the look. The overall look of your footage. Not the character, the look.

Let me draw that line clearly, because it matters. We did a whole episode a while back on character consistency, which is keeping one person looking like the same person from shot to shot. Same face, same hair, same body, same wardrobe. That's a real problem and it has real solutions. This is a different problem. Style consistency is about the world that person is standing in. The color palette. The lighting mood. The film stock and grain. The lens character. The art direction. The overall rendering aesthetic. World coherence. All the stuff that, when it drifts, makes a viewer feel something is off even if they can't name it.

And here's the pitfall that names this whole episode. You generate shot one, it looks gorgeous, you're thrilled. You generate shot two, and shot two looks like a different movie. Same scene, same story beat, and yet the color is cooler, the grain is finer, the light is coming from somewhere else, and the whole thing reads like it was shot on a different camera by a different crew on a different day. That's the failure we're killing today. Shot two looks like a different movie.

There's a nice way to think about the categories here, and it comes from Kling's reference system in their 3.0 release. They split references into three types. Character Reference, which is face, hair, body, the person. Structure Reference, which is layout, perspective, composition, the bones of the frame. And in the middle, Style Reference, which is color palette, lighting mood, the artistic brush strokes, the feel. Style is that middle one. That's our target for the next half hour. Hold onto that three-way split, because it's a clean mental model and we'll come back to it.

A few callbacks before we dig in, because this episode sits on top of work we've already done. We did character consistency, and the mindset there, the consistency mindset, carries straight over. We did an episode on minting keyframes, building your start frames in an image model before you ever animate, and that's going to be a load-bearing technique today. And we did the cost-per-finished-clip episode, the one about not torching credits re-rolling for a look. That discipline is going to save you here too, because a lot of style problems you'd be tempted to fix by re-generating are actually cheaper to fix later in the grade.

Why style drifts in the first place

Let's start with why this even happens, because once you understand the mechanism, every fix makes sense.

The core fact is that each generation is stateless. The model has no memory. When you hit generate, there's a seed involved, and a seed is, in plain terms, the starting point for the random number generator that drives how the model builds an image. Without a seed, every generation is random, even with the exact same prompt. So the model is, every single time, re-deriving a plausible look from scratch. It rolls the dice, builds a palette, picks a lighting scheme, decides on a grain structure, and it does all of that fresh for every clip, with zero awareness of what the previous shot looked like.

Sit with that for a second, because it's the root of everything. Your shot one and your shot two are not two views of one world. They're two independent dreams. The model dreamed up a teal-and-amber overcast afternoon for shot one, and then for shot two it dreamed up a slightly warmer, slightly contrastier version, because nothing told it not to. There's no continuity unless you build the continuity in yourself.

On top of that, different models have different house looks. Every generator has an aesthetic personality baked in by its training. One leans cinematic and desaturated. Another leans crisp and punchy. Another has a certain way it handles skin and skies. So if you mix generators across a project, you're not just fighting the stateless problem, you're fighting two different built-in personalities. The way to know your model's house look is to bench it on your own shots, and the place to do that is the Artificial Analysis Video Arena. The Elo scores there come from blind comparisons, where people see two videos from the same prompt and pick the better one. As of mid twenty twenty-six, text-to-video is led by HappyHorse 1.0 and image-to-video by Dreamina Seedance 2.0, but please don't tattoo those rankings on your arm. They're time-sensitive. The point is that the leaderboard exists and that you should test on your shots, not that any one model wins forever.

And it gets subtler. Even the same model, re-rolling the same prompt, drifts. There's a great line from a working colorist on this: color and light are critical, and if those drift, even the same character feels different. If colors shift, you add explicit cues, like saying "consistent lighting" or "same palette" right in the prompt. And there's a diagnostic I want you to keep in your pocket all season. If you lay your shots out in a comparison grid and one tile jumps out at you, the thing that's wrong is almost always lighting or palette drift. That's your tell.

So here's the mindset, and it's the spine of the whole episode. Drift is the default. Consistency is not something you get for free, it's something you engineer. Every technique we cover from here is just a different way of feeding the same anchor into a system that would otherwise forget it.

Style-reference inputs, the real flags and parameters

Let's get concrete. The first family of tools is the style-reference input, where you literally hand the model a reference and say, make it look like this. And the cleanest worked example, the one I always teach from, is Midjourney's style-reference flag, which they call sref.

In Midjourney, you add the style-reference flag and then either an image web address or you drag and drop an image. And the official docs are careful about what it does. It draws upon the visual elements of that reference. The colors, the composition, the texture, the background, the overall atmosphere. Notice what's not on that list. The subject. It's pulling the look, not the thing. That distinction, look not subject, is the entire game.

Now here's where Midjourney does something genuinely clever, and it's worth understanding even if you never touch Midjourney, because it makes an abstract idea physical. Style Reference Codes. Instead of feeding an image, you feed a number. A numeric code from Midjourney's internal style library. You write the style-reference flag and then a number, and that number can be anything from zero to over four point two billion, and each one resolves to a different style. Think about what that means. A repeatable look has become a single number you can write down, save, and paste into any future prompt. People have curated libraries of these, reportedly several thousand hand-picked codes. This is the reusable style token made literal. One number is a portable, repeatable look. If you ever wanted a concrete image of what "lock the style" means, it's this: it's a number.

There's also a random option. You can ask for a random style code, and it'll assign one that resolves to a concrete code under the hood. The trick there is, once you find one you love, lock it. Write the number down. Because the whole value is repeatability, and a random you didn't capture is gone.

Then there's style weight, which they call sw, and this is your intensity dial. It controls how strongly the reference's style influences the output. The range runs from zero to a thousand, and the default is a hundred. Low values dilute the style, high values let it dominate. We'll come back to this dial in the pitfalls section, because cranking it is one of the classic mistakes, but for now just know it exists and that a hundred is home base.

One more Midjourney wrinkle, and then we'll generalize. There's a style version control, sv, because the V7 model changed how style references get interpreted. If you have older codes from a previous model, you can fall back to the old interpretation. And V7 itself is worth a note because it fixed real problems. It's described as much smarter at understanding the style of an image, much less likely to get undesired subject leakage, which is when the style image drags its own content into your shot, and it works even when your prompt is very different from the style. It also upgraded moodboards, which are Midjourney's saved reference boards, and you can mix multiple style codes together and combine images with codes. Hold the moodboard idea, we're coming back to it as a technique.

Now, you might be thinking, that's all Midjourney, I'm working in video. Fair. So let's generalize, because the job is the same everywhere even though the buttons differ.

Google's Veo has a feature called Ingredients to Video. You upload one to three reference images of a character, an object, or a style, and the model holds them while it animates. The way it's described, your visual assets stay identical while the perspective shifts, and consistency depends heavily on prompt precision. So Veo gives you up to three slots, and one of those slots can be your style anchor.

Runway works through a reference image plus style frames, and the Gen-4.5 generation is reportedly built around a Subject-Scene-Style triad. A headshot for the subject, a full-body for the scene, and a style guide for the look. And there's a line from the Runway world that I think captures the whole shift in this field: reference-image control replaced "longer prompts" as the way to get consistent characters. That's a big idea. We used to write paragraph-long prompts trying to pin a look down with words. Now you hand it a picture. The reference is more reliable than the prose.

Kling, which we met at the top, supports up to ten reference images for multi-reference work, and they recommend two to four angles to lock a subject. And critically for us, they separate the reference types. Style, character, structure, those three buckets again. So when you want to lock the look in Kling, you're feeding the Style Reference slot specifically.

So here's the cross-cutting pattern, and this is the part I really want to stick. Every major generator has some reference or style input slot. The names differ, sref, Ingredients, Subject-Scene-Style, Style Reference, but the job is identical: find the slot, and feed it a consistent anchor. Teach yourself to go looking for that slot in whatever tool you land in, because it's always there, and it's your single most direct lever on the look.

Look-locking techniques

Alright, references are the input. Now let's talk about the actual techniques you stack to hold a look across a sequence. I've got four for you, and they layer.

Technique one. The locked style prompt block, also called a reusable style token. The idea comes from the lookbook world, where people talk about a Style Bible. A Style Bible is a tiny specification you paste into every single prompt without modification. It's your style DNA, and you keep it unchanged. So you write something once, like, shot on 35mm film, muted teal-and-amber palette, soft overcast key light, shallow depth of field, fine grain. And then that block goes onto the end of every single prompt in the project, word for word, never edited. The only thing that changes prompt to prompt is the scene content, what's actually happening. The look description stays frozen. In Midjourney, the numeric style code is your token. On a text-only platform that doesn't take style references, that frozen prose block is your token. Same job, different form.

Technique two. Consistent seed, where it helps. Remember the seed, the random-number starting point. Here's the useful fact: generations with the same parameters, prompt, and seed produce precisely the same image. And if you keep the same seed but change the prompt, you maintain the original composition and lighting while reflecting your prompt changes. That sounds like a dream tool for consistency, and it can be, but there's a sharp caveat. A fixed seed locks composition too. It pins the framing. And across different shots in a scene, you usually want different framing. A wide, then a medium, then a close-up. So if you hard-lock one seed across all of them, you'll fight the model to even change the angle. The right way to use seed is as a tie-breaker for same-framing variations, not as your main cross-shot lock. When you've got two takes of the exact same shot and want them to match exactly, same seed. Across genuinely different shots, let the seed move and lean on your style block and your references instead.

Technique three, and this one's a callback that pays off big. Mint all your keyframes in one image model, with one style, and then animate them. We did a whole episode on minting keyframes, building your start frames in an image model before motion enters the picture. Here's why it's so powerful for style. There's a principle from the lookbook folks: providing your best early-generation image as a reference when generating subsequent images dramatically improves visual consistency. So you generate your hero frame, the one that nails the look, and then you use it as a reference for every other keyframe. If every starting frame shares the same palette, the same lighting, the same grain, then when you push those frames through the video stage, the video inherits the look. Image-to-video preserves the aesthetic of the input frame. This is the move that quietly solves most of the problem, because it collapses the whole consistency challenge down into the image stage, and the image stage is exactly where style references are most mature and most precise. You fight the battle on the ground where you have the best weapons.

Technique four. The style bible as an actual board, a lookbook or moodboard. This is the reference-board version of technique one. Instead of, or alongside, a prose block, you build a board of images: your palette, your lighting, your lens character, your grain, and you reuse it on every shot. There's a clean description of how these tools work: you upload ten to twenty example images that represent your ideal aesthetic, and the system extracts the common elements, the color grading, the composition style, the lighting approach, the overall mood. Midjourney's moodboards are the native version of this, the thing we flagged earlier. The board becomes a single, rich anchor that carries more nuance than words can, and you feed it everywhere.

So those four stack. A frozen style block in the prompt, a fixed seed for same-shot variations, all your keyframes minted in one image model with one style, and a moodboard or style reference riding along on every generation. Do all four and you've engineered a lot of consistency in before a single pixel moves.

Cross-generator matching, where the grade becomes the equalizer

Now I have to be straight with you about a limit. Sometimes you can't fully match at generation time. Especially when you're mixing generators with different house looks. The reality is that some models are just more consistent than others. The general read in the field is that Veo and Runway usually score highest on consistency, while Kling and the open-source stacks can vary more. So if your project spans tools, generation-time techniques get you close, but close isn't matched.

And this is the pivot of the whole episode, so let me say it plainly. Generation-time techniques, everything we've covered so far, get you close. The downstream grade closes the gap. Whatever palette, contrast, and white-balance differences survive generation, you neutralize them in one color-grade pass that pushes every clip toward a single target look. We have a dedicated color and grade episode coming, and I'm not going to step on it. But you can't talk about style consistency honestly without naming the grade, because the grade is where mismatched shots finally become one world. So let's cover just enough of it to finish the job.

LUTs and the DaVinci Resolve grade

Let me gloss a few terms for anyone who's newer, because I'm about to use them a lot.

A LUT, which stands for look-up table, is a reusable color recipe. Concretely it's a file, a dot-cube file, that maps input colors to output colors. The magic of it for us is that the same LUT pushes different clips toward the same look. One recipe, applied everywhere. A grade is just the act of adjusting color, exposure, and contrast toward a target look. White balance is the color-temperature neutral point, the question of whether your whites are actually white or whether they've drifted warm or cool. And DaVinci Resolve is a free, professional editor and colorist. The free version does almost everything; the paid Studio version adds the Neural Engine for the AI-assisted tools. It's the de facto default finisher, so that's what we'll talk in.

To apply a LUT in Resolve, you first make it available. You go into Project Settings, into Color Management, and there's an Open LUT Folder button. You drop your dot-cube files into that folder, hit Update Lists, and now Resolve knows about them. Then on the Color page, you select a clip, right-click your node, choose LUT, and pick one. Or you use the LUT browser, where you can hover to preview the look and drag to apply it. And if it's too strong, you pull it back. There's a Key tab with a Key Output control that lets you reduce the strength of the node, so the LUT becomes a nudge instead of a sledgehammer.

Now, the real job isn't slapping one LUT on and walking away. It's unifying mismatched shots, and there's a proper order of operations. First, normalize each source. You apply an input transform, a color-space conversion, to bring every clip into a common color space, so you're not comparing apples to oranges. Then you apply your foundation creative LUT, the one that defines your target look, across everything. Then you add low-opacity, fine-tune corrections per clip to clean up what's left. And a practical workflow tip: group your clips by scene, balance the whole group together first, and then do per-shot tweaks. That way the scene reads as a unit before you fuss over individual frames.

Resolve also has an AI-assisted feature that's tailor-made for our problem, called Shot Match. You pick a reference clip, your hero shot, the one whose look you want everything else to become. Then you right-click the clip you want to match and choose Shot Match, and Resolve analyzes both and shifts the target to align with the reference. The honest assessment from colorists is that the AI gets you eighty to ninety percent of the way there, and then you tweak the rest by hand. And the good news is Shot Match is in both the free version and Studio, so you don't need to pay to use it.

How do you know when it's actually matched, not just close to your eye? You read the scopes. Resolve has a waveform and a vectorscope, and the goal is that the scopes for two shots in the same scene line up. The waveform tells you about brightness distribution, the vectorscope about color. When those align between shot one and shot two, the shots will sit together no matter what your tired eyes think at midnight.

For white balance and exposure specifically, you work with the primary color wheels. There's Lift, which controls your shadows, Gamma, your midtones, and Gain, your highlights. And there's Offset, which shifts the whole image at once. The guidance for white balance is that the best tools are Offset and the HDR Global wheels, because they affect the full tonal range rather than just one slice of it. So picture the real situation: one of your clips came out of a generator running too cool, too blue, compared to the rest. You grab Offset, warm it back to neutral, and now it matches the others. That's the move. A clip that's wrong-temperature from one model gets neutralized on Offset and then matched into the group. The grade is where two generators with two different personalities finally agree to be in the same movie.

Style transfer and IPAdapter, the power-user escape hatch

I want to mention one more path, and I'm going to keep it light on purpose, because most of you will never need it and that's fine.

There's a tool called IPAdapter. The name stands for image-prompt adapter. It's a way to condition an image generation on a reference image, and the best one-line description I've heard is to think of it as a one-image LoRA. It can transfer either the subject or the style of that reference. It lives in ComfyUI, which is a node-graph interface, and node graphs are really an Act Three topic, so I'm just going to name it as the power-user path and move on.

The reason it's relevant here is a specific mode. You can set the adapter's weight type to "style transfer," and what that does is apply the aesthetic qualities of a reference image to your output while keeping the structural integrity of your input image. Read that again, because it's exactly our dream. It isolates the look from the content. The structure of your shot stays put, and only the style gets transferred in. The weight defaults to one point zero, and when it over-bakes, when the style is steamrolling everything, you lower it, often to around zero point eight. And it's frequently paired with another tool called ControlNet to lock the structure while the adapter supplies the style.

But here's the honest framing. Most creators will never open ComfyUI, and they shouldn't have to. This is the escape hatch for when the hosted style references in your normal tools just aren't precise enough and you need surgical control. There are also no-code "restyle" tools out there that do a simpler version of the same thing in a friendly interface. Think of IPAdapter as the thing that exists when you've outgrown the easy buttons, not as a starting point.

The copyable end-to-end workflow

Let me put the whole thing together into a sequence you can actually run, start to finish.

Step one, build a style anchor. That's one reference image that nails your palette, your lighting, your grain, and your lens character. Or it's a Midjourney style code, or a moodboard. And alongside it, a frozen style prompt block: your stock, your palette, your key light, your depth of field, your grain, written once.

Step two, lock it. Append that style block to every prompt, unchanged. Attach the same style reference to every generation, at the default style weight of around a hundred. And optionally, fix a seed for same-framing variations only.

Step three, mint all your keyframes in one image model with that one style. This is the keyframe-minting callback. Every starting frame shares the look before any motion exists.

Step four, generate your shots by animating those keyframes, image-to-video, feeding your model's style and reference inputs, whether that's Veo's one-to-three Ingredients, Runway's Subject-Scene-Style, or Kling's Style Reference slot. And do not re-roll endlessly chasing perfection. That's the cost-per-finished-clip discipline. Accept "close."

Step five, unify in a grade pass in Resolve. Normalize your color space, Shot Match to a hero clip, neutralize white balance on Offset, drop one creative LUT at reduced strength across all the clips, group by scene, and match the scopes. The grade is what makes mismatched generators sit in one world.

Pitfalls, and how to recover

Let me close with the specific traps, because recognizing them in the moment is half the battle.

First, second-shot look drift. The anchor pitfall. Shot two re-derives a new palette and lighting and grain because generation is stateless. Recovery: reuse your locked style block and the same style reference on every shot, diagnose side by side in a grid, remember that if one tile stands out it's lighting or palette, and fall back to a unifying grade.

Second, mismatched white balance, exposure, or contrast between generators. Each model bakes in a different neutral point. Recovery: the Offset and HDR wheels for white balance, an exposure adjustment per clip, Shot Match, and matching the scopes.

Third, over-strong style weight collapsing your detail. If you crank Midjourney's style weight toward a thousand, or push IPAdapter's weight too high, you flatten the image, over-stylize it, and wipe out subject detail. Recovery: dial the style weight back toward the default of a hundred, or lower, and bring IPAdapter back toward zero point eight.

Fourth, the style reference fighting your subject. That's subject leakage, where the style image drags its own content into your shot. Recovery: prefer versions with better style-subject separation, like Midjourney's V7, which is much less likely to leak; lower the style weight; use a style code instead of a content-heavy reference image; and in ComfyUI, use the style-transfer weight type that isolates look from content.

Fifth, the fixed-seed trap. Locking one seed across shots that should differ in framing forces the composition to repeat. Recovery: use seed only for same-shot variations, and let it move otherwise.

And sixth, credit burn. Re-rolling for a look you could have graded in just torches your budget. That's the cost-per-finished-clip lesson again. Bias toward fixing it in the grade once your generations are close enough.

So that's look-locking. Drift is the default, consistency is engineered, you build one anchor and feed it everywhere, you mint your keyframes in one style, and whatever survives generation, you unify in a single grade pass. Lock the look, and shot two stops looking like a different movie.