LeronX Engine: The Open-Source Core of an AI Video Generation Pipeline

What Is Included and What Is Not

LeronX Engine describes itself as the open-source core of LeronX Pro, a commercial video creation platform. The README is explicit about the split: several modules are open source and several are proprietary.

Open-source modules: - leronx.script: Script generation and storyboard planning. - leronx.scenes: Scene graph, transitions, and shot composition. - leronx.voice: TTS abstraction layer with a plugin-based design. - leronx.render: FFmpeg pipeline with hardware acceleration configuration. - leronx.subtitles: Subtitle generation, styling, and timing in SRT, ASS, and VTT formats. - leronx.assets: Stock footage API client for Pexels and Pixabay. - leronx.plugins: Plugin loader and registry.

Proprietary modules (not in this repository): - leronx.cloud: Distributed rendering cluster. - leronx.auth: Firebase authentication with phone verification. - leronx.billing: Stripe credits system. - leronx.desktop: Electron or Tauri desktop application.

This distinction matters for anyone evaluating the project for self-hosted production use. A deployment that needs cloud rendering or user authentication must build or source those components separately. The repository itself contains only the pipeline engine; the broader product UI, user management, and distributed infrastructure are not available here.

Architecture: Script to Video in Four Stages

The Pipeline class orchestrates four sequential stages: script generation, scene planning, voice synthesis, and video rendering.

Script generation takes a topic, duration in seconds, tone, and language as configuration. The ScriptConfig class captures those inputs. Internally, the script module generates a storyboard plan alongside the text. The storyboard planning logic lives in src/leronx/script/storyboard.py.

Scene planning breaks the script into a scene graph with shot composition rules. The scenes module manages transitions between scenes and applies composition guidelines from src/leronx/scenes/composition.py.

Voice synthesis uses a TTS abstraction layer. The voice module supports 11 audio languages according to the README, with emotion control. Different TTS providers are swapped in through the plugin system rather than hard-coded. The base abstraction class is in src/leronx/voice/tts_base.py, with provider implementations in tts_engines.py.

Rendering uses FFmpeg to assemble the final video from scenes, voice tracks, and overlaid subtitles. GPU acceleration is available through CUDA (NVIDIA) and Metal (Apple Silicon) when the relevant PyTorch extras are installed.

Installing and Running the Basic Pipeline

Prerequisites are Python 3.10 or newer and FFmpeg 5.0 or newer. FFmpeg must be installed separately and available on the system PATH.

git clone https://github.com/leronx/leronx-engine.git
cd leronx-engine
pip install -e ".[dev]"

A minimal pipeline run:

from leronx import Pipeline
from leronx.script import ScriptConfig

config = ScriptConfig(
    topic="The Future of AI in Healthcare",
    duration=60,
    tone="professional",
    language="en",
)

pipeline = Pipeline(config)
video = pipeline.render(output_path="./output/my_video.mp4")

The Docker path starts the backend API on port 8000:

docker-compose up -d

The pyproject.toml base dependencies are httpx>=0.25.0, pydantic>=2.0, and rich>=13.0. GPU acceleration requires the gpu extras (torch>=2.0, numpy>=1.24), which are not installed by the default pip install.

The Plugin System and Extending the Pipeline

Every stage of the pipeline can be extended through the plugin system. A plugin declares its name, the stage it hooks into (script, scenes, voice, render, or post), and a numeric priority that controls execution order within a stage. Lower priority numbers run first.

from leronx import Pipeline, Plugin

class BrandedOverlay(Plugin):
    name = "branded_overlay"
    stage = "post_render"

    def process(self, video, config):
        video.add_overlay(
            image="assets/leronx_logo.png",
            position="bottom-right",
            opacity=0.8,
        )
        return video

pipeline = Pipeline(
    config=RenderConfig(gpu=True, codec="h265"),
    plugins=[BrandedOverlay()],
)

Plugins are passed to the Pipeline constructor as a list. The plugin loader and registry are in the open-source leronx.plugins module. Plugin cleanup logic runs when the pipeline finishes. The examples/ directory includes with_plugins.py showing a complete plugin integration example alongside single_job.py for a bare pipeline run.

Benchmark Numbers and GPU Requirements

The README includes a rendering benchmark table for a reference set of video durations and hardware configurations:

- RTX 4090: 45 seconds for a 60-second video, 90 seconds for 120-second, 4 minutes for 300-second. - RTX 3080: 72 seconds, 145 seconds, 6 minutes. - M2 Max: 58 seconds, 115 seconds, 5 minutes. - CPU only: 8 minutes, 16 minutes, 40 minutes.

These figures are from the README and apply to the benchmark conditions described there. The README does not specify the FFmpeg codec, resolution, or other rendering parameters used to produce them. CPU-only rendering is supported but significantly slower than GPU-accelerated paths.

Limitations and Project Boundaries

The most significant limitation is the proprietary split. The distributed rendering cluster that LeronX Pro uses for fast cloud rendering is not open source. A self-hosted instance using only the open modules will render locally with the FFmpeg pipeline, which is slower and subject to local hardware constraints.

The repository has no GitHub releases. The last push was on 2026-07-01. The pyproject.toml marks the development status as Beta.

The README benchmarks numbers without specifying full conditions: the codec, resolution, and input content type are not documented alongside the timing figures, which makes them difficult to reproduce or validate independently.

The pyproject.toml base dependencies are httpx, pydantic, and rich. None of the AI model libraries are mandatory runtime dependencies; the script generation module presumably calls an external LLM API over httpx, though the README does not document which API or which credentials are required for that stage. Teams evaluating self-hosted deployment will need to trace the script generation and TTS dependencies through the source.

For developers who want a fully open-source video generation pipeline with no proprietary split, MoviePy provides a Python API over FFmpeg with no commercial tier. The difference in approach is that MoviePy is a lower-level editing library focused on assembly and effects, while LeronX Engine adds AI script generation, scene planning, and TTS as integrated stages. A team that already has scripts and voice tracks will find MoviePy more direct; a team that wants to go from a topic description to a rendered video in one call will find LeronX Engine's pipeline a more complete starting point.

Editorial conclusion

LeronX Engine is for developers who want to build video generation tooling on top of a modular Python pipeline and are comfortable working with an engine core rather than a complete application. The cloud rendering cluster, authentication, billing, and desktop application modules are proprietary, so self-hosted use is limited to the open-source components. Verify that ffmpeg 5.0 or newer is installed and that your use case does not require the leronx.cloud or leronx.desktop modules before committing to this codebase.

Frequently asked questions

Official sources

1. Issues
2. Leron-X/leronx on GitHub
3. License: MIT
4. README