A simple LRC file is plain text in which every lyric line is preceded by a bracketed timestamp such as [01:23.45]Example line, and an LRC file generator is the utility that produces that file for you from a list of lyric lines, a starting timestamp, and a fixed interval between lines. Most readers arrive here because they want synced lyrics to scroll beside an audio file in their music player, and they want a deterministic way to build the file without uploading audio or relying on a service that listens to their track. A modern browser-based generator runs entirely in the current tab: you type one lyric line per row, set the first [mm:ss.xx] timestamp and a 0.01–600.00 second interval, optionally add title, artist, and album tags, and the tool emits the exact text of a UTF-8 .lrc file that you can download locally. The fixed interval is treated as a draft, not a final timing: vocals rarely begin at perfectly equal spacing, so the file is meant to be opened in a dedicated editor and retuned against the actual recording. This article walks through what a generator does internally, how the timestamp arithmetic actually works, and exactly how to use it to produce a working synced lyrics file.
What an LRC File Generator Actually Produces
The output of an LRC file generator is a single UTF-8 text file with the .lrc extension. Inside it, every timed lyric line is written as [mm:ss.xx] followed immediately by the lyric text — a strict, de-facto pattern rather than a formal standard. The QuickLRC reference describes this as the most widely supported subset, and independent parsers like Subforge confirm the arithmetic: minutes contribute sixty thousand milliseconds, seconds contribute one thousand, and the two digits after the period represent centiseconds. The optional metadata fields at the top — title ([ti:…]), artist ([ar:…]), and album ([al:…]) — are emitted only when filled, and a blank line separates them from the timed lyrics for readability. The generator keeps the lyric text untouched: it does not rewrite spelling, punctuation, capitalization, language, or copyright notices inside ordinary lyric lines. It also writes the file without a byte-order mark, so older players that expect plain ASCII will not choke on the first character. This is the contract: a deterministic, narrow output built around a small set of validated inputs. Outside that contract, behaviour is the player's job — and that is by design, because no two music players interpret LRC identically.
The Timestamp Format and Why Centiseconds Matter
A valid timestamp in this subset contains two or three minute digits, exactly two second digits from 00 through 59, a period, and exactly two centisecond digits. Valid examples include 00:00.00, 09:59.99, 10:00.00, and 123:45.67. The generator supports timestamps up to 999:59.99 but does not emit an hour field, colon-separated frames, three-digit milliseconds, word-level angle-bracket timestamps, karaoke duet markers, or any player-specific extensions. That narrow scope is what makes the file portable across players — it never includes anything the parser cannot recognize.
Centiseconds matter because they are the smallest unit that survives the format's two-decimal rule. A 100th-of-a-second resolution is more than enough granularity for a single vocal line, and the parser arithmetic is exact integer math at every step: minutes × 60000 + seconds × 1000 + centiseconds. By contrast, decimal seconds — values like 2.50 — would lose precision if added thousands of times in floating point. The generator sidesteps that entirely by converting the interval to integer centiseconds once, before any rows are produced.
The table below shows the four official timestamp examples with their underlying integer-millisecond value.
| Displayed timestamp | Minutes | Seconds | Centiseconds | Total milliseconds |
|---|---|---|---|---|
| 00:00.00 | 0 | 0 | 0 | 0 |
| 09:59.99 | 9 | 59 | 99 | 599,990 |
| 10:00.00 | 10 | 0 | 0 | 600,000 |
| 123:45.67 | 123 | 45 | 67 | 7,425,670 |
The arithmetic in the rightmost column follows the formula minutes × 60000 + seconds × 1000 + centiseconds — the same formula used by independent parsers such as Subforge's LRC time implementation.
How the Interval Arithmetic Works
The interval field accepts any decimal from 0.01 to 600.00 seconds with no more than two decimal places. Internally, that decimal is converted to an integer number of centiseconds before any rows are produced. So a 2.50-second interval becomes exactly 250 centiseconds, a 0.01-second interval becomes exactly 1 centisecond, and a 12.34-second interval becomes 1234 centiseconds. From that point on, every successive line is placed by adding the centisecond value to the previous line's centisecond total — no decimal arithmetic is ever repeated across the run.
Take a starting timestamp of 00:12.34 (which is 1234 centiseconds) and an interval of 2.50 seconds (250 centiseconds). The first three timed lines become:
Line 1: 1234 + 0 × 250 = 1234 centiseconds → 00:12.34 Line 2: 1234 + 1 × 250 = 1484 centiseconds → 00:14.84 Line 3: 1234 + 2 × 250 = 1734 centiseconds → 00:17.34
That is the exact output the generator will produce for the first three rows. Because the running total is integer math, repeated addition does not accumulate binary floating-point drift, even over hundreds of lines. If the final calculated timestamp would exceed 999:59.99, generation fails and the file is not silently truncated — a hard guarantee rather than a soft warning. This matters because a player that reads a malformed final timestamp may treat the rest of the file as out-of-sync.
If you want a different effective cadence without redoing the math, the practical move is to lower or raise the interval slightly, regenerate, and use the new file as your next draft.
How to Use the LRC File Generator Step by Step
The LRC File Generator runs entirely in the current browser tab, so lyric text never leaves your device. The workflow is short and linear.
- Open the generator and paste up to 500 non-empty lyric lines into the lyrics field, putting one display line per row (up to 50,000 total input characters and 500 characters on a single line). Windows, old Mac, and Unix line endings are all accepted; they are normalized before generation, and blank rows are removed.
- Set the first timestamp in MM:SS.xx form (for example, 00:12.34). The field requires two or three minute digits, two second digits from 00 to 59, a period, and exactly two centisecond digits.
- Enter the interval between successive lines in seconds, between 0.01 and 600.00, with up to two decimal places. The value is converted to integer centiseconds before any rows are produced.
- Optionally fill in the title, artist, and album fields. Each becomes a [ti:…], [ar:…], or [al:…] tag; each is trimmed, capped at 120 characters, and rejects square brackets or control characters so a single field cannot inject an extra LRC tag. Empty fields are omitted from the file.
- Read the preview, which shows the exact text that will be saved. Inspect the first and last timestamps to confirm the run fits within 999:59.99 and matches the song length.
- Click Download to save the file. The download is a UTF-8 text file with the .lrc extension, named after the title when present (unsafe filename punctuation becomes hyphens) or synced-lyrics.lrc when no title is set. Editing any input clears the previous preview, so the downloaded file is always identical to the preview you just approved.
For the underlying interval-and-start-time math used in step 3, see how to make an LRC file with a start time and interval. After download, open the file beside the actual recording and adjust individual timestamps in a dedicated LRC editor — the generator is a draft engine, not a finisher.
What the Generator Deliberately Does Not Do
The narrow contract is intentional, and several capabilities are out of scope. The tool does not listen to audio, detect speech, transcribe lyrics, align phonemes, identify beats, or estimate performance timing. It also does not supply copyrighted lyrics, search a catalog, identify a song, confirm ownership, or grant a synchronization license. Lyric text remains the user's responsibility — both for permission to reproduce it and for the spelling inside it.
There are also format choices the generator declines. It will not emit hour fields, three-digit milliseconds, enhanced-LRC angle-bracket word timing, karaoke duet markers, or any player-specific extension. It will not silently truncate a final timestamp that exceeds 999:59.99. It will not insert control characters or stray bracket pairs that could be reinterpreted as extra LRC tags by a parser. And it will not upload your lyrics to a server, save them to an account, or send them to an AI service — every input and every calculation stays in the current tab. The reliable contract is intentionally small: validate the de-facto centisecond timestamp subset, convert a bounded decimal interval to exact centiseconds, preserve bounded lyric text, emit only optional ti/ar/al tags, show the complete untruncated file, and download the exact preview.
Player Compatibility and Why You Should Always Test
Different music players support different metadata tags, timestamp precision, encodings, long minute values, and enhanced-LRC extensions. A file that scrolls perfectly in one player may be ignored entirely by another, or parsed with metadata tags stripped. The generator cannot guarantee identical interpretation across players because that guarantee does not exist in any single place — players choose what to implement, and LRC has no formal standard body to enforce a common denominator.
The practical habit is simple: load the downloaded file into the player you actually use, scrub through the song, and confirm that metadata tags appear where expected and that timestamps fall within the player's supported range. If a player rejects long minute values above 99:59.99, retime the affected lines to fit. If the player treats [ti:…] as a literal lyric, drop the title tag. The generator's job ends at producing a portable, conservative subset — anything beyond that subset is the player's call.
This is also why the file is best treated as a draft. Real vocals rarely begin at perfectly equal spacing; a fixed interval gives a workable starting point but rarely matches the actual performance. Once the previewed text is saved, open it in a dedicated editor and nudge individual timestamps until they sit beside the right syllable.