Stop Paying $500/Month for Short Videos: YumCut Is Free

Stop Paying $500/Month for Short Videos: YumCut Is Free

What if I told you that creators are burning $500 to $2,000 every single month on closed video platforms—and they don't even own their workflow? Every credit-based render, every "premium tier" upsell, every API call locked behind someone else's infrastructure. It's the silent tax on modern content creation, and it's bleeding indie makers, agencies, and faceless channel operators dry.

But here's the secret nobody selling you Veo credits wants you to know: the technology to generate complete, publish-ready vertical videos from a simple text prompt is now completely free and open-source.

Enter YumCut—a self-hosted AI video generator that transforms your ideas into TikTok, YouTube Shorts, and Instagram Reels with automated scripts, voiceovers, subtitles, and watermarks. Built on Next.js^{↗ Bright Coding Blog}. Designed for batch production. Engineered for creators who refuse to rent their tools.

If you're still manually editing in CapCut, paying per-render on Clippie AI, or watching your Runway credits evaporate—this changes everything. Keep reading, because I'm about to show you exactly why top growth teams are quietly migrating their entire short-form pipelines to this open-source powerhouse.

What Is YumCut?

YumCut is an open-source, self-hosted AI short video generator created by Igor Shadurin that produces complete 9:16 vertical videos from text prompts. It's positioned as the free, auditable alternative to closed SaaS tools like Clippie AI, FacelessReels, Revid.ai, and premium API services from Runway, Pika, and Google's Veo.

Unlike tools that lock you into credit systems and opaque pricing, YumCut gives you full infrastructure control. You bring your own AI providers, run local components where possible, and tune the quality-speed-cost triangle to match your actual needs.

The project is built on Next.js with a local-first pipeline architecture—meaning your core generation workflow can run entirely on your own hardware or cloud instances. It supports multi-language output, batch rendering, and API hooks for integration into larger creator stacks. The FFmpeg-ready backend handles video assembly, while the frontend provides an intuitive interface for prompt-to-video workflows.

Why it's trending now: The explosion of faceless channels, AI-generated content, and multi-language content strategies has created insatiable demand for short-form video at scale. Creators discovered that paying $0.50-$5 per video on closed platforms becomes catastrophic at volume. YumCut's 10x cost reduction claim isn't marketing—it's arithmetic. When you're publishing 3-5 videos daily across multiple channels, self-hosting isn't just cheaper; it's the difference between profitable and bankrupt.

Key Features That Make YumCut Insane

YumCut isn't a toy. It's a production-oriented system designed for real publishing workflows. Here's what separates it from weekend projects:

End-to-End Automated Pipeline

From raw prompt to publish-ready 9:16 video: script generation → scene assembly → voiceover synthesis → subtitle burning → watermark application → final render. No manual editing required. The entire chain executes automatically based on your configuration templates.

Local-First Architecture with Provider Flexibility

Run the core pipeline locally while selectively using cloud AI providers for specific tasks (image generation, TTS, LLM scripting). This hybrid approach lets you minimize API costs by keeping compute-heavy video assembly (FFmpeg) on your own infrastructure while outsourcing only what you can't run efficiently yourself.

Batch Rendering Engine

Generate multiple videos simultaneously from a single campaign or content calendar. This is where agencies and multi-channel operators win: queue 50 video variations, walk away, return to finished renders. The batch system supports template-based generation with variable substitution for hooks, CTAs, and language versions.

Multi-Language Content Expansion

One prompt becomes localized versions across languages. The system handles script translation, voice synthesis in target languages, and subtitle generation. Real examples from the repository show Spanish and Portuguese versions of English concepts performing comparably on YouTube Shorts.

Signed Upload/Delete Security Model

Production-grade security with signed grants for storage operations—not wide-open buckets. The architecture separates app and storage modes explicitly, giving you granular control over who can access generated assets and for how long.

Typed API Boundaries

Clean TypeScript interfaces for integrating YumCut into larger automation stacks. Hook it into your n8n workflows, Make.com scenarios, or custom CMS for fully automated content pipelines.

Template-Driven Consistency

Define reusable video structures (hook structure, scene timing, visual style, music bed) and generate infinite variations without rebuilding from scratch. This is the secret weapon for brand consistency at scale.

Real-World Use Cases Where YumCut Dominates

Faceless Channel Daily Publishing

The bread and butter: channels that publish 1-3 videos daily without on-camera talent. YumCut generates scripts from trending topics, assembles visuals, adds voiceover, and outputs ready-to-upload files. One operator can manage 5-10 channels instead of being bottlenecked by editing time.

Multi-Language Content Arbitrage

