DEV Community: Marita P

Topview T1 vs Seedance 2.5: the 62% Discount Is a Ceiling, Not a Floor

Marita P — Sat, 24 Oct 2026 08:36:17 +0000

Topview shipped its first in-house video model on 21 October 2026, with a headline aimed directly at the model it has been reselling: "Built to rival Seedance 2.5 1080P quality at 62% lower cost."

That is a big number, and it is roughly right on the vendor's own arithmetic — T1 is listed at 38% of Seedance's official price. But if you are the person wiring a video model into a product, the number that matters is not 62%. It is the number you get when you plug your shot mix into it. For most pipelines that number is meaningfully smaller, and for one common workload it is negative.

Here is what I could verify, and the gotchas that only show up after you have committed credits.

TL;DR

T1 is priced at roughly $0.22/s at 1080p against roughly $0.585/s for Seedance 2.5, per third-party records. Topview bills in credits, so recompute from your own invoice before you plan anything.
An independent 10-challenge head-to-head puts T1 ahead on lip-sync, character consistency and cinematic color, behind on complex physics, fight choreography, fast action, on-screen text and prompt adherence. Dance and choreography still go to Seedance 2.5.
The 62% is a ceiling. A 65/35 split across shot types lands closer to 41%.
The "30 days unlimited" tier is 720p, standard queue, web-only, and explicitly excluded from API/MCP. If you ship on the API, it does not touch your cost of goods.

What actually shipped

Topview is a Singapore-based company behind an agent-style video workspace — Canvas, Drama Studio, a 3D shot composer, character swap — that routes requests across several third-party models. T1 is its first proprietary model. No architecture details have been published.

The detail that reframes the announcement: Topview already resells Seedance 2.5. T1 is not just another model in the picker; it is a vendor shipping a cheaper substitute for something it currently pays another company for. The 62% is a margin structure being rewritten, which is why it is worth reading carefully rather than adopting on day one. The launch post itself pulled 280K views and ranked 1,362 of 2,071 AI launches in the directory that tracks these — enough to be argued about, not enough to call it a default.

	Reported 1080p rate	vs Seedance 2.5
Topview T1	~$0.22 / second	−62%
Seedance 2.5	~$0.585 / second	—

Two caveats on that table, both material. The per-second figure comes from third-party review records, one of which flags its own pricing as un-re-verified since 23 October — Topview does not publish a clean $/second. And because billing runs through credits that are discounted differently per plan and resolution, the same clip can cost very different amounts depending on whether you are on Plus, Business or Ultra annual. Treat every $/second number, including mine, as an estimate to be replaced by your invoice.

For reference, the plans as listed: Plus $18/month, Business $44/month, Ultra $50/month, Team $56 per seat, all on annual billing. No free tier is documented for T1.

Where it wins and where it loses

One independent comparison ran T1 and Seedance 2.5 across ten challenges — lip-sync, dialogue, physics, fight scenes, dancing, prompt adherence among them — self-funded despite a past sponsorship relationship with the company. The result is not a wash, and it is not a T1 victory lap:

Capability	Better model
Lip-sync, including non-English	T1
Character consistency across a scene	T1
Cinematic color, camera movement	T1 (crisper, more saturated)
Complex physics (e.g. glass shattering)	Seedance 2.5
Fight choreography	Seedance 2.5
Fast action (T1 blurs)	Seedance 2.5
On-screen text / signage	Seedance 2.5 (T1 renders it illegible)
Prompt adherence	Seedance 2.5
Dance and choreography	Seedance 2.5

The pattern is not noise. T1 is strongest when the camera is calm and a face is doing something human; it is weakest when a body has to do something physically unlikely and land it. That split is the whole decision. If your workload is talking-head ads, product b-roll, dialogue scenes, avatar explainers — the discount is real and you keep almost all the quality. If your workload is dance clips, trend remakes, fight beats, or anything where a contact point has to be believable, the cheaper model is a downgrade with a smaller invoice, and you will spend the difference on retries.

Three things that bite after you commit

1. Unlimited is 720p, and the headline is 1080p. The pricing page line item reads Topview T1, 720P, 30 Days Unlimited on Ultra annual. Nothing wrong with that — but if you benchmarked the 1080p comparison and then budgeted on the unlimited tier, you are planning two different products.

2. Unlimited does not reach your pipeline. Topview's terms state that unlimited and free generations on plans are available only on the website and are not accessible via API, MCP, CLI or other automation. Unlimited also means credit-free, not priority — it runs in the standard queue, and wait times vary with demand and recent usage. Fine for a research window. Not something to put an SLA on.

