DEV Community: hua sun

Put yourself in a viral clip with one photo — no prompt

hua sun — Sun, 15 Nov 2026 14:33:36 +0000

I shipped Genjutsu AI — a small web tool for a narrow job: take a video people already share, swap the people for photos you pick, and keep the original take.

No prompt. No storyboard. You upload the clip, the app splits it into scenes and lists who’s in frame. You add one still photo per person you want to change. Everyone else, the background, and the props stay as filmed.

What stays the same

Shot order, timing, and camera
Cuts and pacing
Original audio

What changes

Only the people you assign a photo to. One photo = one identity across every shot they appear in. That can be you, a friend, a pet, a product, or a character.

How it works

Upload mp4, mov, or webm (up to 80MB), or pick a template (Hotel Lobby, Tiny Desk AI, Night Dance, Bulin 47, and others).
Scenes and faces are detected automatically.
Attach a photo for each face you want to replace.
Generate. Download is 720p with the source audio.

Under the hood it’s a Next.js app with a Python cast pipeline for scene/face work, Prisma + Postgres for accounts and credits, object storage for uploads, and a video model API for the swap. Happy to talk stack details in the comments if anyone’s curious.

Limits worth knowing

Rule	Detail
Scene length	A single scene cannot exceed 15 seconds (shorter clips work best).
Resolution	Output is 720p.
Credits	10 credits per 15 seconds; failed runs refund credits.
Sign-in	Google — generations stay on your account.

Credits don’t expire. First 15-second video on Starter is $6.90, then $9.99 (10 credits). Plus and Creator packs are on the pricing page.

Not the same as “Higgsfield Genjutsu”

Genjutsu AI is a separate product: you bring the video, and you attach one photo per person you want in the frame. Same filmed motion, different faces.

Try it

👉 ai-genjutsu.com

A clip under 15 seconds is enough for a first run. I’d love feedback on scene splits, face consistency, and whether the credit pricing feels fair — especially from folks who ship short-form or meme clips.

Disclosure: I built this. It’s a paid credit product, not open source.

ClipRedo lets you remake a trending clip with your own photos

hua sun — Wed, 04 Nov 2026 13:48:40 +0000

I shipped ClipRedo for people who want their own version of a short clip that is already going around.

You do not write a prompt, and the site does not post the file for you. You pick a template, upload the photos it asks for, and download a new video. The room, the camera, and the order of the moves stay with the template. The people come from the photos.

The site is in English. The line on the homepage is "Redo the trend. Make it yours."

What is live

Four templates:

Hotel Lobby. Two photos. 15 seconds, 4:3. Two people, an orange wall, and one hanging microphone. 10 credits.
Bulin 47. One photo. 15 seconds, vertical. One person in the middle of a crowd. 10 credits.
Bulin 47 Trio Dance. Three photos. 15 seconds, vertical. Three people dancing together. 10 credits.
Fancy Cafe. Two photos. 21 seconds, vertical. One person sits on a small round table. Another walks in and sits on the bench. 480p is 10 credits. 720p is 20 credits.

Photos are JPG, PNG, or WEBP, up to 10MB each. Sign-in is Google.

What the file does not include

The download has no soundtrack. If you post on TikTok, add the trend's sound inside TikTok. On Reels, add it inside Instagram. ClipRedo does not attach a song, and it does not publish the post.

Faces, clothes, and timing can still differ from the preview. The template aims to keep the place and which person does which move.

A run that fails before the video is ready returns the credits. A finished video keeps the charge.

There is no subscription. Credits are a one-time purchase, and they do not expire.

Price

Starter: $9.99 for 10 credits
Plus: $24.99 for 30 credits
Creator: $69.99 for 100 credits

Most templates cost 10 credits. Fancy Cafe at 720p costs 20, so the Starter pack is not enough for that option on its own. The 1 / 3 / 10 video counts on the pricing page assume 10 credits per video.

If you open clipredo.com, the useful thing to look at first is the preview on each template, before you spend anything.

When “No Speech Found” Actually Means “Wrong Language”

hua sun — Sat, 12 Sep 2026 07:41:08 +0000