Take a winning English concept and auto-generate Spanish, Portuguese, French, German versions with localized voice and subtitles. The repository shows Spanish Simpsons-style content hitting 1.5K views—same production effort, 4x the addressable audience.

Agency Batch Production for Multiple Clients

Marketing agencies white-labeling short-form content use YumCut's template + batch system to produce 100+ videos weekly across different brand identities. Self-hosted deployment means client data never touches third-party SaaS infrastructure—critical for enterprise compliance.

Rapid Hook/Style A/B Testing

Generate 10 variations of the same core script with different opening hooks, visual styles, or CTA placements. Upload all, measure performance, double down on winners. The speed advantage here is existential: test in hours what takes competitors weeks.

AI News and Commentary Channels

Feed trending headlines into YumCut, get narrated video summaries with relevant visuals. The automated pipeline means breaking news response time in minutes, not hours.

Step-by-Step Installation & Setup Guide

Ready to escape the SaaS tax? Here's your complete deployment path:

Prerequisites

# Ensure Node.js 18+ and FFmpeg are installed
node --version  # Should show v18.0.0 or higher
ffmpeg -version  # Required for video assembly pipeline

# Install FFmpeg if missing (Ubuntu/Debian)
sudo apt update && sudo apt install ffmpeg

# macOS with Homebrew
brew install ffmpeg

Clone and Install

# Clone the repository
git clone https://github.com/IgorShadurin/app.yumcut.com.git
cd app.yumcut.com

# Install dependencies
npm install
# or
yarn install

Environment Configuration

# Copy the environment template
cp .env.example .env.local

# Edit .env.local with your provider credentials
# Required: AI provider API keys (OpenAI, ElevenLabs, Replicate, etc.)
# Required: Storage configuration (local or S3-compatible)
# Optional: Commercial license key if running for clients

Key environment variables to configure:

Build and Launch

# Development mode with hot reload
npm run dev

# Production build
npm run build
npm start

Verify FFmpeg Integration

# Test that FFmpeg is accessible to the pipeline
npm run verify:ffmpeg
# Should confirm version and codec support for H.264/AAC

Docker^{↗ Bright Coding Blog} Deployment (Recommended for Production)

# Build production image
docker build -t yumcut:latest .

# Run with mounted storage and env file
docker run -d \
  --name yumcut \
  -p 3000:3000 \
  --env-file .env.local \
  -v $(pwd)/renders:/app/renders \
  yumcut:latest

REAL Code Examples from the Repository

The YumCut repository includes practical implementation patterns. Here are the critical ones, extracted and explained:

Example 1: Basic Prompt-to-Video Generation

This pattern shows the core workflow—taking a text prompt and triggering the full pipeline:

// POST /api/generate - Main generation endpoint
import { NextRequest, NextResponse } from 'next/server';
import { VideoPipeline } from '@/lib/pipeline';

export async function POST(request: NextRequest) {
  const body = await request.json();
  
  // Extract generation parameters from request
  const { prompt, language = 'en', style = 'default', duration = 60 } = body;
  
  // Validate required fields
  if (!prompt || prompt.length < 10) {
    return NextResponse.json(
      { error: 'Prompt must be at least 10 characters' },
      { status: 400 }
    );
  }
  
  // Initialize pipeline with user configuration
  const pipeline = new VideoPipeline({
    language,           // 'en', 'es', 'pt', 'de', etc.
    styleTemplate: style,  // References template in /templates/
    targetDuration: duration,  // Seconds, typically 30-90 for shorts
    enableSubtitles: true,
    enableWatermark: true,
  });
  
  // Execute full generation: script → scenes → voice → assembly
  const result = await pipeline.execute(prompt);
  
  // Return signed URL for download and metadata
  return NextResponse.json({
    videoUrl: result.signedUrl,      // Time-limited access
    duration: result.actualDuration,
    scenes: result.sceneCount,
    cost: result.estimatedCost,      // Track spend per video
  });
}

What's happening here: The endpoint receives a creative prompt, validates it, instantiates the VideoPipeline with style and language preferences, then executes the full chain. The response includes a signed URL (security-first design) and cost tracking for budget management.

Example 2: Batch Generation for Content Calendars

This is where production scale happens—queue multiple videos with shared templates:

// Batch processing for agency/team workflows
import { BatchProcessor } from '@/lib/batch';

const campaign = new BatchProcessor({
  template: 'educational-tech',  // Pre-defined scene structure
  maxConcurrent: 3,              // Control API rate limits
  outputFormat: 'mp4',           // Universal compatibility
  resolution: '1080x1920',       // Standard 9:16 vertical
});