3. The credit wallets are not interchangeable. Plus and Business plan credits can pay for API calls. Ultra and Team credits cannot. Monthly credits don't roll over. Top-up packs live longer. On a hobby project this is trivia; in production it is the difference between a plan that funds your pipeline and one that only funds your browser tab.

Net effect: the unlimited offer is an excellent trial, and it is not a cost-of-goods reduction. The discounted surface and the surface you actually pay for are different line items.

Do the math for your own mix

The headline assumes you move everything to T1. You won't, because some of your shots need the other model. So compute the blend.

#!/usr/bin/env python3
"""Blended video-generation cost for a mixed shot list.

RATE: your own effective $/second from your invoice, not a blog post.
MIX:  (shot_type, share_of_usable_seconds, model). Shares must sum to 1.0.
"""

RATE = {"t1": 0.22, "seedance": 0.585}          # $/s at 1080p, reported 2026-10-24

MIX = [
    ("dialogue / lip-sync",  0.35, "t1"),        # T1 wins lip-sync
    ("b-roll / product",     0.30, "t1"),        # calm camera, low physics risk
    ("dance / choreography", 0.20, "seedance"),  # T1 loses here
    ("fast action",          0.15, "seedance"),  # T1 blurs
]

TAKES = 4                 # generations per usable shot — your reroll rate
USABLE_SECONDS = 600      # finished seconds you actually keep per month

generated = USABLE_SECONDS * TAKES
print(f"generated seconds/month: {generated}")

for model in ("t1", "seedance"):
    print(f"all-{model:<9} ${generated * RATE[model]:>7,.0f}")

blended = sum(generated * share * RATE[model] for _, share, model in MIX)
solo = generated * RATE["seedance"]
print(f"blended mix  ${blended:>7,.0f}")
print(f"saving vs seedance-only: {1 - blended / solo:.0%}")

Output on that mix:

generated seconds/month: 2400
all-t1        $    528
all-seedance  $  1,404
blended mix  $    835
saving vs seedance-only: 41%

41%, not 62%. That gap is not a trick — it is what routing looks like. And note which way the error runs: 62% is the best case you can only reach by sending every shot to the cheaper model, including the ones it is bad at. The headline number is a ceiling on your saving, never a floor.

Change TAKES to 12 and the absolute numbers triple, but the percentage barely moves — reroll rate scales both sides equally. What actually moves the percentage is the mix, which is why the next table matters more than the pricing page.

A routing table you can steal today

Shot type	Route to	Why
Lip-sync dialogue, talking head	T1	Its clearest win, including non-English
Product b-roll, slow push-ins	T1	Calm camera, no physics to fail
Cinematic establishing shots	T1	Color and camera are its strength
Dance, choreography, trend remakes	Seedance 2.5	Explicitly the weaker model here
Fights, falls, collisions	Seedance 2.5	Fails on contact points and physics
Anything with readable on-screen text	Seedance 2.5, or composite the text in post	T1 renders signage illegible

The last row is worth internalising: if your video needs legible words baked in, that is a compositing problem, not a model problem. Overlay it after generation and you stop paying for a capability neither model reliably has.

A one-hour bench before you switch anything

Five prompts is enough to find the edge, and you should run them on your own footage rather than anyone's highlight reel:

One calm dialogue shot, face in frame, one line of speech.
One dance or choreography shot with a full-body subject.
One fast action shot with a hard stop or impact.
One product rotation with a reflective surface.
One shot containing a legible sign or label.

For each, look at the same five things: hands, contact points, text legibility, identity drift across the full duration, and whether the action completes or decays in the last second. Then compare blended cost against the routing table above. You will get roughly the same verdict as the independent test, and you will have your own evidence instead of mine.

What I actually took away

Per-second generation price is converging on zero — T1 at 38% of the official rate, Wan 3.0 marketed as near-Seedance-2.5 at 30% of the price, MiniMax H3 near-Seedance-2.0 at 30% of the cost. Within a year the per-second number will be the least interesting figure in any model comparison.

What stays expensive is everything around it: the rerolls of shots you should not have generated, the latency tax of a shared queue you cannot prioritise, and the work of deciding which shots your product actually needs. A 62% discount on the cheapest line item is welcome. It is not the line item that decides whether the product ships.

So: benchmark your own five prompts, route by shot type, and recompute the blend from your invoice. That gets you most of the discount and none of the regressions.

Sources, so you can check the numbers rather than take them: the launch claim and reach figures come from the launch post as tracked by Doomers; plan pricing and the unlimited-model terms from Topview's own pricing page; the per-second comparison from The AI Dude's review, which flags its pricing as un-re-verified since 23 October; the ten-challenge head-to-head from Art of Smart's writeup of a self-funded comparison; the credit and API wallet rules from TechPilot's reading of Topview's pricing on 18 October. The 62% is Topview's claim. The quality comparison is contested and rests on a small number of independent tests rather than a public benchmark — including mine, which is arithmetic, not measurement.

