The easiest way to customize your Plex server and let your ridiculous creativity run wild.
You don’t need a complicated workflow, expensive software, or hours of editing to get started. Sometimes all it takes is an idea, your phone, and a willingness to make something completely absurd.
Make one. Share it. Let’s see what you come up with.
What happens when the cable guy discovers you already canceled cable… because you use Plex? 😏
This one was too perfect not to make. The whole joke is watching his confidence completely collapse the second he realizes there’s an entire Plex library sitting right in front of him.
Another movie-parody preroll from the rotation on my personal server.
Workflow: AI-assisted generation + editing/post-production
Format: 16:9 cinematic preroll
As always, feedback and remix ideas are welcome.
Upscaling can make a low-resolution pre-roll look cleaner on a large TV, but it cannot perfectly restore details that were never present. AI tools estimate new detail, so stronger settings do not always produce a better result.
Don't expect magic results like this.
For most pre-rolls, 1080p is the sweet spot. A 4K export creates a larger file and takes longer to process, but it may not look noticeably better.
Make a copy of your original video and check its resolution.
Common resolutions:
A good rule is to upscale one reasonable step:
Keep the original aspect ratio and frame rate. Upscaling resolution and converting a video to 60 FPS are separate processes.
This is the option I would recommend to most beginners. It is paid, but the interface is straightforward.
If the result looks waxy or unnaturally sharp, reduce the enhancement strength or try a less aggressive model. Always judge the moving preview—not just a single frame.
Topaz has an official beginner quick-start guide.
Super Scale is included in the paid Studio version of DaVinci Resolve.
Super Scale can be demanding, so processing may be slow. Resolve 20 also offers enhanced 3x and 4x modes, but bigger is not automatically better. Blackmagic’s Resolve 20 guide describes the current Super Scale options.
Video2X is a free, open-source option with a graphical installer on Windows and support for Linux. It uses models including Real-ESRGAN and Real-CUGAN.
Video2X is the best free choice for people willing to experiment, but its options can be more intimidating than Topaz.
HandBrake can enlarge the video frame, but it does not reconstruct detail like an AI upscaler. Your TV may already perform a similar resize during playback.
Use this when you mainly need a standard 1080p file or better Plex compatibility.
HandBrake itself notes that ordinary upscaling is generally not recommended because it does not add real detail. See its resizing documentation.
For the widest compatibility across Plex clients, use:
Plex notes that MP4, H.264, and AAC are broadly supported for Direct Play, although exact support still depends on the playback device. See Plex’s Smart TV format guide.
The result looks plastic or painted
The denoise or sharpening is too strong. Reduce it and make another preview.
Text changes shape or flickers
AI models sometimes struggle with small text and logos. Try a gentler model or use ordinary resizing.
The file is 4K but does not look better
A larger resolution does not guarantee more detail. Try a clean 1080p version instead.
Plex starts transcoding it
Check that the file is MP4 with H.264 video and AAC audio. Also check whether its resolution, bitrate, or frame rate exceeds what the playback device supports.
For a 720p pre-roll, upscale it to 1080p using Topaz Proteus on Auto or Video2X with Real-ESRGAN at 2x. Preview it carefully, keep the original frame rate, and export an MP4.
This one turned into a bit of a monster.
The goal was to put characters from completely different visual mediums into the same Plex preroll — modern 2D cel animation, vintage 2D animation, polished 3D animation, and a practical-puppet look — while keeping each one visually distinct.
About 16 hours of generation, troubleshooting, reference work, editing, and a bunch of preproduction later… here it is.
The biggest lesson was that trying to make MiniMax direct the entire thing in one giant prompt was a disaster. Breaking it into individual shots, locking the environment with reference images, and only giving the model what it needed for each shot made a huge difference.
And yes, the XXXXXL tidy-whiteys are the projection screen. 😄
The KJNodes MiniMax Live Preview node I posted about earlier was also extremely useful while working through this one.
If anyone wants a deeper tutorial, what would be most useful: mixed-media character consistency, reference-image blocking, or the scene-by-scene MiniMax workflow?
One of the more useful little additions I’ve made to my MiniMax H3 workflow is KJNodes' Model Preview Override.
Instead of staring at a progress bar and hoping MiniMax understood your prompt, this node gives you a live look at the video while the sampler is still working.
MiniMax H3 renders can take a while. If the character is already facing the wrong direction, the composition has gone completely sideways, or your carefully planned scene has decided to become interpretive dance, you can spot it early and cancel the render.
It doesn't change the generation. It just lets you see what MiniMax is doing while it's doing it.
For video models, KJNodes can preview a single frame or several frames as an animated preview.
The node is part of ComfyUI-KJNodes by Kijai:
https://github.com/kijai/ComfyUI-KJNodes
The easy method is through ComfyUI Manager. Search for:
KJNodes for ComfyUI
Install it and restart ComfyUI.
You can also manually clone the KJNodes repository into your:
ComfyUI/custom_nodes/
folder and install its requirements. That's the installation method documented by Kijai.
Search for:
Model Preview Override
Then insert it directly into your MODEL connection before the sampler:
Model Loader → Model Preview Override → Sampler
That's it.
Whatever MODEL cable was going into your sampler now goes into Model Preview Override, and the MODEL output from the preview node continues on to your sampler. The node simply wraps the model with the preview function.
For a basic setup, you can pretty much leave the defaults alone.
Preview Frames = 1 gives you a single updating frame and has the least overhead.
Increase Preview Frames if you want an animated glimpse of the video as it develops. You can also control the preview FPS and maximum preview resolution.
There is also a Tiny VAE option. Compatible Tiny VAE files go in:
ComfyUI/models/vae_approx/
and can then be selected directly in the node. This produces a more recognizable RGB preview without having to perform a full VAE decode every sampling step.
It's not glamorous, and it doesn't magically make MiniMax generate better video.
What it does do is keep you from wasting a full render on something that was obviously going wrong several steps ago.
And when you're experimenting with AI Plex prerolls, catching the train wreck before it reaches the station is a feature. 😁
Sometimes you don’t need a full cinematic preroll or an elaborate movie parody. Sometimes a simple, clean logo stinger is all it takes to give your Plex server that polished “feature presentation” feel before the movie drops.
This one is built around the modern Plex logo, with a quick geometric fold-and-assemble animation and sharp sound design. Short, clean, and out of the way; just enough branding to make the transition into the movie feel intentional.
I’ve built a lot of these network-style IDs over my career, but with today’s technology you can customize, experiment, and try out new ideas faster than ever before. No Maya, 3D Studio Max, or Cinema 4D required. They look great alongside the bigger themed prerolls on my server.
If you’ve made your own Plex logo stinger, bumper, or ident, share it with the community. I’d love to see the different styles people come up with.
Here’s a fun example of a pre-roll in progress. The knight’s voice definitely needs some work; maybe a raspier, older, more rugged tone. That’s where ADR comes in, along with other tools. I might even just use my own voice. 😂 There’s AI for this too, but sometimes it’s quicker to cut it in Adobe Premiere and Audition and record your own edits when aiming for perfection.
The Minimax H3 tutorial post covers how this was created.
Some of you have been experimenting with AI-generated Plex prerolls, and asked that I put together a simple walkthrough for anyone who sees these videos and thinks, "That looks cool, but I have absolutely no idea how they're making it."
For this example, I wanted to make a short preroll that looked like a black-and-white 1920s rubber-hose cartoon. Think old theatrical cartoons: Steamboat Mickey with stretchy arms and legs, exaggerated movement, simple backgrounds, film grain, and goofy sound effects.
The final gag is that two characters aboard a little tugboat are fighting over the controls until somebody realizes Plex is working. They rush inside, the Plex logo appears on an ancient television, and the logo becomes the preroll.
The basic workflow is:
That's really it.
This is probably the most important thing to understand about AI video.
Don't write a movie.
You're making a tiny visual joke.
My basic idea was:
A happy cartoon sailor is wildly steering a tugboat.
Another sailor gets angry, kicks him away from the wheel and yells:
"Get the TV working so we can watch Plex!"
A moment later he hears a "ding."
They both rush into the cabin.
The Plex logo appears on the television.
"Oh boy!"
Plex logo.
That's enough story for a preroll.
Even that turned out to be quite a lot to ask an AI video generator to accomplish in ten seconds.
You can technically generate video entirely from text, but I've had much better results creating still images first.
The still images become something like storyboards.
For this project I created reference images for:
You can make these images with ChatGPT, Gemini, Midjourney, Flux, Stable Diffusion, or whatever image generator you prefer.
The important part is consistency.
If Character #1 has a white sailor hat, black shirt and giant round nose in the first image, try to maintain that design in every other reference image.
AI video generators are much better at maintaining a character when you give them something concrete to look at.
Think of your images as instructions:
<image 1> = this is what Character A looks like.
<image 2> = this is what the room looks like.
<image 3> = this is the camera angle I want.
That distinction becomes extremely important later.
For this video I used MiniMax H3 with reference images.
One feature I particularly like is that you can directly refer to uploaded images inside your prompt.
For example:
Use <image 1> for CHARACTER A.
Use <image 2> for the wheelhouse environment.
Use <image 5> for the living quarters.
This is MUCH better than simply uploading six images and saying:
"Make a video based on these."
Tell the model what each image is actually for.
One of the lessons I learned making this preroll is that AI models don't necessarily understand that an image is only supposed to become relevant later in the video.
If you upload a picture of a colorful Plex logo, for example, the model knows that bright yellow/orange object is important.
It may decide to use that visual information somewhere you never intended.
In one of my early generations, my innocent little Plex cartoon suddenly developed what looked like an orange flamethrower followed by an explosion.
That was definitely not in the script.
Don't write prompts like:
"The first guy pushes the other guy and then he grabs his wheel while he kicks him."
Humans can usually figure out what that means.
AI can get confused very quickly.
Instead define them:
CHARACTER A = sailor from <image 1>
CHARACTER B = sailor from <image 4>
Then write:
CHARACTER B pushes CHARACTER A away from the wheel.
CHARACTER B kicks CHARACTER A.
CHARACTER A flies out of frame.
CHARACTER B takes control of the wheel.
It seems repetitive, but that's exactly what you want.
You're not writing beautiful prose.
You're directing a very enthusiastic animator who occasionally has the attention span of a caffeinated squirrel.
My first instinct was to describe everything happening during each time range.
Something like:
0:02–0:05 — The character enters, argues, waves his arms, pushes the first character, kicks him, pumps his fist, grabs the wheel, turns around and delivers a line of dialogue.
That's too much.
Three seconds is nothing.
The AI starts combining actions instead of performing them sequentially.
A better structure looks like this:
0:02–0:03
Character B enters and angrily waves his arms.
0:03–0:04
Character B pushes Character A and kicks him out of frame.
0:04–0:05
Character B grabs the wheel and speaks.
Those tiny timing instructions give the model a much clearer sequence of events.
This sounds silly until you start generating AI video.
Negative instructions can be incredibly useful.
For this cartoon I eventually added things such as:
NO fire.
NO explosions.
NO sparks.
NO lasers.
Do not create additional characters.
Do not change their clothing.
Do not transform the ship's wheel.
Do not show the living quarters before 7 seconds.
Why specify things that aren't in the script?
Because generative video works through associations.
Words such as "glowing," combined with an orange logo reference, might lead the model toward sparks or fire.
A character being "kicked out of frame" might cause him to magically disappear before the foot even touches him.
A camera transition might cause the entire environment to morph into the next scene.
Once you see a generation do something stupid, don't just regenerate the exact same prompt.
Add an instruction specifically preventing that behavior.
This one bit me.
I originally described the Plex logo as appearing on the television and then "morphing" into the full-color Plex logo.
To a human, that's pretty obvious.
To generative AI, "morph" basically means:
"Please invent whatever bizarre transformation you think looks interesting between these two things."
Instead I changed it to:
The Plex logo expands directly forward from the television screen until it fills the frame.
This is a simple 2D graphic zoom.
Do not morph the room.
Do not transform the television.
Much better.
Words matter.
This was another important discovery.
The entire cartoon was supposed to be black and white until the very last moment, when the familiar Plex color appears.
But I had supplied the generator with a full-color Plex logo as one of the reference images.
The generator apparently decided:
"Yellow/orange must be important!"
And started leaking that color into earlier parts of the animation.
The solution was simple.
Create a black-and-white Plex logo reference for the AI video generation.
Then instruct the model:
At the end, change the logo to the normal Plex orange/yellow.
The AI already knows what orange looks like.
It doesn't need a brightly colored reference image influencing every frame of your black-and-white cartoon.
This is probably the biggest misconception people have about AI video.
You usually don't type one magical prompt and receive a finished commercial.
Think of the first generation as a rough cut.
Watch it and ask:
What worked?
What didn't?
Did the character stay consistent?
Did the camera do what I wanted?
Did an action happen too early?
Did the AI skip something?
Did someone's arm suddenly become six feet long?
In my case, most of the revised preroll worked beautifully, but I wasn't happy with the kicking gag.
So I didn't regenerate the entire ten-second video.
I generated only the kicking shot again.
The replacement prompt basically said:
ONE continuous medium-wide shot.
CHARACTER B pushes CHARACTER A.
CHARACTER B performs ONE exaggerated cartoon kick.
His foot clearly makes contact with CHARACTER A's backside.
CHARACTER A does not disappear before the kick connects.
CHARACTER A stretches and flies out of frame.
That last instruction was there because AI video models have a habit of anticipating the result.
Tell it that someone is going to be kicked out of frame and sometimes the poor guy starts flying away before anyone actually kicks him.
The corrected generation worked.
I simply replaced the bad shot with the better one.
This is where AI video starts becoming dramatically more useful.
Don't think:
"I need AI to generate my entire finished video perfectly."
Think:
"I need AI to generate usable shots."
If you have:
keep the opening and ending.
Regenerate the middle.
Put them together in DaVinci Resolve, Premiere Pro, Final Cut, CapCut, or whatever editor you already use.
You can also handle things like the Plex logo transition in your editor instead of trusting the AI to reproduce a corporate logo perfectly.
In many cases that's actually the better approach.
The successful prompt was much more structured than my original one.
Instead of one giant paragraph, it established:
STYLE
1920s black-and-white rubber-hose animation.
CHARACTERS
Character A always comes from one reference image.
Character B always comes from another reference image.
REFERENCE IMAGE ROLES
Each uploaded picture has exactly one purpose.
SHOT 1
Specific actions.
SHOT 2
Specific actions.
SHOT 3
Specific actions.
SHOT 4
Specific actions.
AUDIO
Music, voices and sound effects.
RESTRICTIONS
Things the model absolutely should not create.
That structure made an enormous difference.
No.
If you're just getting started, I wouldn't begin there.
Services such as MiniMax, Google Veo/Flow and similar hosted AI video platforms are considerably easier because most of the technical work is handled for you.
Upload your images.
Write your prompt.
Generate.
Download the result and edit it.
That's enough to start making some surprisingly impressive prerolls.
ComfyUI is where things get interesting for people who want much more control.
It allows you to build your own generation workflow using different image models, video models, ControlNet-style guidance, LoRAs, upscalers, frame interpolation and other tools.
The downside is that you're essentially building your own AI production pipeline.
It's incredibly powerful, but there is absolutely no reason somebody needs to understand nodes, checkpoints, VRAM or samplers just to make their first Plex preroll.
Start simple.
You can always fall down the ComfyUI rabbit hole later.
AI video prompting isn't really about writing the longest or most descriptive prompt.
It's about removing ambiguity.
Instead of:
"Make the sailor angrily take over the boat."
Describe what the camera actually sees:
Character B enters from the right.
Character B raises both arms.
Character B pushes Character A.
Character B kicks Character A once.
Character A flies out of frame to the right.
Character B grabs the wheel.
That's basically directing.
And once you start thinking in individual shots instead of trying to make AI understand an entire movie scene, the results improve dramatically.
We're at a pretty fun point with this technology.
You don't need an animation studio to make a ten-second custom bumper for your Plex server anymore.
You can sketch out a ridiculous idea, generate a few reference images, animate them, fix the parts that go off the rails, and have something completely unique playing before movie night.
And sometimes the AI will randomly give a 1920s cartoon sailor a flamethrower.
Consider that part of the creative process.
If you've seen some of the AI-generated Plex prerolls posted here and thought, “Okay, how the hell are people making these?”, this guide is for you.
The good news is that you do not need to know anything about AI, programming, animation, or visual effects to get started.
At its simplest, you type what you want to see into an AI video generator, wait for it to create the clip, trim it in a video editor, add your Plex logo, and you're done.
At the other end of the spectrum, you can run AI models locally on your own computer using tools such as ComfyUI, giving you considerably more control.
I'm going to explain both.
If you've never generated AI video before, this is where I'd start.
Google has an AI filmmaking application called Flow, which uses Google's Veo video-generation models. You describe a shot using ordinary English and Veo attempts to create it for you.
Current versions of Flow support things such as text-to-video, image-to-video, reference images, first/last frames, audio generation and different aspect ratios depending on the selected Veo model. (blog.google)
Think of it as:
You describe a tiny movie scene → AI shoots the scene.
The biggest beginner mistake is trying to make an entire movie in eight seconds.
Don't.
A preroll works best as one joke or one small scene.
For example:
>A nervous man is hiding in an outdoor bathroom. Something enormous approaches outside. He looks toward the camera and says, “I should have stayed home and made it a Plex night.”
That's it.
You don't need three locations, fourteen characters, an explosion, a helicopter and a complicated backstory.
AI video works much better when you give it one clear thing to accomplish.
You don't need special AI vocabulary.
Describe the scene like you're explaining it to a camera crew.
A useful formula is:
SHOT + LOCATION + CHARACTER + ACTION + DIALOGUE + ENDING
For example:
>Cinematic realistic movie scene at night. Medium close-up of a frightened man sitting inside an old wooden roadside bathroom. The building shakes as something enormous approaches outside. Dust falls from the ceiling. He looks terrified, slowly turns toward the camera and says, “I should have made it a Plex night.” Immediately afterward, a huge creature crashes through the wall behind him. Realistic Hollywood lighting, dramatic sound design, no subtitles, no text on screen.
Notice how specific that is.
Instead of:
>Dinosaur attacks guy.
You're telling the AI:
Google itself recommends giving Flow detailed information about the subject and action rather than relying entirely on short prompts. (blog.google)
In Google Flow, create a project and select the appropriate video-generation option.
For your first experiment, Text to Video is perfectly fine.
Paste in your prompt and generate.
And here's something you'll learn VERY quickly:
You might get something fantastic on the first try.
You might get a guy whose arm suddenly passes through his forehead.
Generate several versions.
Don't endlessly rewrite a perfectly good prompt because one generation failed. Sometimes the next generation using exactly the same prompt comes out dramatically better.
This is where AI prerolls start getting much more interesting.
Instead of asking AI to invent the entire scene, create the first frame yourself.
You can create that image using whatever image generator you prefer.
Then give that picture to Flow using Frames to Video / image-to-video and tell Veo what should happen next.
Google's Frames to Video feature is specifically designed around providing a starting image; and some modes can use both a starting and ending frame, to give you much more control over composition. (blog.google)
This is extremely useful for prerolls.
Your workflow becomes:
Create still image → Animate still image → Edit video → Add Plex ending
For example, you could first create the perfect image of your character sitting in a car.
Then tell the video generator:
>The character notices something terrifying through the windshield. His smile disappears. He slowly looks toward the camera and says…
You've already locked in the character, wardrobe, location and camera angle with the image.
The AI only has to figure out the movement.
Once you get comfortable, stop trying to generate your entire preroll as one video.
Generate shots.
For example:
Shot 1 — 3 seconds
Wide shot of the approaching danger.
Shot 2 — 4 seconds
Close-up of character delivering Plex joke.
Shot 3 — 2 seconds
Chaos.
Shot 4 — 2 seconds
Plex logo.
Put them together in an editor.
This is much closer to how actual filmmaking works, and it gives you dramatically more control.
Flow also includes tools for keeping assets consistent between shots and building multiple clips into scenes. Google's current Flow system can use reference “ingredients,” starting frames and other existing material when constructing additional shots. (blog.google)
You don't need sophisticated editing software.
Use whatever you're comfortable with:
DaVinci Resolve
Adobe Premiere
Final Cut
CapCut
Vegas
etc.
This is where I recommend adding things such as:
Plex logo
Music
Sound effects
Exact timing
Title cards
Final dialogue adjustments
Fades or cuts
I generally would not rely on the AI generator to create your Plex logo.
Generate the movie scene and add the real logo afterward.
You'll get a much cleaner result.
Keep prerolls short. Personally, I think roughly 5–15 seconds is the sweet spot for most ideas.
Remember: you're going to see this thing every time you start a movie.
A 45-second masterpiece stops being a masterpiece around viewing #37. 😂
Once you understand image-to-video, reference images become incredibly powerful.
Instead of describing:
>A middle-aged man with a brown jacket…
you can give the AI an image showing exactly what you mean.
Flow calls reusable visual references Ingredients. They can represent characters, objects or stylistic references and can be carried into generated scenes. (blog.google)
This is useful when your preroll has:
You're essentially telling the AI:
“This. I want THIS thing in the video.”
Instead of hoping it understands your description.
Okay.
Now we're entering the rabbit hole.
ComfyUI is an open-source, node-based interface for running generative AI workflows. Instead of one giant GENERATE button, ComfyUI lets you connect individual pieces of the generation process together. (ComfyUI)
It looks intimidating the first time you open it.
Boxes everywhere.
Lines everywhere.
Numbers everywhere.
Don't panic.
You do not need to understand all of it.
Think of a ComfyUI workflow like a home theater receiver.
There are a million settings available.
That doesn't mean you need to adjust all of them.
They're called nodes.
Each node performs a job.
One might load an AI model.
Another contains your prompt.
Another loads your starting image.
Another controls how the video is generated.
Another saves the finished video.
The lines simply pass information from one node to another.
Very simplified:
MODEL
↓
YOUR PROMPT
↓
STARTING IMAGE
↓
VIDEO GENERATION
↓
SAVE VIDEO
That is essentially what you're looking at.
ComfyUI can run locally on Windows, macOS and Linux, and there is now also an official cloud option. (ComfyUI)
Local generation means the AI model runs on your GPU instead of Google's computers.
The big advantage:
You're not paying for every individual generation.
The big disadvantage:
Your computer has to actually run the model.
AI video models can require substantial GPU memory, and requirements vary enormously depending upon the particular model, resolution and workflow.
If you're running an NVIDIA gaming GPU, you're probably going to find plenty to experiment with.
DO NOT START WITH AN EMPTY WORKFLOW.
Seriously.
Don't open ComfyUI and think:
>Okay, apparently I need to build one of these node diagrams.
You don't.
ComfyUI includes a Template Library containing working generation workflows.
Load one.
For example, current official ComfyUI documentation includes ready-made video workflows for models such as LTX-2.3 and Wan2.2. (ComfyUI)
With supported templates, ComfyUI can also identify models that your workflow requires and guide you through obtaining missing components. (ComfyUI)
So your first experience can basically be:
Open ComfyUI
↓
Templates
↓
Video
↓
Choose a workflow
↓
Download required models
↓
Change the prompt
↓
Generate
That's dramatically less frightening than what a screenshot of ComfyUI makes it look like.
Once you've got it working, here's a very practical way to create prerolls.
Generate a high-quality still showing exactly where the shot should begin.
Get the:
camera angle
character
wardrobe
lighting
location
props
right BEFORE worrying about animation.
Open a video template designed for image-to-video generation.
You'll normally find a node where you can load your image.
Drop your starting frame there.
There may be a bunch of nodes you don't understand.
Ignore them.
Find the one containing the text prompt.
Change it.
Describe movement, not just appearance.
If your starting image already shows a man sitting in a car, you don't need three paragraphs explaining that he's sitting in a car.
Tell the video model what happens:
>The man suddenly notices something outside the windshield. His expression changes from relaxed to terrified. He slowly leans backward while staring forward. The camera gently pushes toward his face.
That's the important part.
In ComfyUI this is normally called Queueing the workflow.
The nodes will light up as ComfyUI works its way through the pipeline.
Eventually you'll get a video.
Congratulations.
You just generated AI video locally.
Eventually you can start modifying the workflow itself.
You can:
This is why people become addicted to ComfyUI.
Eventually you aren't just using an AI generator.
You're building your own AI production pipeline.
ComfyUI-generated images can contain the workflow information used to make them.
That means someone can sometimes give you a generated ComfyUI image and you can drag that image into ComfyUI to reconstruct the workflow that created it. Workflows can also be exported and shared as JSON files. (ComfyUI)
This is fantastic for a community like this.
If somebody develops a great Plex preroll workflow, they can potentially share:
the video
the prompt
the starting frame
the workflow
and other people can experiment with it.
There are two approaches.
Some current AI video systems can generate dialogue, environmental audio and sound effects directly with the video.
Veo supports native audio generation, and current Flow/Veo implementations include audio in several video-generation modes. (blog.google)
Some local ComfyUI video models also support audio/video generation; for example, the official LTX-2.3 workflow supports audio as part of its generation capabilities. (ComfyUI)
This is still frequently the better choice.
Generate the visuals.
Then add:
dialogue
sound effects
music
Plex sound/logo sting
in your editor.
It gives you much more control.
Your first result probably won't be perfect.
Neither will your second.
That's normal.
The workflow is:
Generate → Watch → Identify what sucks → Change ONE thing → Generate again.
Don't change twelve things simultaneously.
If the camera movement is wrong, fix the camera movement.
If the character is wrong, fix the character.
If the timing is wrong, fix the timing.
Eventually you'll hit one where you say:
“Holy crap. That's the one.”
Save it.
Once you've exported your finished video, place the file somewhere your Plex Media Server can access.
In Plex Media Server, the Movie pre-roll video setting allows you to specify the full path to your video file.
Plex also supports multiple prerolls.
Separate filenames with commas and Plex will play them sequentially.
Separate filenames with semicolons and Plex will randomly choose one.
For example:
Halloween.mp4;Jurassic.mp4;Christmas.mp4;Alien.mp4
That gives you a rotating collection of prerolls instead of seeing the same one every night. Plex notes that Cinema Trailers must be enabled for the preroll feature to play. (Plex Support)
And that's where this becomes addictive.
One preroll becomes five.
Five becomes twenty.
And eventually you're spending Saturday afternoon making an AI-generated movie character complain that they should have stayed home and watched Plex instead of dealing with whatever horrible situation you've put them in.
Which is basically why this subreddit exists. 😂
If you've never done any of this:
Start with Google Flow/Veo.
Learn how prompting works.
Then try:
Text-to-Video → Image-to-Video → Multiple Shots → Editing
Once you understand those concepts, try ComfyUI.
Don't worry about understanding every node.
Grab an existing workflow and start changing things.
That's how most of us learn this stuff.
And most importantly:
They don't have to be perfect.
Share the preroll.
Share what generator you used.
Share your prompt if you want.
Share your ComfyUI workflow if you're comfortable doing so.
And if something went completely hilariously wrong during generation...
Post that too.
Sometimes the failed AI generations are better than the actual preroll.
Welcome to r/PlexPrerollStudio.
Now go make something ridiculous.
Another one for my movie-parody Plex preroll rotation. This one was especially fun to put together. Enjoy! 😄 Feedback and remix ideas welcome. Download by right clicking on the video and selecting save as.
A Plex-night spin on one of the most permanently traumatizing highway scenes of the 2000s. 😄
This preroll riffs on the infamous logging-truck sequence from Final Destination 2, turning that moment of impending disaster into a very good reason to stay home, fire up Plex, and avoid driving behind anything carrying timber.
Created as part of my growing collection of movie-inspired Plex prerolls for random playback before films.
Format: 16:9
Style: Cinematic movie parody
Workflow: AI-assisted generation + editing/post-production
Feedback, alternate punchlines, and remix ideas are always welcome. You can download by right clicking on the video player and saving.
Hope you all make it a Plex night. Enjoy. Happy to discuss work flows on how you can create this yourself.
I like to keep my pre-rolls short, under fifteen seconds, so viewers can get to the content quickly. Keep making it a Plex night folks!
This is a community for people who enjoy making their Plex experience a little more cinematic. Share finished prerolls, works in progress, downloads, prompts, editing techniques, animation, sound design, and production workflows.
Shoot it. Animate it. Edit it. Generate it. Composite it. Mix all of the above. We care about what you create and helping each other make it better.
Constructive criticism is encouraged. Endless arguments over whether someone’s chosen production tool is legitimate are not.
Create something cool. Share it. Make the next Plex night better.
Workflow: github.com/Comfy-Org/workflow_templates/blob/main/templates/video_minimax_h3_r2v.json
Used multiple reference images for each scene.
Prompt For Multi Character:
subject_definitions:
<Subject 1> is [CHARACTER 1] from <Picture 1>, preserving the visual identity, costume, proportions, accessories, and visual style shown in the reference image.
<Subject 2> is [CHARACTER 2] from <Picture 2>, preserving the visual identity, costume, proportions, accessories, and visual style shown in the reference image.
<Subject 3> is [CHARACTER 3] from <Picture 3>, preserving the visual identity, costume, proportions, accessories, and visual style shown in the reference image.
summary:
[reference generation] A 5-second cinematic multiverse portal arrival. Three characters emerge from a consistent amber-orange portal and take a calm, confident formation.
retention_analysis:
<Subject 1> (appears in [Shot 1]): fully_preserved - retains the identity, costume, proportions, accessories, and visual style shown in <Picture 1>.
<Subject 2> (appears in [Shot 1]): fully_preserved - retains the identity, costume, proportions, accessories, and visual style shown in <Picture 2>.
<Subject 3> (appears in [Shot 1]): fully_preserved - retains the identity, costume, proportions, accessories, and visual style shown in <Picture 3>.
detailed_description:
A 5-second cinematic portal-arrival scene at dusk. One stable medium three-shot, framed from the knees up. No dialogue, no combat, no wide landscape, no camera movement, and no crowd.
Portal continuity: a large circular amber-orange portal stands behind the characters. It has a bright rotating outer ring, a darker transparent centre, floating gold sparks, gentle smoke, and a low resonant hum. Keep its colour, size, brightness, particle density, and rotation speed consistent across every portal-arrival clip.
[Shot 1] <Subject 1> steps through the portal first and takes the centre position with quiet confidence. <Subject 2> emerges on one side, naturally adjusts or lowers any item they are carrying if applicable, then gives a focused glance toward the unseen distance. <Subject 3> walks through last, takes position on the opposite side, and calmly surveys the scene. The three hold a poised, united stance as the portal flickers and golden particles drift around them. Their expressions and body language remain confident and appropriate to their individual character identities.
overall_soundscape:
Low portal hum, soft wind, subtle movement from clothing or equipment, and drifting golden sparks. No speech.
non_diegetic_music:
A restrained cinematic rise builds across the shot and resolves on a calm, confident note.
Prompt For single characters:
subject_definitions:
<Subject 1> is [CHARACTER] from <Picture 1>, preserving the visual identity, costume, proportions, accessories, and visual style shown in the reference image.
summary:
[reference generation] A 5-second cinematic multiverse portal arrival. One character walks through a consistent amber-orange portal, then takes a confident action stance with a subtle grin.
retention_analysis:
<Subject 1> (appears in [Shot 1] and [Shot 2]): fully_preserved - retains the identity, costume, proportions, accessories, and visual style shown in <Picture 1>.
detailed_description:
A 5-second cinematic portal-arrival scene at dusk. No dialogue, no crowd, no wide landscape, and no combat.
Portal continuity: a large circular amber-orange portal stands behind <Subject 1>. It has a bright fiery rotating outer ring, a darker transparent centre, floating gold sparks, gentle smoke, and a low resonant hum. Keep its colour, size, brightness, particle density, and rotation speed consistent across every portal-arrival clip.
[Shot 1] Medium knee-up shot. <Subject 1> walks steadily through the portal toward the camera, then comes to a composed stop. Their costume, silhouette, movement style, and any character-specific accessories remain fully consistent with <Picture 1>. Golden sparks drift around them as the portal flickers behind.
[Shot 2] Close-up of <Subject 1>. They shift into a distinctive, character-appropriate action stance, looking directly ahead with calm confidence. Their expression changes into a subtle smile and restrained grin. Keep the movement natural and controlled, with no exaggerated facial distortion. The portal remains softly visible and out of focus in the background.
overall_soundscape:
Low portal hum, soft wind, subtle movement from clothing or equipment, and drifting golden sparks. No speech.
non_diegetic_music:
A restrained cinematic rise builds through the entrance and resolves as <Subject 1> holds the final stance.
