DEV Community: ryan-w-ai

Why Video Inpainting Looks Fine — Until You Hit Play

ryan-w-ai — Fri, 16 Jan 2026 09:32:03 +0000

Introduction

Video inpainting looks deceptively similar to image inpainting.

After all, a video is just a sequence of images — right?

In practice, this assumption is responsible for most visual artifacts seen in automated video restoration systems today.

The most common symptom is flicker: unstable textures, jittering edges, and inconsistent motion in repaired regions.

This post explains why per-frame approaches fail, why optical flow only partially helps, and how modern spatiotemporal models address the problem.

⸻

The Per-Frame Trap

In a per-frame pipeline, each frame is processed independently using an image inpainting model.

Mathematically, this optimizes spatial quality:
• Sharp edges
• Plausible textures
• Local realism

What it does not optimize is temporal coherence.

Small stochastic differences between frames accumulate into visible instability during playback.

Each frame is “correct” — but the sequence is not.

⸻

Optical Flow: Useful but Fragile

To improve consistency, traditional systems introduced optical flow.

The idea is simple:
1. Estimate pixel motion between frames
2. Use motion vectors to propagate known content into missing regions

This works well under limited conditions:
• Static backgrounds
• Slow camera motion
• Minimal occlusion

However, optical flow breaks down when:
• Foreground objects occlude background regions
• Motion is non-linear or chaotic
• Lighting changes rapidly

Once flow estimation fails, artifacts propagate instead of being corrected.

⸻

Spatiotemporal Deep Learning

Modern approaches abandon frame independence entirely.

Instead of processing images sequentially, spatiotemporal models process volumes of video.

Key techniques include:
• 3D convolutional networks for joint space-time feature extraction
• Attention mechanisms that reference multiple frames simultaneously
• Transformer-based architectures that model long-range temporal dependencies

These models learn which visual information remains consistent across time — and which does not.

This fundamentally changes how missing regions are reconstructed.

⸻

Measuring Temporal Consistency

Temporal quality cannot be evaluated using single-frame metrics.

Common approaches include:
• Feature similarity across consecutive frames (e.g., VGG-based metrics)
• Temporal Flicker Index (TFI)
• Optical-flow residual stability scores

These metrics better correlate with human perception of video quality.

⸻

Practical Implications

Temporal modeling is not an academic detail.

It directly determines whether a system is usable in:
• Video restoration
• Object removal
• Watermark erasure
• Generative video editing

Any pipeline that ignores temporal consistency will fail under real-world conditions.

⸻

Conclusion

The biggest mistake in video AI is treating time as an afterthought.

Per-frame methods optimize images.
Spatiotemporal methods optimize videos.

Understanding this distinction explains why many tools fail — and why newer architectures are finally closing the gap between automated video processing and professional results.

This post is adapted from a longer technical article exploring the full evolution from optical flow to spatiotemporal AI:

Read the full technical breakdown

Remove CapCut Watermark with AI — How We Built a Flicker-Free Video Inpainting System

ryan-w-ai — Tue, 30 Dec 2025 15:39:36 +0000

We got tired of blurry crop overlays. So we built our own restoration-based AI CapCut watermark remover — and here’s how.

🔗 Full engineering write-up & live demo:

Remove CapCut watermark with AI – engineering breakdown

Most “CapCut watermark removers” on the internet still do one of three things:

crop the frame,
blur or smear the logo,
or cover it with another sticker.

It works visually at a glance, but for real creators this is painful:

subtitles get cut off,
logos or UI elements are gone,
edges look soft and dirty,
and on video you often see flicker and ghosting frame to frame.

For my own projects I wanted something closer to video restoration instead of “logo hiding”, so I ended up building an AI CapCut watermark remover that:

keeps the original resolution,
inpaints pixels instead of cropping,
and preserves temporal consistency across frames.

The full story (with diagrams, screenshots and examples) is on my own blog:

👉 Remove CapCut watermark with AI – full article & demo

Below is the short engineering overview for dev.to.

Why another CapCut watermark remover?

CapCut is everywhere in short-form content. The official export watermark is fine for casual use, but for:

client work,
brand videos,
educational content,
or anything you want to re-edit later,

you really don’t want a big logo sitting on top of your footage.

Traditional tricks (crop / blur / overlay) all have the same problem:

they destroy pixels instead of reconstructing pixels.

So the goal of this project was:

“Remove the CapCut logo while keeping the video usable for professional editing.”

Our approach in one diagram

The high-level pipeline looks like this:

Detect the CapCut watermark region.
Track it across frames with optical flow.
Inpaint each frame using an AI model.
Smooth the result to avoid flicker.
Export the final video.

I go into much more detail (why this order, what models, what trade-offs) in the long-form post:

➡️ Flicker-free video inpainting pipeline for CapCut watermark removal

1. Detection & tracking

We don’t hard-code a crop. Instead we:

use template-like matching around typical CapCut positions,
run edge/contrast checks to avoid false positives,
and stabilise the region across frames via optical flow.

This gives us a robust mask even when:

the background is busy,
the logo sits on top of text,
or the export resolution changes.

2. AI inpainting (frame level)

Once we have a clean mask, each frame goes through an inpainting model.

Key points:

We prefer structure-aware inpainting so edges (UI lines, walls, subtitles) stay coherent.
The model runs at video-friendly speed – no “wait 10 minutes per clip” nonsense.
We keep everything in the original resolution as much as possible.

3. Temporal consistency (video level)

If you just inpaint frame-by-frame, you get:

random variations in texture,
shimmering edges,
and obvious “AI noise” when you play the video.

To fix this we add a temporal smoothing step:

use optical flow to align neighbouring frames,
blend and filter the inpainted regions,
clamp aggressive changes so motion looks natural.

This is where the “flicker-free” part really comes from.

I show visual examples in the main post:

🔍 Remove CapCut watermark with AI – before/after comparisons

4. Shipping it as a web tool

Another requirement: no heavy desktop installation.

So the final product is a browser-based CapCut watermark remover:

upload your video,
the pipeline runs on the backend,
download a cleaned version.

You can try it here:

🎬 Online AI CapCut watermark remover (web app)

What’s next

In the full article I also cover:

how we handle different export resolutions,
failure cases and what still breaks,
trade-offs between quality vs. processing time,
and ideas for a Pro version (batch, higher bit-rate, API, etc.).

If you’re curious about the full engineering details, check out:

👉 Remove CapCut watermark with AI – engineering breakdown & live demo

And if you’re building something similar (video restoration, AI VFX cleanup, etc.),

I’d love to see it – feel free to share your links or questions in the comments.

Vibe Coding hit a wall: How I fixed $0.30/error OOMs and cut AI costs by 70%

ryan-w-ai — Wed, 17 Dec 2025 12:02:12 +0000

Originally published on my blog: Video Watermark Tech

I recently joined the "Vibe Coding" movement—letting AI write 90% of my code to ship fast. It felt like magic.

I "prompted" my way to building a Free Video Watermark Remover in a single weekend. No boilerplate, just vibes. I deployed it, shared it on Dev.to, and traffic started pouring in.

But then, the "Vibe Check" failed hard.

The AI wrote functional code, but it didn't write efficient code. Reality hit me in the form of a server log.

The Disaster: Paying for Failure 💸

I woke up to a sea of red logs: RuntimeError: CUDA out of memory.

Users were uploading raw 4K, 60fps videos recorded on modern iPhones. These files were massive. When fed directly into the AI model (ProPainter on Replicate), the VRAM spiked, and the process crashed after about 4 minutes.

Here is the kicker with Serverless GPU providers like Replicate:
You pay for the compute time, even if the task fails.

I was paying $0.20 - $0.30 for every crashed session. I was literally burning money to frustrate my users. The "Vibe" was gone.

The Naive Solution vs. The Engineering Solution