Two Photos In, One Scream-and-Swap Out: What Actually Matters When Picking an AI Dance-Video Tool

Marita P — Fri, 23 Oct 2026 04:40:57 +0000

The dumbest-sounding constraint is often the whole product

A few weeks ago I watched a friend lose an entire evening to a trend he could not join. The video everyone was posting was a specific thing: one face screams into the camera, another person dances behind them, the two swap places, and then they both sprint toward the lens together. The choreography is fixed. The music is fixed. The only real input is who the two people are.

He had two photos and no way in. The tools he tried wanted a prompt. They wanted a script. They wanted him to describe the dance, the lighting, the camera move. He didn't know how to describe a dance. He just wanted to put his face — and his cat's face — into a video everyone would recognize instantly.

That constraint — two photos in, no prompt, one very specific output — is a genuinely interesting engineering boundary. It's also the thing nobody writes about, because "pick two photos, get a 21-second vertical 720p video of a scream-and-swap dance" sounds too silly to take seriously. But the constraint is exactly why it works.

Why "no prompt" is a feature, not a shortcut

A general-purpose video model is a blank canvas. That's its strength and its tax. The moment you ask a general model for a dance video, you inherit a thousand hidden decisions: what choreography, what camera angle, what song, what length, what happens when two identities start to drift mid-frame. Most people solve zero of these and then blame the tool.

A template-based generator inverts the problem. It hardcodes the choreography, the timing, the music, and the camera — and leaves you exactly one free variable: the two faces. When the output space is small, the model can be tuned for that specific output. Face consistency across a 21-second swap, the moment the two people change places, the final sprint — those stop being "creative choices" and become a pipeline you can actually optimize.

This is the same logic behind why the best developer tools feel boring on the surface. A constrained interface is a product decision, not a limitation. It's the difference between a text field and a well-typed function signature.

The two axes that actually matter for selection

When I compare the "two photos → dance video" tools that have popped up around this trend, the ones that hold up tend to win on two axes and lose on a third.

Axis one: identity preservation under a swap. The hard part isn't rendering two people. It's rendering two people who stay themselves while they swap places. When the model swaps the roles, the cheap implementations drift — hairline changes, eye color shifts, the second face starts to look like a blend of both. This is why the underlying model matters. Tools built on a stronger base model (the current crop runs on things like Seedance 2.5) do measurably better at keeping each face locked while the bodies move past each other. Ask any of these tools what their base model is before you pay.

Axis two: pets, and "unexpected combinations." Here's a thing I did not expect to be a real feature: cats. And dogs. And cat-plus-dog. A dedicated cat dance is not a joke — it's a signal that the tool treats its subjects as more than human faces. A human face has a lot of high-level semantic structure the model can latch onto. A cat is mostly low-level texture. If a tool handles a cat without drifting into a weird chimera, it usually means the identity pipeline is genuinely robust, not just tuned for one face shape.

Axis three, where everyone loses: consent. This is the one no tool can reliably solve, and you should be suspicious of any that claims it can. None of these generators can verify that you have permission to use the second person's face. That check lives entirely with the person holding the photos. The honest tools say so. Before you put someone else's face — a friend, an ex, a colleague, a stranger — into a video, get their consent out loud. "It's just a joke" is not a rule. A technical pipeline will never be able to automate that for you, so don't let a product's marketing imply otherwise.

The pricing tells you the real model

One thing that reliably separates the serious tools from the trend-chasing copies is how they handle failure.

A one-off purchase with a credit system — say, ten credits for one standard video — plus a refund when a generation fails, is a cost model, and it's usually a sign the operator actually knows what their GPU bill looks like. Every failed render is real money for them, so a tool that refunds failed generations is admitting that failure happens, and paying for it rather than making you pay for it. A tool that charges you for garbage output is either unaware of its own failure rate or indifferent to it.

The same logic applies to the "no watermark" question. A watermark isn't just branding — it's often a licensing and cost signal. A tool that lets you download a clean file and post it straight to TikTok or Reels is treating the output as yours, which is the whole point of a one-time purchase. A tool that locks the clean export behind a subscription is selling you the file, not the video.

What I'd check before paying

If you're evaluating one of these tools, here's the short list:

What's the base model? "Seedance 2.5" or a comparable current model is a good sign; a vague "AI-powered" is not.
Does it handle pets cleanly? It's a surprisingly good proxy for identity robustness.
Does it refund failed generations? This tells you the operator's real confidence, not their marketing copy.
Is there a watermark, and can you download clean? One-time purchase tools should hand you a clean, shareable file.
Does it ask you — in plain language — to get consent first? If a tool pretends the ethics problem doesn't exist, treat everything else it says with more skepticism.

The trend itself will fade; it always does. But the underlying pattern — shrink the output space to one recognizable thing, and optimize a pipeline until that one thing is bulletproof — is exactly how a lot of genuinely useful AI tooling gets built. The silly 21-second dance is a decent case study in a very serious design principle.

The tool I've been describing here is Smalltown Boy AI (https://smalltownboyai.app/), a two-photos-to-vertical-video generator for the scream-and-swap "Smalltown Boy" dance trend. I'm not affiliated with it — I just find its constraints more interesting than most of the blank-canvas generators people throw at this kind of video.

Feeding Two Faces to a Diffusion Model: What Makes a Two-Person (or Two-Pet) Video Come Out Clean

Marita P — Mon, 19 Oct 2026 09:15:29 +0000

The Input Problem Nobody Talks About

Most of the conversation around AI video generation focuses on the output — how realistic the motion looks, whether fingers melt, if the lips sync. Almost nobody talks about the input. But when a video has to reconstruct two distinct identities at once, the quality of your two source photos matters more than any prompt you could write.

This is the engineering reality behind the "scream-and-swap" dance videos currently flooding short-form feeds: one face screams into the camera in close-up while a second subject dances behind, then they swap. It's a single 21-second, portrait, 720p clip, generated from exactly two photos — or one photo of two people. No prompt. No timeline editing.

For developers who want to understand why those videos look clean or broken, the answer lives almost entirely in how the two identities are encoded and how they survive a swap.

Two Identities Are Harder Than Two Times One

A single-subject generator only has to hold one face embedding consistent across frames. Add a second subject and you immediately hit the problems that make two-person generation feel like a different product entirely:

Identity drift. Two faces in close proximity are the classic failure mode. The model bleeds features between them — one person's jawline creeps onto the other, eye colors swap mid-frame.
Occlusion. The front subject occludes the rear one. The model has to remember the hidden subject through the occlusion window, not just paint what's visible.
Order matters. The "scream then swap" structure means each identity has to occupy both roles across the clip: close-up foreground and background dancer. A model that can hold face A in the foreground may still smear it when A moves to the back.

The practical takeaway: two-person output is not "single-person, twice." It's roughly a 2–3× harder consistency problem, and most of the work happens before a single frame is rendered.

What "Good" Input Photos Actually Look Like

Because there's no prompt to lean on, the photos are the prompt. Here's what separates a clean swap from a smear, based on what the underlying pipelines (Seedance-class video diffusion models) tolerate well:

Match the lighting. Two photos shot under wildly different light — one warm indoor, one cool daylight — force the model to reconcile two color temperatures. The identity embedding fights the lighting reconciliation, and you get a face that looks pasted on.
Match the angle, roughly. A full-frontal face and a three-quarter profile give the model two conflicting notions of the same skull. Faces facing the camera, with both eyes visible, reconstruct far more reliably.
Clear separation in a two-person photo. If you feed a single group shot, the two faces should be distinct and unoccluded. If they're cheek-to-cheek, the model can't cleanly attribute features to each identity.
Sharp and high-res. Crops that are blurry or downscaled starve the encoder of the high-frequency detail (eye shape, lip line) that identity preservation depends on.

The reason these rules matter more than "write a better prompt" is architectural: in a no-prompt tool, there is no textual handle to disambiguate the two people. Everything rides on the visual embedding.

Why Pets Work, and Why That's a Clue

One of the more surprising things about this format is how well it handles cats, dogs, and even a cat-plus-dog combo — there's a dedicated cat-dance variant, and a cat with a dog swapping roles. That's not a gimmick; it's a signal about the model.

Diffusion models reconstruct identities from low-level visual features (fur texture, ear geometry, muzzle shape) more than from the high-level semantic features we care about as humans. A cat's face has strong, distinctive, low-level texture, so identity holds well. It's the same reason a person's face holds best when the eyes and lip line are crisp rather than when the pose is flattering.

If you're building or tuning a two-subject pipeline, that's a useful diagnostic: when identity breaks, ask whether you lost low-level texture (motion blur, occlusion, resizing) before you blame the model's "understanding."

The Consent Question, Revisited as a Constraint

A tool that turns any two photos into a dancing, screaming clip also turns "any two photos" into a real risk. It is trivially easy to use a face that isn't yours. From a builder's perspective, consent isn't just ethics — it's a design constraint. Watermark-free, downloadable output (meant for TikTok and Reels) amplifies whatever you generate.

