An LRC file is a plain UTF-8 text file in which each lyric line is preceded by a bracketed timestamp in [mm:ss.xx] form, such as [01:23.45]Example line, so a music player can show each line as the song reaches that moment. Producing one from raw lyrics requires a centisecond-precision start time, a fixed interval between successive lines, optional title, artist, and album tags, and a way to save the resulting .lrc file beside the audio. The LRC File Generator handles that workflow in your browser: it parses the start timestamp, converts the interval to integer centiseconds, and emits a preview that matches the downloaded file exactly. Because the format is a de-facto family rather than an official standard, players differ in how they parse the same file, so the generator sticks to that simple subset.
What an LRC file actually contains
Each LRC file is a single text document with a small header section for metadata and a larger body where every lyric line is preceded by one bracketed timestamp. A line timestamp has two or three minute digits, exactly two second digits from 00 through 59, a period, and exactly two centisecond digits, which gives one hundredth-of-a-second resolution. According to the QuickLRC reference for the LRC file format, this bracketed-then-text form is the de-facto simple LRC subset. A typical line reads [02:14.67]Every road leads back to you, and the minutes value, the seconds value, and the two centisecond digits together describe exactly when that line should appear.
Metadata is optional and lives at the top of the file inside square-bracketed tags of the form [tag:value]. Common tags include [ti:] for the song title, [ar:] for the artist, and [al:] for the album, and different players recognize different tags. Blank metadata fields are typically omitted from the output, and a blank line usually separates the header from the timed lyrics for readability.
The format is intentionally minimal. There is no audio embedded inside the file, no styling, and no per-player extensions required; the player's job is to compare each timestamp to the current playback position and render the matching lyric line.
Inputs the LRC File Generator accepts
The generator takes four sets of inputs and applies one deterministic rule to them. None of the inputs are uploaded anywhere; the page reads them, formats them, and offers the result for local download.
First, you provide the lyric lines. The field accepts between 1 and 500 non-empty lines and up to 50,000 characters in total, with at most 500 characters on a single line. Each row becomes one display event in the finished file. Windows (CRLF), old Mac (CR), and Unix (LF) line endings are all normalized, and blank rows are removed before any timestamps are calculated. The text inside each line is preserved exactly as typed: spelling, punctuation, capitalization, language, and any embedded copyright notices stay untouched.
Second, you set a start timestamp in [MM:SS.xx] form. The minutes field uses two or three digits, the seconds field uses exactly two digits between 00 and 59, and the centisecond field uses exactly two digits. Valid examples include 00:00.00, 09:59.99, 10:00.00, and 123:45.67; the product supports timestamps through 999:59.99.
Third, you choose an interval between 0.01 and 600.00 seconds with no more than two decimal places. That value is converted to an integer number of centiseconds before any rows are produced, so adding the interval to the start time over hundreds of lines does not accumulate binary floating-point drift.
Fourth, you can optionally add title, artist, and album values. Each field is trimmed, limited to 120 characters, and cannot contain square brackets or control characters, which prevents one field from injecting a stray LRC tag or line. Empty fields are omitted entirely.
Build the LRC file in the generator
- Open the LRC File Generator in your browser.
- Paste or type one lyric line per row into the lyrics field. Use a separate line for every display event you want in the finished file, whether that is a single word, a phrase, a verse line, or a chorus line. Leave out numbering, decoration, or speaker labels; whatever you type becomes the literal text the player shows.
- Enter the start timestamp in [MM:SS.xx] form, such as 00:12.34 for the first line you want to display at twelve and thirty-four hundredths of a second into the song.
- Set the interval to the average gap you expect between successive lyric lines, expressed in seconds with up to two decimal places. A value such as 2.50 means each subsequent line will be timed 250 centiseconds after the previous one.
- Fill in the title, artist, and album fields only if you want [ti:], [ar:], and [al:] metadata tags in the output. Leave any of these blank to omit that tag entirely.
- Generate the preview. The generator now walks through every preserved lyric line, adds the interval in integer centiseconds for each step, and renders the complete file as a single block of text. Editing any input after this point clears the previous preview.
- Inspect the first and last timestamps in the preview. If the last timestamp would land past 999:59.99, generation fails and nothing is silently truncated; reduce the line count, lower the start time, or shrink the interval until the final value fits.
- Download the .lrc file. The download is the exact preview text saved as UTF-8 without a byte-order mark, with a filename derived from your title (unsafe punctuation becomes hyphens) or synced-lyrics.lrc when no title is set.
- Open the downloaded file next to your recording and retime individual lines in your music player or a dedicated lyrics editor. The fixed interval is only a starting draft and rarely matches real vocal timing.
Reading the preview and checking the timestamp math
Because the interval is converted to integer centiseconds before any timestamps are added, the preview is reproducible: the same start time, interval, and line count will always produce the same sequence. A worked example helps make this concrete.
If your start timestamp is 00:12.34 (1234 centiseconds) and your interval is 2.50 seconds (250 centiseconds), the first three preserved lines are stamped 00:12.34, 00:14.84, and 00:17.34. The arithmetic runs in centiseconds: 1234 + 250 = 1484 centiseconds for line two, and 1484 + 250 = 1734 centiseconds for line three, which the generator then renders back into [mm:ss.xx] form. Because the addition happens in integers, no binary floating-point drift accumulates across hundreds of lines.
The table below lists what counts as a valid start timestamp for this tool. Anything outside these patterns is rejected before any lyric row is processed.
| Input | Accepted? | Reason |
|---|---|---|
| 00:00.00 | Yes | Two minute digits, two second digits, two centisecond digits |
| 09:59.99 | Yes | Last legal second is 59 |
| 10:00.00 | Yes | Two minute digits allowed, seconds reset to 00 |
| 123:45.67 | Yes | Three minute digits, within the 999:59.99 ceiling |
| 1:02.30 | No | Minutes must be two or three digits, not one |
| 12:60.00 | No | Seconds must be 00 through 59 |
| 00:12.3 | No | Centiseconds must be exactly two digits |
If the last calculated timestamp would exceed 999:59.99, generation fails outright rather than silently truncating, which is why the preview check before download matters.
What the generator deliberately leaves out
The product implements the widely used simple LRC subset rather than claiming a formal universal standard. Knowing what is intentionally omitted helps you decide whether the output matches your target player before you invest time in a manual edit pass. The independent Subforge LRC time implementation confirms the centisecond math used here, and the table below summarizes which features the generator emits and which it does not.
| Feature | Emitted? | Notes |
|---|---|---|
| Simple [mm:ss.xx] line timestamps | Yes | Two or three minute digits, two centisecond digits |
| Optional [ti:], [ar:], [al:] tags | Yes | Only when each metadata field is non-empty |
| UTF-8 encoding without byte-order mark | Yes | Matches the preview text exactly |
| Hour fields ([hh:mm:ss.xx]) | No | Minute-only form throughout |
| Colon-separated frame digits | No | Centisecond field is fixed at two digits |
| Three-digit millisecond precision | No | Two fractional digits only |
| Enhanced word-level timestamps | No | One timestamp per line, no inline markup |
| Karaoke duet markers | No | No dual-channel timing |
| Player-specific extensions | No | Generic simple LRC only |
The generator also does not listen to audio, detect speech, transcribe lyrics, align phonemes, identify beats, or estimate performance timing. Each line gets the same interval added on, no matter how the vocalist actually sings it. Treat the output as a deterministic draft and adjust individual lines against the recording in a dedicated editor before publishing or sharing the file.
Download, filename, and encoding details
When you click Download, the page saves the exact text shown in the preview as a UTF-8 file with an .lrc extension. No byte-order mark is added, which avoids a BOM prefix that some players reject.
The filename is derived from your title field when one is present. Unsafe filename punctuation such as slashes, colons, asterisks, or question marks is replaced with hyphens, and an empty title falls back to synced-lyrics.lrc. Temporary download object URLs are revoked after the download fires and when the component unmounts, so an older file cannot remain presented as the result of newer preview text.
The preview and the download are guaranteed to be the same string. Editing any input clears the previous preview, and temporary download object URLs are revoked, so an older file cannot remain presented as the result of newer text.
Adjust timestamps against your real recording
The fixed interval produces a mathematically clean draft, but real vocals rarely begin at perfectly equal spacing. Open the downloaded .lrc file in a dedicated editor or in the lyrics panel of your music player, play the recording, and nudge each timestamp forward or backward until the line changes when the singer reaches the word. This is the step that turns a draft into a usable lyrics file.
Different players support different metadata tags, timestamp precision, encodings, long minute values, and enhanced-LRC extensions. Always test the file in the player you actually use. If a line fails to appear, a tag is ignored, or a long minute value is misread, the issue sits in the player, not in the simple LRC subset the generator emits. If you plan to use the file alongside an MP3 on the same device, this guide on getting an LRC file to load with your local MP3s covers naming, placement, and player recognition.
The generator does not supply copyrighted lyrics, search a catalog, identify a song, confirm ownership, or grant a synchronization license. You are responsible for having permission to reproduce and distribute whatever text you paste into the field. The page simply formats user-provided text in your browser, with no lyric upload, account storage, or AI service involved.