// Define content variants from one core idea
const prompts = [
  { prompt: 'Explain blockchain in 60 seconds', language: 'en' },
  { prompt: 'Explain blockchain in 60 seconds', language: 'es' },
  { prompt: 'Explain blockchain in 60 seconds', language: 'pt' },
  { prompt: '5 blockchain myths debunked', language: 'en', hook: 'controversial' },
  { prompt: 'How I lost money in crypto', language: 'en', hook: 'story' },
];

// Execute all with progress tracking
const results = await campaign.execute(prompts, {
  onProgress: (completed, total, current) => {
    console.log(`Progress: ${completed}/${total} - Rendering: ${current.title}`);
  },
  onComplete: (allResults) => {
    // Auto-export to CMS, upload queue, or analytics
    console.log(`Campaign complete: ${allResults.length} videos`);
    console.log(`Total cost: $${allResults.reduce((s, r) => s + r.cost, 0).toFixed(2)}`);
  },
});

The power move: One core concept becomes 5 publishable videos with different languages and hooks. The maxConcurrent parameter prevents API rate limit violations. Progress callbacks let you build real-time dashboards. Cost aggregation shows exactly what your content factory spends.

Example 3: Custom Template Definition

Templates control the visual and structural DNA of your videos:

// templates/educational-tech.ts
export default {
  name: 'educational-tech',
  aspectRatio: '9:16',
  resolution: { width: 1080, height: 1920 },
  
  // Scene structure: how content flows
  sceneStructure: [
    { type: 'hook', duration: 3, maxWords: 15 },      // Grab attention fast
    { type: 'problem', duration: 8, maxWords: 40 },    // Establish stakes
    { type: 'solution', duration: 15, maxWords: 80 },  // Core content
    { type: 'proof', duration: 10, maxWords: 50 },     // Evidence/example
    { type: 'cta', duration: 4, maxWords: 12 },        // Follow/comment/subscribe
  ],
  
  // Visual style parameters
  visualStyle: {
    backgroundType: 'gradient',        // gradient, image, video
    gradientColors: ['#1a1a2e', '#16213e'],
    textPosition: 'lower-third',       // Safe zone for UI overlay
    fontFamily: 'Inter-Bold',
    fontColor: '#ffffff',
    textStroke: { width: 2, color: '#000000' },  // Readability on any background
  },
  
  // Audio configuration
  audio: {
    voiceProvider: 'elevenlabs',
    voiceId: 'Josh',                   // Consistent narrator
    backgroundMusic: 'upbeat-tech',    // From /assets/music/
    musicVolume: 0.15,                 // Duck under voice
    normalizeAudio: true,              // Consistent loudness
  },
  
  // Subtitle styling
  subtitles: {
    enabled: true,
    style: 'word-by-word-highlight',   // TikTok-native feel
    highlightColor: '#00ff88',
    position: 'center-lower',
  },
  
  // Branding
  watermark: {
    enabled: true,
    text: '@YourChannel',
    position: 'top-right',
    opacity: 0.6,
  },
};

Why this matters: Templates make brand consistency automatic. Define once, generate hundreds. The sceneStructure enforces proven short-form psychology (hook fast, deliver value, close strong). Visual parameters ensure every video looks like your content, not generic AI slop.

Example 4: FFmpeg Assembly Pipeline (Core Engine)

The actual video construction happens via FFmpeg orchestration:

// lib/ffmpeg/assembler.ts - Video construction engine
import { spawn } from 'child_process';
import { join } from 'path';

export class FFmpegAssembler {
  async assembleVideo(scenes: Scene[], config: AssemblyConfig): Promise<string> {
    const outputPath = join(config.outputDir, `${config.id}.mp4`);
    
    // Build complex filtergraph for scene transitions
    const filterComplex = scenes.map((scene, i) => {
      // Each scene: image/video input with text overlay and audio
      return `[${i}:v]fade=t=in:st=0:d=0.5,fade=t=out:st=${scene.duration-0.5}:d=0.5[v${i}];` +
             `[v${i}]drawtext=text='${escapeText(scene.text)}':` +
             `fontfile=${config.fontPath}:` +
             `fontsize=${scene.fontSize}:` +
             `fontcolor=${config.textColor}:` +
             `x=(w-text_w)/2:y=h*0.75[v${i}t]`;
    }).join('');
    
    // Concatenate all processed scenes
    const concatInputs = scenes.map((_, i) => `[v${i}t]`).join('');
    const finalFilter = `${filterComplex}${concatInputs}concat=n=${scenes.length}:v=1:a=0[outv]`;
    
    // Execute FFmpeg with optimized encoding
    const ffmpeg = spawn('ffmpeg', [
      '-y',                              // Overwrite output
      ...scenes.flatMap(s => ['-loop', '1', '-i', s.mediaPath]),  // Image inputs
      '-i', config.audioPath,            // Mixed audio track
      '-filter_complex', finalFilter,    // Scene assembly
      '-map', '[outv]',                  // Video output
      '-map', `${scenes.length}:a`,      // Audio from mixed track
      '-c:v', 'libx264',                 // H.264 for universal compatibility
      '-preset', 'fast',                 // Encoding speed/quality tradeoff
      '-crf', '23',                      // Quality level (lower = better)
      '-c:a', 'aac',                     // Audio codec
      '-b:a', '192k',                    // Audio bitrate
      '-movflags', '+faststart',         // Web-optimized streaming
      '-pix_fmt', 'yuv420p',             // Maximum compatibility
      outputPath,
    ]);
    
    return new Promise((resolve, reject) => {
      ffmpeg.on('close', (code) => {
        code === 0 ? resolve(outputPath) : reject(new Error(`FFmpeg exited ${code}`));
      });
    });
  }
}