So the rule I hold, and would bake into any similar product: get explicit consent from anyone whose face you generate before you publish. It costs nothing at generation time and saves everything later. Treat it as a first-class input validation, not an afterthought.

A Minimal Check Before You Generate

If you're evaluating or building a two-subject video tool, here's a short pre-flight list that catches most of the bad output before you waste a render:

Are both faces front-facing and well-lit?
Do the two photos share a similar lighting temperature?
Is each face sharp, with eyes and lip line clearly resolved?
In a group photo, are the two faces clearly separated and unoccluded?
Have I confirmed consent from every face in the frame?

Most "broken" AI videos aren't a model failure. They're an input failure. Get the two photos right and the swap mostly takes care of itself.

Smalltown Boy AI: The Scream-and-Swap Dance Trend, Explained (and How to Make Your Own)

Marita P — Mon, 12 Oct 2026 06:45:08 +0000

What is the Smalltown Boy AI trend?

You've probably seen it already: two people taking turns screaming straight into the camera, then swapping places and dancing together like they've rehearsed for years. A grandma and her grandson. Two best friends. A man and a deeply unimpressed cat. That's the Smalltown Boy dance, and it's everywhere right now.

The name comes from "Smalltown Boy," a 1984 Bronski Beat synth-pop classic about a young man leaving his small town behind. The song never really disappeared, but it recently came roaring back in a very specific form: a short, funny format where one character leans dramatically into the lens while the other dances in the background — then they switch.

The twist is that almost nobody in these videos actually filmed anything. The faces are real. The dancing bodies were never there.

Why this works now

For years, "AI video" meant heavy tools, prompt engineering, and a lot of trial and error to keep a face recognizable across frames. Photo-to-video models have crossed a threshold in the last year or so where they can hold two specific identities while driving a full-body performance — the exact thing a two-character dance format needs. Tools like the Smalltown Boy AI generator (built on Seedance 2.5) turn that into a three-step flow: two portraits in, one 21-second vertical clip out, no prompt required.

The interesting part isn't the tech, though. It's what the tech deleted. Old viral dance challenges — the Harlem Shake, the Mannequin Challenge, every TikTok dance ever — all demanded three things from you:

Skill, or the willingness to fake it.
Courage — the willingness to put your face and body on the internet and be bad at something in public.
Setup — a camera, space, time, a second person, and enough takes to land one good shot.

For a huge number of people, courage was the wall. Not the dancing. The "what if I look stupid" part. The Smalltown Boy trend quietly removes that wall: you never go on camera, and the only skill required is picking two photos.

How to make your own in three steps

Pick your duo. Two separate portraits, or one clear photo with both characters. Front-facing, well-lit, faces visible, no sunglasses, no heavy filters. Similar face sizes make the pair easier to read.
Choose the order. Photo A takes the first screaming close-up while Photo B dances behind — then they switch. Put the more dramatic person (or the cat) in whichever slot is funnier. This single choice drives the whole joke.
Generate and review. You get a 21-second, 720p vertical clip. Watch the full thing and check both faces before sharing, then download (no display watermark) and post to TikTok, Reels, or Shorts.

That's the entire barrier to entry: do you have two photos you're allowed to use?

The pet version is its own genre

The cat dance deserves its own mention. Two cats — or a cat and a dog — doing the same absurd scream-and-swap is somehow funnier than the human version. The practical advice: pick photos with distinct faces and coat patterns, keep bodies visible, and check the pet's anatomy and markings carefully in the result. AI still gets animal bodies wrong more often than human faces.

One thing that has nothing to do with the tool

The technology got here before the manners did. The entire point of this format is putting real, specific faces onto bodies doing things those people never did — and that's both the magic and the risk. A face is consent you can give and take away.

So before you generate a video of someone else's face — a friend, a partner, a kid, a coworker — ask. Not after, not "they'll love it." Ask. The surprise is never worth more than the consent underneath it.

The takeaway

The more the machine handles the dancing, the more the only thing that matters is whose faces are in the frame. The skill was never the point, and neither was the courage — those were just tolls you paid to reach the actual joke: look, it's us, and it's ridiculous.

The moves are now free. The reason to want two specific faces in the frame is still yours, and it turns out that was the only part anyone was ever watching for.

Keeping Two Faces From Swapping Mid-Verse: Identity Preservation in AI Music Videos

Marita P — Sun, 11 Oct 2026 01:25:29 +0000

The problem nobody warns you about

