generate video

To generate a movie file using Rust that includes:

1. A directory of images (photo slideshow)

2. A soundtrack (e.g., MP3 or WAV)

3. Text overlays (lyrics and credits)

You can combine Rust with the power of FFmpeg (invoked via the command line) for media processing. Rust will handle orchestration: scanning the directory, building the command, and executing it.

Assumptions

Images are in pehotoshow/ directory

Audio file is named soundtrack.mp3

Lyrics/credits are in a text file (e.g., descriptions.txt)

Output file is final_video.mp4

Each image shows for 5 seconds

Dependencies

Add to Cargo.toml:



[dependencies]


walkdir = "2.4"


chrono = "0.4"


anyhow = "1.0"

Rust Code



use walkdir::WalkDir;


use std::fs;


use std::process::Command;


use std::path::Path;


use anyhow::{Result, Context};


use chrono::Local;

    fn main() -> Result<()> {

let image_dir = "photoshow";


let audio_file = "soundtrack.mp3";


let lyrics_file = "descriptions.txt";


let output_file = format!("final_video_{}.mp4", Local::now().format("%Y%m%d_%H%M%S"));


// Step 1: Get sorted list of image paths


let mut image_files: Vec7lt;_> = WalkDir::new(image_dir)


.min_depth(1)


.max_depth(1)


.into_iter()


.filter_map(|e| e.ok())


.filter(|e| e.path().is_file())


.filter(|e| {


if let Some(ext) = e.path().extension() {


matches!(ext.to_str(), Some("jpg" | "jpeg" | "png"))


} else {


false


}


})


.map(|e| e.path().to_path_buf())


.collect();


image_files.sort();


// Step 2: Copy and rename images to temp directory for ffmpeg


let temp_dir = "temp_images";


fs::create_dir_all(temp_dir).context("Creating temp image directory")?;


for (i, img) in image_files.iter().enumerate() {


let target = format!("{}/img{:03}.jpg", temp_dir, i);


fs::copy(img, &target).with_context(|| format!("Copying image {:?}", img))?;


}


// Step 3: Generate slideshow video without audio


let slideshow = "slideshow.mp4";


let image_duration = 5; // seconds per image


let ffmpeg_slideshow = Command::new("ffmpeg")


.args([


"-y",


"-framerate", &format!("1/{}", image_duration),


"-i", &format!("{}/img%03d.jpg", temp_dir),


"-c:v", "libx264",


"-r", "30",


"-pix_fmt", "yuv420p",


slideshow


])


.status()


.context("Generating slideshow video")?;


if !ffmpeg_slideshow.success() {


return Err(anyhow::anyhow!("FFmpeg failed on slideshow step"));


}


// Step 4: Add audio and text overlay (lyrics or credits)


let filtered_video = "filtered_video.mp4";


let text_overlay = build_drawtext_filter(lyrics_file)?;


let ffmpeg_filter = Command::new("ffmpeg")


.args([


"-y",


"-i", slideshow,


"-i", audio_file,


"-vf", &text_overlay,


"-shortest",


"-c:v", "libx264",


"-c:a", "aac",


"-strict", "-2",


&output_file


])


.status()


.context("Adding audio and text overlay")?;


if !ffmpeg_filter.success() {


return Err(anyhow::anyhow!("FFmpeg failed on final step"));


}


println!("Final video generated: {}", output_file);


Ok(())


}

	fn build_drawtext_filter(lyrics_path: &str) -> Result<String> {

let content = fs::read_to_string(lyrics_path).context("Reading lyrics file")?;


let lines: Vec<&str> = content.lines().collect();


// For simplicity, each line appears every 5 seconds


let mut filters = Vec::new();


for (i, line) in lines.iter().enumerate() {


let start = i as i32 * 5;


let end = start + 5;


let filter = format!(


"drawtext=fontfile=/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf:\


text='{}':\


fontsize=24:fontcolor=white:x=(w-text_w)/2:y=h-100:\


enable='between(t,{},{})'",


line.replace(":", "\\:").replace("'", "\\'"),


start,


end


);


filters.push(filter);


}


Ok(filters.join(","))


}

---

Requirements

ffmpeg must be installed and in your PATH

DejaVuSans-Bold.ttf or a compatible font must exist at the given location (or adjust the path)

---

Output

A slideshow video with:

Timed image transitions

Audio track

Subtitled lyrics or credits

---



[package]


name = "media_slideshow_generator"


version = "0.1.0"


edition = "2021"


[dependencies]


walkdir = "2.4"


chrono = "0.4"


anyhow = "1.0"

rust video generation standards

Use Rust to automate the creation of YouTube videos from images and text prompts.

Then upload those videos to YouTube; all via code. While this is not yet a mainstream approach, developers frustrated with the limitations of non-linear video editors are increasingly scripting video workflows using Rust for more control and automation.

Using Rust to Generate Videos

Rust is suitable for this task, although it usually leverages existing video tools rather than handling raw video encoding directly. A typical architecture involves:

Reading input data (images, captions, audio)

Calling external tools like ffmpeg or imagemagick via Rust's std::process::Command

Organizing assets: arranging the images, syncing audio, adding text overlays

Assembling the video with precise control over frame rate, resolution, transitions, etc.

For example, a Rust program can:

Convert and size images to 1920x1080 (16:9 YouTube standard)

Add captions/subtitles from a text file

Overlay music or narration

Compile the video using ffmpeg or gstreamer

These are powerful pipelines for procedural or prompt-based video generation.

Uploading to YouTube via Rust

To upload to YouTube automatically, you'll need to interact with the YouTube Data API v3, which is a Google API. Rust does not yet have a first-class YouTube API SDK like Python or JavaScript, but you can still access the API via:

REST API calls using libraries like reqwest

Handling OAuth2 using oauth2 or Google's yup-oauth2

The process generally involves:

Setting up a Google Cloud project and enabling the YouTube Data API

Creating OAuth2 client credentials for desktop or service account access

Authenticating with OAuth2 to get an access token

Making a POST request to https://www.googleapis.com/upload/youtube/v3/videos

Attaching the video file and metadata (title, description, tags, privacy status)

Special Account?

Yes, you need to:

Have a Google account with a YouTube channel

Enable the YouTube Data API in the Google Developer Console

Set up OAuth2 credentials

For automated (headless) uploads, your app must be authorized, and in some cases verified by Google if the usage exceeds certain quotas or is intended for third-party users

This process is more complex than simple GUI uploads but provides automation at scale.

Current Usage in the Wild

This approach is used by:

Content automation tools (e.g. news-to-video systems, podcast visualizers)

AI-based content creators (generating slideshow videos or narrated scripts)

Marketing automation pipelines

CLI developers looking to publish tutorials, timelapses, or music visualizations

The Rust ecosystem is still catching up in terms of libraries for multimedia generation and OAuth2 convenience, but it's perfectly viable with the right wrappers.

Summary of Generation Video

Task

Tools in Rust

Image processing

image crate, magick-rust, std::process::Command + imagemagick

Video rendering

Call ffmpeg via Command, or use gstreamer bindings

Audio integration

ffmpeg, rodio, or custom wav/mp3 muxing

YouTube upload

reqwest, serde_json, oauth2 crate, manual REST calls

rust use generative AI image-generation

to create an image from a prompt and associated graphic design style statement.


Here is a list of Rust crates used for video generation by category.

Rust Crates for Video Generation

Image and Media Processing
Audio Processing
Video Composition and Rendering
API Communication and Uploading
Async, Error Handling, and CLI

last updated: 2025-07-25

TOP | blog home