The technical reality: This is where "AI video" becomes actual video. FFmpeg handles the pixel-perfect assembly: scene transitions, text burning, audio mixing, encoding optimization for platform algorithms. The -movflags +faststart ensures instant playback on social platforms. The yuv420p pixel format guarantees compatibility from iPhone 8 to latest Android.

Advanced Usage & Best Practices

Cost Optimization Strategy

Pro tip: Start cloud-heavy for speed, then migrate components local as you validate your content-market fit.

Template A/B Testing Framework

Create template variants with single-variable changes:

const testMatrix = {
  hookStyle: ['question', 'shock', 'story', 'direct'],
  duration: [30, 45, 60],
  musicEnergy: ['low', 'medium', 'high'],
};
// Generate all combinations, measure retention at 3s and completion

API Integration for Automation

// Webhook-triggered generation from your CMS
app.post('/webhook/yumcut', async (req, res) => {
  const { trendingTopic } = req.body;
  const video = await yumcut.generate({
    prompt: `Create a 60-second explainer about ${trendingTopic}`,
    autoPublish: true,  // Connect to Buffer/Later/Native APIs
  });
  res.json({ publishedUrl: video.platformUrls.tiktok });
});

Comparison with Alternatives

The verdict: If you value cost control, data sovereignty, and infrastructure flexibility, YumCut is the only option that doesn't force compromises. Closed tools win on "it just works" convenience—for a tax of 10x your infrastructure cost.

FAQ

Is YumCut really free for personal use?

Yes. The core project is open-source and free for personal use. You pay only for your own API usage (OpenAI, ElevenLabs, etc.) and infrastructure. No platform fees, no credit systems, no feature gates.

What's the catch with self-hosting?

You manage your own infrastructure and API keys. This requires technical setup (the guide above) and ongoing maintenance. The tradeoff is 10x lower costs and complete control. For non-technical users, the hosted version at YumCut.com exists.

Can I use YumCut for client work or commercial services?

Requires a commercial license. Contact igor.shadurin@gmail.com for licensing. This supports continued open-source development while letting agencies build profitable services.

How does video quality compare to Runway or Pika?

YumCut's visual quality depends on your chosen image/video generation provider. With premium providers (Replicate, Leonardo), quality matches or exceeds closed tools. With local models, you trade some quality for massive cost reduction. The assembly and editing quality (transitions, text, audio mix) is professional-grade via FFmpeg.

What languages are supported?

Any language supported by your LLM and TTS providers. Tested examples include English, Spanish, Portuguese, French, German, Italian. The template system handles RTL languages with configuration adjustments.

Can I customize the visual style completely?

Yes. Templates are fully configurable TypeScript objects controlling colors, fonts, scene structures, transitions, and watermarking. You can create unlimited custom templates matching any brand identity.

Is there a limit on video length?

Optimized for 15-90 second short-form (TikTok/Reels/Shorts). Technical limits depend on your infrastructure. Long-form is possible but not the primary design target.

Conclusion

The creator economy runs on volume and speed. Every day you're not publishing is a day your competitors are capturing attention that could have been yours. The problem? The tools designed to help you scale are engineered to extract maximum rent from your success.

YumCut inverts this model. Open-source core. Self-hosted infrastructure. Provider flexibility. Template-driven consistency. Batch production at costs that make closed platforms look like a bad joke.

I've shown you the architecture, the code, the cost structure, and the real-world proof. The repository has working examples generating content that's already performing on TikTok and YouTube Shorts. The only question is whether you'll act on this information before your competitors do.

Stop renting your creative infrastructure. Own your pipeline. Scale without limits.

👉 Get YumCut on GitHub now — star the repo, read the full technical docs at docs/tech.md, and join the creators who've already escaped the SaaS tax.

Your first self-hosted video is closer than you think.