You train a model to turn two photos into a short music video. The first three seconds look great. Then, around second five, the guy on the left suddenly has the other guy's jaw. By second eight, their faces have traded places entirely.

If you have built any kind of face-to-video pipeline, you know this failure mode well. It has a name: identity drift. And for a two-person performance video — a rap duet, a duet cover, two friends singing at each other — it is the single hardest thing to get right.

This post is about why identity drift happens, and the engineering decisions you can make to hold two faces steady across a full clip. It is not a product pitch. It is a walk through the failure modes and the levers.

Why one face is already hard

Single-subject face video is a solved-ish problem because the pipeline can lean on strong priors. You detect a face, you extract an identity embedding, and you condition every generated frame on that embedding so the person stays the same. Tools like insightface give you a face detector and an embedding extractor that is fast and stable enough to run per-frame, and models like inswapper do the face swap itself.

The identity embedding is the load-bearing piece. It is a vector — a few hundred floats — that tries to encode "who this person is" while discarding "what expression they are making, what lighting they are in, what angle we are seeing." In practice those two things are not cleanly separable. That is where the drift comes from.

Why two people make it dramatically harder

A duet is not two single-face problems glued together. It is one problem with a new axis of failure: attribution.

Consider what the model has to decide at every frame:

Which face is which. When both people are in frame, the pipeline must map "left person" and "right person" to the correct embeddings, every frame, even as heads turn and the camera moves.
Whose motion belongs to whom. A rap duet has the two performers trading lines, leaning toward the microphone, overlapping in the frame. The model has to keep each person's gestures attached to their own identity, not bleed movement from one onto the other.
Sustaining it over time. Thirty seconds is hundreds of frames. A tiny per-frame error compounds. By the end, two people can have converged toward a single averaged face — the classic "they merged" artifact.

If you have built a single-person pipeline, point 2 is the one that will surprise you. With one face, motion is basically free — any gesture is automatically "the person's." With two faces, motion attribution becomes a hard constraint, not a freebie.

The levers that actually matter

Through building and debugging this, a few decisions made the biggest difference. These are listed roughly in order of impact, not in the order you would build them.

1. Identity conditioning has to be per-person and explicit

Do not pass a single "image" to the generator and hope it figures out there are two people. Pass two separate, clearly tagged identity embeddings, and keep them spatially anchored (left vs. right) for as long as the frame composition allows. When the camera changes composition, re-anchor rather than letting the model guess.

2. Use a pose or layout prior, not just pixels

For a performance video, the two people have a scripted relationship to each other — one is "talking," one is "reacting." Encoding that structure as a pose or layout signal (keypoints, or a depth/segmentation layout) stops the model from inventing plausible-but-wrong interactions. A face-detection + keypoint pass per frame is cheap and removes a whole class of swap artifacts.

3. Constrain the visual style, because style drift feeds identity drift

Here is a non-obvious one. If the scene style is allowed to drift — lighting changes, camera angle wanders, background shifts — the face model gets a worse signal, and identity drift gets worse with it. Locking the style down hard (same color palette, same lighting, same framing for the whole clip) is not just an aesthetic choice. It is an identity-preservation technique. This is one reason a fixed, stylized "stage" look is so much easier to keep consistent than a free-form cinematic scene.

4. Accept that you are trading cost against consistency

Full identity consistency over long clips is expensive. The cheaper the model, the sooner faces start to drift. If you want a "set it and forget it" experience — drop two photos in, get a clip out — you are implicitly making a trade: you spend more compute on identity anchoring so the user does not have to fiddle with prompts or a timeline. Knowing where that trade sits is the difference between a demo that impresses for three seconds and a product that survives a full video.

What "good enough" looks like

You will know your pipeline has crossed the line when you can watch a full clip and never once think about the faces. That is the real acceptance test. The faces just are — two distinct people, clearly themselves from the first frame to the last, even when they trade lines, lean into frame, or sing together.

Reaching that point is less about any single model and more about the scaffolding around it: explicit per-person embeddings, a layout prior, a locked style, and a deliberate cost/consistency tradeoff.

One thing that has nothing to do with the code

A quick reminder before you go build something fun with this: if you are putting a real person's face into a generated video — a friend, a partner, a celebrity, anyone — get their consent first. Face-swap and identity-preservation tech is powerful, and the same pipeline that keeps two faces stable for a music video can just as easily put someone in a video they never agreed to. The technical skill is the easy part. The responsibility is on you.

Have you hit the "they merged into one person" bug? How did you fix it — better embeddings, a pose prior, or something else? I would like to hear what worked in your pipeline.

Building a Face-Consistent Two-Person Video Generator: Architecture, Models, and a Minimal Prototype