A user uploads a video with clearly audible speech.
The transcription API returns nothing.
The obvious error message is:

No speech found.
But that message may be wrong. The audio is not silent—the transcription model may simply be listening for the wrong language.
We ran into this while building SubtitleGenerator, and it led to an interesting product decision: should we keep adding automatic detection, or just ask the user what language they are speaking?

How the problem happens

A speech-to-text request usually contains three important pieces of information:

The audio

The transcription model

The expected language A simplified request might look like this:


ts
const formData = new FormData();
formData.append("audio", audioBlob);
formData.append("language", "en");
await fetch("/api/transcribe", {
  method: "POST",
  body: formData,
});
This works when the speaker is using English.

But if the video contains Chinese, Spanish or Arabic speech, forcing en can produce:

An empty transcript
Very low-confidence words
English-looking nonsense
Text written in an unexpected alphabet
A misleading “no speech found” error
The audio exists. The model just cannot map it confidently to the expected language.

Why not always use automatic detection?
The obvious solution is automatic language detection.

In ideal conditions, that works well. The problem appears with real creator content:

Five-second clips
Music before the first spoken sentence
Strong accents
Noisy phone recordings
Multiple speakers
Mixed-language speech
Hindi and English code-switching
One or two words surrounded by silence
Language detection needs evidence. A short clip may not provide enough of it.

This creates a dangerous failure mode: the application looks fully automatic, but when detection fails, the user has no idea why.

The fallback we considered
We initially considered a pipeline like this:

Run normal transcription
        ↓
Result is empty or uncertain
        ↓
Send audio to another model for language detection
        ↓
Run transcription again with detected language
It sounds smart, but it has hidden costs.

If a ten-minute video is processed twice, the application may pay for twenty minutes of model usage. The user also waits for two requests while believing they submitted only one job.

Worse, the second model can still guess incorrectly.

Adding another AI call does not automatically make a workflow more reliable. Sometimes it just makes the failure slower and more expensive.

The decision: ask before processing
We chose a simpler workflow:

Show a Spoken language selector before upload
Default to English for our current audience
Send the selected language explicitly
Remember the choice locally
Ask the user to check it when the result looks suspicious
The client sends the language with the audio:

const formData = new FormData();
formData.append("audio", audioBlob);
formData.append("language", spokenLanguage);
const response = await fetch("/api/transcribe", {
  method: "POST",
  body: formData,
});
The server validates the value and applies a predictable fallback:

const supportedLanguages = new Set([
  "en",
  "es",
  "fr",
  "de",
  "hi",
  "ar",
  "zh",
]);
const requestedLanguage = formData.get("language");
const language =
  typeof requestedLanguage === "string" &&
  supportedLanguages.has(requestedLanguage)
    ? requestedLanguage
    : "en";
The selected value is then passed to the transcription provider.

This approach is not as magical as “we detect everything automatically,” but its behavior is easier to explain and debug.

Detecting a suspicious result
Users can still choose the wrong language, so we need a recovery path.

After transcription, we inspect the returned words:

type TranscriptWord = {
  text: string;
  confidence?: number;
};
function needsLanguageReview(words: TranscriptWord[]): boolean {
  if (words.length === 0) {
    return true;
  }
  const wordsWithConfidence = words.filter(
    (word) => typeof word.confidence === "number",
  );
  if (wordsWithConfidence.length === 0) {
    return false;
  }
  return wordsWithConfidence.every(
    (word) => (word.confidence ?? 1) < 0.75,
  );
}
An empty result or consistently low confidence does not prove that the language is wrong. The recording might simply be poor.

So we do not display:

Wrong language detected.

Instead, we say something closer to:

The result looks uncertain. Check the spoken language and try again.

That distinction matters. Confidence is a signal, not proof.

Spoken language is not translation language
This also forced us to make the interface clearer.

Consider a Spanish video that needs English subtitles:

Spoken language: Spanish
Translation target: English
The correct pipeline is:

Spanish audio
    ↓ Transcription
Spanish transcript
    ↓ Translation
