A live HLS manifest and a local FFmpeg concat list are different things. FFmpeg documents reload behaviour for needed live HLS playlists; the official material does not establish that an already-running process rereads an edited local concat-list file.
To change a product demo sequence while keeping YouTube Live connected, make the change at the input layer and leave the output connection configured. If you want a running FFmpeg process to follow playlist updates, test a live HLS workflow with your actual media and build before relying on it: reload support alone does not promise an interruption-free transition.
What “playlist” means in this setup
A playlist can describe a sequence of files on your computer, or it can be a live manifest that points a player or demuxer to media segments as they become available. Those are separate input designs, even if both are represented by text files and both are casually called playlists.
The FFmpeg concat demuxer reads a list of files as an input sequence. If your workflow uses a text file such as demo-list.txt, it is a local concat list. The list tells FFmpeg what inputs make up that sequence; it should not be treated as a live control panel that the running process is known to poll after every edit. The general FFmpeg documentation describes the concat demuxer, but the reviewed documentation does not establish a general hot-reload feature for its list file: FFmpeg’s documentation.
A live HLS input works differently. Its .m3u8 manifest refers to media segments and can be refreshed as the sequence develops. FFmpeg’s HLS demuxer implementation includes reload behaviour for needed live playlists. That is specific evidence for HLS, not evidence that a local concat text file behaves the same way: FFmpeg’s HLS demuxer source.
Before changing anything, identify the input named in the FFmpeg command or script. A local path to a concat list and a URL to an HLS manifest call for different expectations and different tests. If you inherited the setup, inspect the command, service configuration or launcher script rather than guessing from the fact that playback currently loops.
Keep the YouTube output connected
The output side is the FFmpeg connection to YouTube’s ingest service. YouTube describes the stream URL and stream key as the values used to connect an encoder to the live stream. Keep that destination configuration in place while you evaluate a different way of supplying the demo sequence; changing the input architecture is not, by itself, a reason to create a new live destination. See YouTube’s instructions for managing a live stream and its encoder setup guidance.
“Keep the output connected” does not mean that any source change will be invisible to viewers. It means you avoid deliberately stopping or replacing the YouTube output process as part of the planned input update. The source can still run short of segments, stall, change timestamp behaviour or present media the output cannot handle. The destination credentials can remain unchanged while the picture or sound has a problem.
For example, a shop might run a sequence of product demonstrations with a closing card between items. Updating the sequence is not just swapping filenames. The new clip must arrive in time, its audio and video must be usable by the pipeline, and its transition must be checked in the real stream. Keep a known-good sequence and a rollback plan available while you test the new one.
Understand live HLS playlist reloads
In a live HLS workflow, a producer publishes a manifest and media segments. FFmpeg reads the manifest and, for a needed live playlist, its HLS demuxer has a reload path that checks again and reparses the playlist. This is the documented behaviour that makes HLS a plausible input-layer design for a changing sequence.
The timing is not a universal schedule for every playlist. It depends on the playlist and FFmpeg implementation, including the version and build you are using. Nor does “reload” mean that a change will appear instantly at a chosen frame. FFmpeg needs the referenced media to be available, and the input, timestamps and output all need to work together.
A live manifest also depends on a publisher that updates it correctly. If a new entry is written before its segment is ready, the reader may not have usable media when it requests it. If the playlist retains old entries or removes them too soon, the transition can behave differently from the one you expected. The HLS input path is therefore a workflow to test, not a guarantee supplied by the word HLS.
If your product sequence is already produced as live HLS, or you can operate a publisher that makes a current manifest and valid segments available, point FFmpeg at that HLS input and test a controlled sequence change. If you only have a folder of finished video files and a local concat list, the HLS route introduces work: segmenting, publishing and checking the manifest. Decide whether that additional moving part is manageable before rebuilding a stable production setup.
Why editing a concat list may not reload
A plain local concat list is a description of inputs, not a documented live manifest protocol. The fact that the file can be edited while FFmpeg is running does not show that FFmpeg will revisit it, discard its existing read state or begin using the revised order. Do not infer those behaviours from the fact that HLS has a reload path.
A separate, version-specific test might establish what happens in your exact setup. Without that test, do not plan on changing the text file under a running process and assume the active playlist will change. An edit could affect a later run while the current process continues with what it has already opened or read. The reviewed official sources do not settle precisely what every version does in every circumstance, so avoid turning that possibility into a claim about guaranteed behaviour.
If you need to retain a local-file workflow, make the update at a boundary you can control: prepare a new list, validate it, then use a process changeover procedure that your own system has tested. Depending on how you run FFmpeg, that may involve starting a replacement process and carefully managing the output handover; it may also interrupt the broadcast. Do not attempt an untested replacement against a live stream merely because the list is short.
For a broader view of file sequencing, rotating playlists with a Python script is relevant to automated rotation, but it should not be read as proof of concat-list hot reload. Similarly, a Windows-based YouTube loop workflow can help you think through how a local setup is operated; the input type and update behaviour still need to be established for your own command.
Choose an input-layer update workflow
Choose the least complex workflow that solves the actual change you need. The comparison below focuses on what the evidence supports, what you must provide and what remains to test.
| Workflow | What it does | What is supported | Main trade-off |
|---|---|---|---|
| Edit a local concat list while FFmpeg runs | Changes the text file used to describe a file sequence | No general in-place reload behaviour is established by the reviewed official material | Do not rely on the active process seeing the edit without a version-specific test |
| Publish a live HLS manifest and segments | Gives FFmpeg a live playlist input to refresh | The HLS demuxer has reload behaviour for needed live playlists | Requires a working publisher and validation of segment timing, media and transitions |
| Replace or restart the input process under a planned procedure | Applies a prepared local sequence at a controlled changeover | Operationally possible only to the extent your particular output handover has been tested | It may cause a visible or audible break; do not promise continuity |
If you choose HLS, make the producer’s responsibilities explicit. It should publish segments that correspond to the intended demo order, update the manifest consistently and leave referenced media available when FFmpeg needs it. Keep the existing YouTube output settings stable during the input test so that a source-side fault is not confused with a destination change.
If you choose a local list, treat any live update technique as a test hypothesis until demonstrated on the exact FFmpeg version and build, operating system, media formats and launch method you will use. Record what happens when you add, remove and reorder entries. Observe whether the running process changes sequence, whether audio remains continuous, and whether YouTube receives a stable output. A result on one setup is not automatically a result for another.
A product loop may also include a manually selected “featured demo” that changes more often than the rest. Separate that editorial decision from the media mechanics: decide who changes the order, who checks the source files, and who can restore the previous sequence. A Raspberry Pi FFmpeg setup guide may be useful if that is your platform, but the device guide cannot answer whether your running input reloads a particular list.
Test changes before relying on them
Test the real change path before using it in a public session. YouTube Help recommends testing ahead of a live stream and says tests should include audio and movement in the video similar to what you will stream. That is useful here because a static title card can conceal a timing problem that becomes obvious when a moving product demonstration begins. Use the current YouTube encoder settings guidance for the output profile you actually intend to send.
Build a rehearsal around the failure you are trying to avoid. Start with the current sequence, make one representative playlist change, then watch what FFmpeg reads and what YouTube’s preview receives. Include a clip with motion, a clip with speech or music if your stream has audio, and the type of transition viewers will see. Check the beginning and end of each segment as well as the point where the order changes.
Use the same FFmpeg binary and launch mechanism in the test as in production. A command run interactively may not behave like a scheduled task or service with different working directories, permissions or environment. Note the version and build, input format, manifest or list location, and the exact change made. That gives you a useful record if the result differs on another machine or after an upgrade.
Do not test only whether the playlist file changed on disk. Confirm whether the running input follows it, whether the intended segment appears, whether there is a gap or repeated material, and whether audio remains in sync. If you cannot verify those points, use a workflow with an explicit, rehearsed changeover rather than treating an unobserved edit as safe.
Where your setup uses a local machine for other tasks, avoid relying on an operator remembering to keep that machine awake or logged in during an overnight stream. For an uploaded-file workflow where the recurring pain is leaving a computer running, StreamNeo can take an uploaded video and run it as a YouTube live stream without keeping your computer on; it does not change the need to prepare and test a playlist update, and it is YouTube-only.
Verify the stream after updates
During a rehearsal and any live change, use YouTube Live Control Room to check the preview and stream health. The preview shows whether the intended picture is arriving; stream health helps identify delivery problems. YouTube’s live stream troubleshooting guidance is a sensible reference when the preview or health status indicates trouble. Do not treat a healthy indicator as proof that the sequence is editorially correct or that viewers hear the intended audio.
Watch the transition itself. Confirm the product demo order, check that the first frame of a new item is not a frozen or unintended frame, and listen for a missing, duplicated or unexpectedly loud audio passage. If you can, monitor the public playback path as well as the encoder preview, since a local preview and what reaches a viewer are not identical checks.
If a change fails, return to the known-good input plan rather than making several untracked edits at once. Record the time, what changed, what FFmpeg reported, and what Live Control Room showed. Preserve the YouTube output configuration while you diagnose the source path, unless the output itself is the fault. This separation makes it easier to identify whether the issue lies in the manifest or list, the media, timestamps, encoder or ingest connection.
A reliable 24/7 channel is maintained through repeatable checks, not a one-time successful test. If your stream also has a local-source buffering issue, the separate guide on why a local sermon video can still buffer explains why a file being on the same machine does not settle every delivery question. Here too, validate the whole path rather than assuming the source format tells you everything.
For a longer-running channel, keep a change log and an owner for playlist edits. Note which sequence is live, where its source files or segments are maintained, and how the previous version can be restored. This is particularly helpful when one person prepares the demos and another person watches the channel overnight. It gives the operator a known response if the new item does not appear as expected.
Before committing, compare the operating options on the pricing page. When the file and channel are ready, start free — 24-hour trial, no card.
FAQ
Can I edit a local concat list while FFmpeg is live?
You can edit the file, but the reviewed official material does not establish that an already-running FFmpeg process will reread it. Do not depend on an update until you have tested it with your exact FFmpeg version, build and launch method.
Does an HLS manifest reload mean the picture will change immediately?
No. FFmpeg’s HLS demuxer has reload behaviour for needed live playlists, but segment availability, timing, timestamps and media compatibility affect when and how a transition appears. Test the actual sequence rather than treating reload support as a promise of gapless playback.
Do I need to replace my YouTube stream key to update the sequence?
An input change does not in itself require a different destination configuration. YouTube uses the stream URL and key to connect the encoder to its ingest feed, but preserving them does not make an untested source transition seamless.
What should I check before making a playlist change live?
Rehearse the same update with representative movement and audio, using the production FFmpeg build and launch path. Check the intended order, transition, sound, YouTube preview and stream health, and keep a known-good sequence ready to restore.