My first instinct (and the AI's suggestion) was to "Vertical Scale": Just upgrade the hardware. Switch from an NVIDIA T4 to an A100 (40GB VRAM).

The problem: A100s are expensive. This would triple my costs per second. It doesn't solve the inefficiency; it just masks it with money.

Then I realized: Does a TikTok reposter really need 4K 60fps?
Most social media platforms compress videos to 1080p or 720p anyway. Processing 60 frames per second for a watermark removal is a waste of compute—30fps is visually identical for this use case.

The Fix: The CPU Middleware Pattern 🛡️

Vibe coding gets you from 0 to 1, but System Architecture gets you from 1 to 100.

Instead of sending raw videos directly to the GPU, I introduced a CPU Pre-processing Layer. I already had a VPS on Hostinger (which I paid for annually). The CPU cycles there were effectively free (sunk cost).

The New Architecture:

User Uploads -> My Hostinger Server (CPU).
Normalization -> FFmpeg compresses video to 720p @ 30fps.
Inference -> Optimized video sent to Replicate (GPU).
Merge -> AI output video + Original Audio merged back via FFmpeg.

The Code Implementation

Here is the Python logic I used to normalize the inputs before they ever touch the expensive GPU.


python
import subprocess

def optimize_video_for_ai(input_path, output_path):
    """
    Standardizes video to 720p and 30fps to prevent OOM.
    Uses 'veryfast' preset to minimize CPU latency.
    """
    command = [
        "ffmpeg", 
        "-i", input_path,
        "-vf", "scale='min(1280,iw)':-2",  # Downscale to 720p max, keep aspect ratio
        "-r", "30",                        # Force 30fps
        "-c:v", "libx264", 
        "-preset", "veryfast",             # Prioritize speed
        "-crf", "28",                      # Slight compression to speed up upload
        "-an",                             # Remove audio (we merge original audio later)
        "-y",
        output_path
    ]

    subprocess.run(command, check=True)

I refused to pay subscriptions just to delete an ending, so I "Vibe Coded" a CapCut Watermark Remover (No Login)

ryan-w-ai — Thu, 11 Dec 2025 06:50:52 +0000

The "Vibe Coding" Era 🌊

I confess. I haven't written a single line of boilerplate code in months. And I love it.
We are in the era of Vibe Coding.

Last week, I had a specific problem as a content creator: I love using CapCut for its templates, but I hate that floating ID watermark and the black ending screen that ruins the loop.

I googled "remove capcut watermark". The results?

"Sign up for a free trial" 🛑
"Upload limit: 10MB" 🛑
"Watch this 30s ad first" 🛑

The "old me" would have sighed and opened video editing software to crop it manually.
The "Vibe Coding me" opened my AI editor (Cursor) and said: "Let's build a web tool to kill these watermarks. Fast."

The Challenge: Why existing tools fail

Removing a watermark isn't just about cropping or blurring (which looks ugly). It requires AI In-painting—reconstructing the missing pixels behind the logo.

Most tools hide this feature behind a paywall or a login wall. I wanted a solution that was:

Browser-based (No download).
No Login (I value my privacy).
Specialized for CapCut (Detects the specific ending frames).

How I "Vibe Coded" it in a weekend ⚡

I focused on the Logic, and let AI handle the Syntax.

The Prompt: "Build a React drag-and-drop zone. Connect it to a Python backend using an in-painting model. Optimize it for TikTok and CapCut video formats."
The Vibe: I acted as the Product Manager and the CTO. The AI was my junior dev team.
The Tech Stack: Next.js for the frontend, Python/FastAPI for the inference engine.

Because I didn't spend weeks writing CSS from scratch, I could focus entirely on the User Experience and the AI Model performance.

The Result: VideoWatermarkRemove.com 🚀

I launched VideoWatermarkRemove.com.

It is the epitome of Vibe Coding: simple, fast, and solves exactly one problem.

Here is the specialized CapCut interface I built:

[👇 Action: Drag and drop your Screenshot here 👇]
(Delete this line after uploading. Make sure the screenshot shows the "Remove CapCut" interface)

(Caption: The specialized mode for removing CapCut templates and endings)

Key Features:

🚫 No Login Required: Just drop your file and get the clean video.
✂️ Specialized CapCut Mode: I fine-tuned the logic to handle CapCut Watermark Removal better than generic tools. It attempts to reconstruct the text area rather than just blurring it.
⚡ Fast Processing: Optimized for short-form content (TikTok/Reels/Shorts).

Why this matters (The "No-BS" Philosophy)

If you are a dev or a creator, you know the pain of "Software Bloat."
I built this tool to be the opposite.

No "Credits system."
No "Email capture."
Just a clean tool for the community.

Try it out

I am currently optimizing the model to better handle moving watermarks (like the bouncing TikTok logo).

I would love for you to test the CapCut Mode:
👉 Try the Free CapCut Watermark Remover

If you encounter any edge cases (e.g., specific 4K templates), let me know in the comments! I'll just prompt the AI to fix it. 😉

Happy Vibe Coding! 🌊✨

How I built a free AI Video Watermark Remover using React & Firebase

ryan-w-ai — Mon, 01 Dec 2025 10:56:48 +0000

Hey fellow devs! 👋

I recently launched a side project that solves a personal pain point I've had for a while: removing watermarks and ending screens from CapCut/TikTok videos without jumping through hoops.

Most tools out there require a signup, payment, or they simply "blur" the watermark (which looks terrible). I wanted to build something cleaner, faster, and 100% free.

Here is the result: VideoWatermarkRemove.com

🛠 The Tech Stack

I wanted to keep it lightweight and fast, so I went with:

Frontend: React + Vite (for that instant HMR)
Styling: Tailwind CSS (Dark mode by default, obviously)
Auth: Firebase Authentication (Google Sign-in)
Hosting: Vercel
Core: AI Inpainting models for object removal

🐛 The "Struggle" (A Hard Lesson on Caching)

It wasn't all smooth sailing. I spent about 3 hours debugging a weird Firebase Auth 400 Error when deploying to production.

Locally, everything worked fine. In production? Broken.
I checked my API Keys, my Google Cloud OAuth redirect URIs, and my .env variables. Everything looked correct.

The culprit? Vercel deployments and Browser Cache.
I had updated the authDomain environment variable in Vercel settings but forgot to trigger a Redeploy. Even after I did, my Chrome browser was aggressively caching the old index.html which referenced the old config.

Lesson learned: Always hard refresh (Ctrl+Shift+R) and verify your build variables in the "Network" tab before losing your mind! 😅

🚀 How it works

Instead of a simple Gaussian blur, the tool uses an AI inpainting approach. It detects the watermark area (like the bouncing TikTok logo or the static CapCut ending) and attempts to "reconstruct" the background pixels based on the surrounding context.

🔮 What's Next?

This is currently an MVP. I'm planning to:

Improve the mobile layout (it's a bit clunky on small screens right now).
Add support for batch processing.
Optimize the AI model speed.

I'd love to get your feedback on the UI/UX and the removal quality. Feel free to roast my code or give suggestions!

Try it out here: https://www.videowatermarkremove.com/

Thanks for reading!