English subtitles
Trying to transcribe Spanish audio as English is not translation. It is a transcription request with incorrect context.

Keeping these two settings separate prevents a surprising number of errors.

Make the retry cost visible
Changing the language and running transcription again means making another API request.

That may consume additional processing time, so the interface should say so before the retry.

The alternative—silently retrying until something works—creates unpredictable costs for both the user and the application.

Our rule became:

Never hide a second paid model call behind an innocent-looking loading state.

If the retry costs time or credits, tell the user.

What about mixed-language videos?
A single language selector does not solve everything.

A speaker may switch between Hindi and English, Spanish and English, or Arabic and French. Some transcription providers support multilingual modes, but support and accuracy vary by model.

A practical language configuration might therefore look like this:

type LanguageMode =
  | { type: "single"; language: string }
  | { type: "multilingual" };
The important part is not promising multilingual accuracy unless the selected provider and model genuinely support it.

For unsupported combinations, a clear limitation is better than a confident-looking bad transcript.

What we learned
1. Ask users for information they already know
The speaker usually knows which language is in the video. Asking takes seconds and can prevent an expensive failed request.

2. Automatic does not always mean simpler
Automatic detection removes one control from the interface, but it can add retries, cost and confusing failure states behind the scenes.

3. Error messages should describe evidence
“No words were returned” is evidence.

“The video contains no speech” is an interpretation—and it may be wrong.

4. Confidence is not correctness
A low-confidence word needs review. It should not automatically be presented as an error.

5. AI costs are part of UX design
Fallback calls, retries and detection requests affect both the bill and the waiting experience. They are product decisions, not merely backend details.

Final thought
Developers often try to make AI products feel magical by removing every question.

But when the user already knows something the model must guess, one small question can make the product faster, cheaper and more trustworthy.

Sometimes the best AI fallback is not another model.

It is a dropdown.

I'm building [SubtitleGenerator](https://www.subtitlegenerator.net/), an AI subtitle editor that highlights uncertain words so creators can review what matters instead of checking every line.

I Built an AI Subtitle Editor Where Fixing Mistakes Matters More Than Transcription

hua sun — Tue, 08 Sep 2026 11:31:33 +0000

I thought transcription was the hard part.

It turns out that generating 95% correct subtitles is relatively easy. Finding and fixing the remaining 5% is where people lose their time.

A person’s name is wrong. A brand name becomes a common word. One sentence has strange timing. The user then has to replay the entire video just to find a handful of mistakes.

That is the problem I wanted to solve with SubtitleGenerator.

Instead of treating transcription as the finished product, I built the editor around a correction workflow I call the Fix Loop:

Generate subtitles
Highlight words that may be wrong
Jump directly to the relevant audio
Fix or approve the word
Repeat until the track is clear
Style and export

This post covers some of the technical decisions behind it.

The stack

The application currently uses:

Next.js 16
React 19
TypeScript
PostgreSQL with Drizzle ORM
Auth.js
Browser media APIs
ffmpeg.wasm as a fallback
IndexedDB for local project persistence
External speech-to-text and translation APIs

The interesting part was not choosing the stack. It was deciding which work belonged in the browser and which work belonged on the server.

Keeping the original video in the browser

Uploading a large video to a server before transcription creates several problems:

Slow uploads
More storage
More bandwidth
More privacy concerns
More cleanup jobs
A worse experience on unreliable connections

Subtitle generation only needs the audio track, so the original video stays in the browser.

The client extracts a mono 16 kHz WAV file and sends that smaller audio representation to the transcription endpoint.

The simplified flow looks like this:


ts
const audio = await extractAudioFromMedia(videoFile)

const formData = new FormData()
formData.append("audio", audio, "audio.wav")
formData.append("duration", String(duration))
formData.append("language", language)

const response = await fetch("/api/transcribe", {
  method: "POST",
  body: formData,
})

How We Map Photos to Printable Bead Palettes (Without 80 Near-Identical Colors)

hua sun — Wed, 26 Aug 2026 09:05:05 +0000

How We Map Photos to Printable Bead Palettes