Marita P — Wed, 07 Oct 2026 06:10:42 +0000

The "two photos in, one rap performance out" generators are everywhere right now. If you're a developer, the product is a curiosity — but the engineering underneath it is a genuinely interesting problem, and it maps onto a skill you'll reuse for a lot more than memes.

This post is a build guide, not an explainer. I'll walk through the architecture, the model choices at each stage, and a minimal prototype that gets you to "a face stays the same across a moving clip" without a PhD in diffusion.

The Hard Problem, Stated Plainly

Forget the orange stage. The core challenge in any personalized video generator is identity preservation: keep a specific face believable across dozens of frames while the body moves, the mouth animates, and the camera shifts.

A generic face can drift and nobody notices. Your user's face has to stay recognizably them for the whole clip, or the joke dies and the product looks broken. This is the axis everything else hangs on.

The Pipeline, as Something You'd Actually Build

A working prototype is five stages. Each one is a replaceable component, which matters because you'll swap models at every layer.

upload ──► face detect/align ──► identity embed ──► motion+scene ──► audio ──► composite/export

1. Face detection and alignment

You can't feed a raw selfie to a diffusion model. First you localize the face, crop it, and normalize it to a canonical orientation.

Detection: RetinaFace or SCRFD (both available via insightface) are the standard picks — fast on CPU, accurate enough.
Alignment: fit five facial landmarks (eyes, nose, mouth corners) and apply a similarity transform to warp the face to a fixed 112×112 or 256×256 template.

from insightface.app import FaceAnalysis

app = FaceAnalysis(name="buffalo_l", providers=["CPUExecutionProvider"])
app.prepare(ctx_id=0, det_size=(640, 640))

img = load_image("person_a.jpg")
faces = app.get(img)          # each face has .bbox, .kps, .normed_embedding

The normed_embedding on each detected face is the prize — it's the identity vector you'll use downstream.

2. Identity embedding

This is the step most tutorials skip. You need a compact vector that represents the person, independent of pose, lighting, and expression. Face recognition models trained on large datasets (ArcFace-family backbones) give you exactly that — a 512-dim embedding where "same person" = "high cosine similarity."

