What an SRT file actually is
An SRT file is not a special video format or a proprietary container — it's a plain text file with a specific, predictable structure. Open one in Notepad and you'll see exactly what your video player sees: a sequence of numbered blocks, each with a start time, an end time, and the line of text to display in between.
That simplicity is exactly why it's still the most widely supported subtitle format nearly two decades after it first appeared. Every major video player, every editing suite, and every streaming upload form accepts .srt without a plugin.
The anatomy of a single cue
Every subtitle entry, or "cue," follows the same four-line pattern:
00:00:14,200 --> 00:00:16,800
You're not seeing the whole picture.
2
00:00:16,900 --> 00:00:18,500
Neither are you — that's the point.
Four things have to be exactly right for a player to parse this correctly:
- A sequence number — starts at 1 and increments for every cue. Players use this to keep cues in order.
- A timecode line in
HH:MM:SS,mmm --> HH:MM:SS,mmmformat — hours, minutes, seconds, and milliseconds separated by a comma, not a period. - One or more lines of text — most players cap readable subtitles at two lines, roughly 42 characters per line.
- A blank line separating this cue from the next one. Miss this and most parsers merge two cues into one broken block.
Writing one by hand
Because it's plain text, you technically don't need any tool beyond a text editor to create an SRT file:
- Open a plain text editor (Notepad, TextEdit in plain-text mode, or any code editor).
- Type your first cue following the four-line pattern above.
- Leave exactly one blank line, then type the next cue with the sequence number incremented by one.
- Repeat for every line of dialogue.
- Save the file with a .srt extension, using UTF-8 encoding without a byte-order mark.
Writing the structure by hand is easy. Getting the timing right by hand is the hard part — guessing "00:00:16,900" without watching the video against a waveform means constant trial-and-error exporting, reloading, and nudging numbers by a few hundred milliseconds at a time.
The mistakes that actually break playback
Most "my subtitles won't show up" problems trace back to one of these:
| Symptom | Usual cause |
|---|---|
| File doesn't appear as an option at all | Wrong file extension, or a `.txt` saved as `.srt` without actually renaming it |
| Only the first cue shows | Missing blank line between cues merges everything after it into one block |
| Subtitles are consistently early or late | A global timing offset — the whole track needs to shift, not individual lines |
| Special characters show as garbled symbols | File saved in the wrong encoding (should be UTF-8) |
| Player silently rejects the file | A stray byte-order mark at the very start of the file |
Timing rules that make subtitles feel professional
Getting the format right makes a subtitle file work. These conventions are what make it feel polished:
- Minimum display duration: keep even short lines on screen for at least ~1 second — anything faster reads as a flicker.
- Reading speed: aim for roughly 15–17 characters per second of screen time so viewers can actually finish reading before the cue changes.
- No overlaps: one cue's end time should never be later than the next cue's start time — overlapping cues render unpredictably depending on the player.
- Small gaps between cues: a 1–2 frame gap between consecutive cues avoids a "stuck" flicker effect some players introduce during instantaneous cue changes.
- Line length: two lines max, ~42 characters per line, to avoid overflowing the safe area on smaller screens.
Skip the manual math. Time cues against the actual video, catch overlaps automatically, and export a clean .srt — free, in your browser.
Open the editor →A faster way: timing cues against the real video
The format itself takes five minutes to learn. What takes real time is timing — watching playback, marking exactly when a line starts and ends, and fixing the inevitable overlap between two cues that seemed fine in isolation.
A browser-based editor like SRT Creator handles the parts that are tedious by hand: it captures the current video position as a start or end time with one click, flags overlapping or out-of-sequence cues automatically, and exports a standards-compliant .srt file when you're done — all without uploading the video anywhere or creating an account.
For a one-off subtitle or two, a text editor is fine. For anything with more than a handful of lines, timing against the actual video is the difference between minutes and hours.
Frequently asked questions
What does SRT stand for?
SubRip Subtitle, named after the SubRip software originally used to rip subtitle streams from DVDs. You don't need SubRip or a DVD to make one today — it's just a plain text format.
Can I create an SRT file in a plain text editor?
Yes. Notepad, TextEdit, or any code editor works, since it's just UTF-8 text. The hard part is timing each cue against the video, which is where a browser-based editor with a live preview saves the most time.
Why won't my SRT file show up in my video player?
Check, in order: the file extension is actually .srt, there's a blank line between every cue, the arrow is exactly -->, and the file was saved as UTF-8 without a byte-order mark.
What's the difference between SRT and VTT?
They're structurally similar. VTT (WebVTT) is the web standard for HTML5 video and supports more styling options, while SRT is the older, simpler format that the widest range of players and editing software accept. Most tools convert freely between the two.