Turning a photo into a craftable perler-bead chart is mostly an image-processing problem: downsample to a grid, then map every cell to a finite palette that people can actually buy.

If you only “pixelate” an image, you still get hundreds of RGB values. Makers need something closer to:

a grid sized for a real pegboard
colors from a brand palette (Perler / Hama / etc.)
a count list so they know what to buy

That workflow is what we ship in the browser at PixelBeads.

The pipeline (high level)

Load + optional crop — focus on the subject; less background = fewer junk colors
Resize to target grid — e.g. 29×29 / 50×50 style boards, not arbitrary megapixel pixels
Quantize to a palette — nearest color in Lab (or similar) to brand swatches
Optional color reduction — merge near-duplicates so the project stays buildable
Export — printable chart + per-color counts

The hard part is step 3–4: looks like the photo vs you can finish it this weekend.

Why naive nearest-RGB fails

RGB Euclidean distance is a bad perceptual metric. Two shades can be “close” in RGB but look very different (or vice versa). For craft palettes we care about:

perceptual distance (Lab / ΔE-style thinking)
inventory constraints (user only owns 40 codes)
count explosion (80 colors ≈ abandoned project)

So we expose custom palettes: users pick only the codes they own, then quantization is limited to that subset. Write-up on the product side: custom bead palettes.

A tiny mental model (pseudo)


text
for each cell in grid:
  sample average color of the source region
  find nearest swatch in allowed_palette  # Lab distance
  write swatch_id to cell

then optionally:
  merge swatches below a ΔE threshold
  recompute counts

How to Create Pixel Bead Patterns from Any Image

hua sun — Tue, 25 Aug 2026 12:27:06 +0000

I recently tried pixelbeads.io to convert a photo into a printable bead pattern. It was super easy and free, no sign-up needed. The color counts were accurate and helped me plan my project. Check it out: pixelbeads.io

How to Turn Any Photo into a Perler Bead Pattern (Free Online)

hua sun — Fri, 03 Jul 2026 09:31:12 +0000

Creating a Perler bead pattern used to require hours of manual work. You had to resize your image, reduce colors, count beads, and redraw everything on graph paper.

Today, AI can do all of that automatically.

If you've ever wanted to turn a pet photo, anime character, game sprite, or family picture into a printable Perler bead pattern, here's the easiest way.

Step 1 — Upload Your Image

Start by choosing any photo.

Good examples include:

Pet portraits
Family photos
Pixel art
Game characters
Anime characters
Logos
Simple illustrations

The clearer the image, the better the final bead pattern will look.

Step 2 — Generate the Pattern

Upload the image to PixelBeads.io.

The generator automatically:

Detects image colors
Converts the picture into bead-friendly pixels
Optimizes the color palette
Matches colors to common Perler bead colors
Generates a printable bead grid
Counts the exact number of beads required

The entire process usually takes only a few seconds.

Step 3 — Print the Grid

Once the conversion is complete, you can download:

Printable bead grid
Color legend
Bead count
Pattern preview

Simply print the pattern or display it on a tablet while building your project.

Tips for Better Results

For the best-looking bead art:

Use high-resolution images.
Avoid blurry photos.
Choose subjects with strong contrast.
Crop unnecessary backgrounds before uploading.
Keep the image focused on one main object.

These small adjustments can dramatically improve the final pattern.

Popular Projects

Many makers use photo-to-pattern conversion for:

Pet memorials
Family portraits
Pokémon
Mario characters
Minecraft art
Retro game sprites
Anime characters
Custom gifts

Because every uploaded image is unique, every pattern is unique as well.

Why Use an Online Perler Bead Generator?

Compared with drawing patterns manually, an online generator saves time and reduces mistakes.

Benefits include:

Fast conversion
Accurate color matching
Printable layouts
Automatic bead counting
No software installation
Works directly in your browser

Whether you're a beginner or an experienced crafter, generating patterns online is much easier than creating them by hand.

Start Creating Today

Ready to make your own custom Perler bead pattern?

Upload your favorite image and let PixelBeads.io transform it into a printable bead design in just seconds.

Happy crafting!