Keep the embedding for the source face (the user's photo). In generation, you'll pull the generated face back toward this vector.

3. Motion and scene

Here you have two real architectural choices, and they're not equivalent:

Approach	How it works	Trade-off
Face-swap over a template	Generate or reuse a fixed performance clip, then swap in the target face frame-by-frame	Fast, cheap, identity locked by construction; less control over scene
Identity-conditioned video diffusion	Drive a video model with the identity embedding (IP-Adapter-style injection or LoRA)	More flexible scenes; harder to keep identity stable, higher compute

For a two-person rap clip, the first approach is why these tools feel instant: the expensive part (a believable performance with choreography and camera) is solved once, at build time, and reused for every user. You're not generating a scene from scratch per request — you're compositing faces into a pre-rendered one. That's a cost and latency decision, not just a convenience.

If you want bespoke scenes, look at identity-injection via IP-Adapter + AnimateDiff, or a fine-tuned LoRA per recurring character. Budget 10–100× the compute.

4. Audio

Don't synthesize the copyrighted reference track. Generate an original beat plus lyrics and vocals — typically a music/lyrics LLM for the bars, then a TTS or singing-vocals model (Bark, or a commercial text-to-song API) for the performance. Keep audio as a separate pass and mux it at the end; coupling it to the video model only adds failure modes.

5. Composite and export

Stitch frames with ffmpeg, mux the audio, encode for social (vertical, H.264). Nothing exotic here, but get the frame rate and aspect ratio right before you scale.

A Minimal Face-Swap Prototype

If you want something working in a weekend, the face-swap route is the pragmatic choice. The modern standard is insightface's inswapper model:

import cv2, numpy as np
from insightface.app import FaceAnalysis
import onnxruntime as ort

# Load models once
swapper = insightface.model_zoo.get_model("inswapper_128.onnx",
                                          providers=["CPUExecutionProvider"])
source = app.get(load_image("person_a.jpg"))[0]      # identity to inject

video = cv2.VideoCapture("template_performance.mp4")
writer = setup_writer("out.mp4", fps=video.get(cv2.CAP_PROP_FPS))

while True:
    ok, frame = video.read()
    if not ok:
        break
    targets = app.get(frame)
    for t in targets:
        frame = swapper.get(frame, t, source, paste_back=True)
    writer.write(frame)

writer.release()

This gives you a template performance with a stable face in under a hundred lines. Two people? Run the swap for each of two source identities, or use a template that already has two performers in fixed left/right positions and assign each face to its slot.

Where the Real Complexity Lives

The prototype gets you 80% there. The last 20% is where products are won or lost:

Occlusion and motion blur. Hands, microphones, head turns — a raw swap breaks down. The good tools add a face-consistency loss or an identity-regularized diffusion pass on top of the swap.
Multi-face assignment. Keeping face A on the left and face B on the right across 12 seconds, without drift or swap, is a tracking problem as much as a generation problem.
Latency and cost. A reusable template keeps per-request cost near constant. Generating per user scales your GPU bill with your traffic — the difference between a hobby project and a dead one.

Build It or Use It?

If this is your product, build the pipeline — the identity-preservation problem is a genuine moat worth owning.

If you just need the output — say, a shareable two-person clip for a campaign or a quick test of the format — don't re-solve a solved problem. Something like AI Rap Duo already bundles the template, the identity preservation, and the original beat into a two-photo upload with no prompt. That's the right call when the goal is the video, not the architecture.

Either way, the interesting engineering question is the same one that makes any personalized AI product hard: keeping a real, specific face believable while everything around it moves. Nail that, and the rest is just plumbing.

How AI Rap Duo Video Generators Work Under the Hood (and How to Pick One)

Marita P — Mon, 05 Oct 2026 04:26:56 +0000

The "Hotel Lobby AI" trend is everywhere right now: two photos in, a twelve-second rap performance out, with two familiar faces sharing an orange stage and a hanging microphone. If you're a developer or a curious builder, the interesting question is not what these tools do — it's how they do it, and which one actually fits your stack.

This post breaks the pipeline down, then gives you a short framework for choosing between the main approaches.

The Pipeline, Step by Step

Most two-photo rap duo generators run roughly the same sequence under the hood:

Face detection and alignment. The tool finds the faces in your one or two uploads, crops them, and aligns them so the downstream model can work with a consistent input. If you upload two separate portraits, the left/right placement is usually fixed at this stage.
Identity mapping. This is the hard part. The model has to keep your person's identity stable across dozens of frames while the body moves, mouths rap, and the camera shifts. This is typically a face-swap or identity-embedding step layered on top of a motion prior — not a raw text-to-video call.
Motion and scene generation. The orange stage, the performer choreography, and the camera are baked in as a template, which is why these tools need no prompt. You're not describing a scene; you're selecting from a pre-built one.
Audio generation. Rather than reusing the copyrighted "HOTEL LOBBY" recording, many tools synthesize an original beat plus lyrics and vocals. The lyrics are often generated from an optional "topic" field you can fill or leave blank.
Render and export. Everything is composited into a short clip you can download and post.

The practical takeaway: the engineering moat is in identity preservation and audio, not in the scene. That's why the good tools feel instant — the expensive part was solved at build time, not at generation time.

Prompt or No Prompt? The Real Trade-off

The tools split into two camps, and the choice matters more than the orange stage.

Approach	Input	Control	Typical use
Two-photo rap duo generator (e.g., AI Rap Duo)	One or two portraits, optional topic	Low — scene is fixed	Fast, no-prompt clips for social
Prompt-driven video model	Text prompt + reference images	High — every frame is yours	Iterative, bespoke scenes
Editor template	Original clip + manual edits	Medium	Remixing the reference audio

If your goal is a shareable clip in minutes, the two-photo route wins because it removes the fiddly part without removing the one decision that actually matters: who is in the video. A tool like AI Rap Duo takes two portraits or a single duo photo and returns a built-in Hotel Lobby–style performance with an original AI-written verse and beat — no prompt assembly required.

If you need maximum control over lighting, camera, and choreography and are willing to iterate, a prompt-driven model is the fit — but budget for the extra time and the separate audio step.

Why Identity Preservation Is the Hard Part

The single hardest problem in this space is keeping a specific face believable across a moving, lip-syncing body. A generic face can wobble and nobody notices; your face has to stay recognizably you for the joke to land. That's why two-photo generators lean on face-identity embeddings and face-swap priors rather than a raw diffusion pass — and why the audio is usually generated separately from the visuals. It's also why the best tools feel instant: they pre-solved the expensive part at build time, so the per-generation cost stays low.

A Quick Selection Checklist

Want original audio, not the reference track? Look for generators that synthesize lyrics + vocals + beat rather than replaying a copyrighted recording.
Care about identity stability? Prefer tools built specifically for face-to-video, not general text-to-video, since the former optimize for keeping a face consistent across frames.
Need it fast? Two-photo generators are the shortest path from idea to shareable clip.

The trend is fun, but the interesting engineering problem is the same one that makes any AI video product hard: keeping a real, specific face believable while everything around it moves. The tools that nail that are the ones worth watching.