VideoFlow: The Apache-2.0 Open Source Alternative to Remotion

For years, developers looking to build video pipelines with code had one primary destination. But as the ecosystem matures, the requirements for programmatic video are shifting. Teams are no longer just looking for a way to render frames; they need open-source licensing, portable data formats, and the ability to export video directly in the user's browser without a heavy server bill.

If you are searching for a Remotion alternative open source toolkit that fits these criteria, VideoFlow was built specifically for you. By decoupling the video definition from the rendering engine and adopting the Apache-2.0 license, VideoFlow offers a flexible, developer-first approach to automated content creation.

Why Developers are Looking for a Remotion Alternative

Remotion is a powerful tool, but its architecture and licensing often create friction for modern engineering teams. Because Remotion scenes are defined as React component trees, they are inextricably tied to a React runtime. This makes it difficult to generate video definitions from other languages (like Python or Go) or to store and version-control video projects as pure data.

Furthermore, Remotion's core is proprietary. For organizations that prioritize true open-source foundations or those that need to embed video rendering into commercial products without complex licensing overhead, VideoFlow provides a clean path forward. The core builder and all three official renderers are Apache-2.0, ensuring your stack remains free and unencumbered forever.

The Three-Renderer Rule: Browser, Server, and DOM

One of the most significant differences in the VideoFlow architecture is its three official renderers. Unlike other tools that focus primarily on server-side rendering with headless browsers, VideoFlow treats the browser as a first-class citizen.

1. @videoflow/renderer-browser: Renders and exports MP4s directly in the user's browser tab using WebCodecs. This is a game-changer for client-side applications, allowing you to offer video export to your users with zero server cost.
2. @videoflow/renderer-server: A headless Node.js renderer that drives Chromium via Playwright. It is optimized for batch jobs and automated content factories.
3. @videoflow/renderer-dom: A frame-accurate, 60fps live preview engine. You can see this in action on our Playground.

Because all three renderers consume the same VideoJSON, you can build a workflow where users preview their video in the DOM, hit 'Save' to export an MP4 in their browser, and fallback to a server-side render for long-running background tasks—all using the same source code.

Portable VideoJSON: Your Video as Data

In VideoFlow, you don't write components; you use a fluent builder API to compile a portable VideoJSON document. This document is resolution-agnostic and contains every instruction needed to recreate the video. Because it's just JSON, you can store it in a database, diff it in Git, or even have an LLM generate it on the fly.

Here is how you build a cinematic scene with VideoFlow's core API:

import VideoFlow from '@videoflow/core';

const $ = new VideoFlow({ width: 1920, height: 1080, fps: 30 });

// Add a background image with a blur animation
const bg = $.addImage(
  { fit: 'cover', opacity: 0.8 },
  { source: 'https://example.com/background.jpg' }
);

bg.animate(
  { filterBlur: 0 },
  { filterBlur: 10 },
  { duration: '4s', wait: false }
);

// Add a title with a built-in transition
const title = $.addText(
  { text: 'Open Source Video', fontSize: 8, color: '#FF5A1F' },
  { transitionIn: { transition: 'blurResolve', duration: '800ms' } }
);

$.wait('3s');
title.fadeOut('500ms');

const json = await $.compile();

This snippet demonstrates the power of the VideoFlow builder API. You get 27 transition presets (like blurResolve, glitchResolve, and lightSweepReveal) and 42 GLSL effects out of the box, without having to write complex interpolation logic manually.

Built-in Cinematic Primitives

In many other programmatic video tools, creating high-end visual effects requires writing custom shaders or complex math. VideoFlow ships with professional-grade primitives as standard features. Whether you need blendMode: 'overlay', a vhsDistortion effect, or a typewriter transition, it's a single line of code.

This focus on "cinematic defaults" allows small teams to produce output that looks like it came from an After Effects studio, rather than a basic canvas script. For more on how to stack these, check out our guide on Mastering Cinematic Compositing: A Guide to VideoFlow BlendModes.

Licensing That Scales with You

While the core and renderers are Apache-2.0, we also offer the VideoFlow React Video Editor for teams that need a drop-in UI. It features a multi-track timeline, inspector, and keyframe support. Crucially, the editor is free for individuals, non-profits, and small teams (up to 3 employees), making it accessible to the indie hacker community while providing a clear commercial path for larger enterprises.

Conclusion: The Future of Programmatic Video

VideoFlow isn't just a Remotion alternative; it's a rethink of how video should be authored for the modern web. By prioritizing JSON portability, browser-native rendering, and an open-source core, we are building a toolkit that can power everything from personalized SaaS recaps to automated social media factories.

Ready to move beyond proprietary constraints? Visit our GitHub repository to see the source, or dive into the Getting Started guide to build your first video in minutes.