# Chord grids

> Chart a song as bars and chords, no lyrics. Write grids the simple chordsheet.com way or with the full ChordPro grid environment: split bars, repeats, endings, strums, and how the two forms convert.

Source: https://fretlist.com/docs/grids

A chord grid charts a song as a row of bars, with a chord in each, and no lyrics underneath. It is how you write an intro, a turnaround, a jazz head, or a whole instrumental: the shape of the tune at a glance, aligned so the barlines line up down the page.

Fretlist reads grids two ways, and both draw the same chart. In **Chords over Lyrics** you use the compact [chordsheet.com](https://www.chordsheet.com) style, where a space is all that separates one bar from the next. In **ChordPro** you use the full `{start_of_grid}` environment, which spells out every beat. This page starts with the simple style, then the full one, then how they convert.

## The simple way: a `[Grid]` block

In Chords over Lyrics, open a grid with `[Grid]` on its own line and list the bars below it. Separate bars with a space; each chord is one bar:

```
[Grid]
C F Am G
```

Give the grid a heading with `label`, exactly like a `[Verse]` or `[Chorus]` section:

```
[Grid label="Chorus"]
C F Am G
```

The block ends at the first blank line, so a grid and the section after it stay separate.

### Two chords in one bar

Glue chords together with an underscore to split a bar between them (a "split bar"), each taking half:

```
[Grid]
Dm7_G7 Cmaj7 Am7 D7
```

Use a tilde instead when both chords land on the same beat. They share one slot rather than dividing the bar:

```
[Grid]
A~D Cmaj7 Am7 D7
```

### Repeats

Wrap bars in parentheses to repeat them. `|:` and `:|` work the same way:

```
[Grid]
(C F Am G)
```

Add a play count right after the closing bracket, `3x` or `x3`, to say how many times:

```
[Grid]
(C F Am G)3x
```

### A double barline

Two pipes mark a heavier division, like the end of a section:

```
[Grid]
A B || C D
```

### A note in the grid

Start a line with `-` to put a note between the rows, handy for a "repeat to fade" or a section cue. `;` keeps its spacing exactly, `:` and `=` mark section titles, and `#` works too:

```
[Grid]
C F Am G
- Solo
Am7 D7 Gmaj7 Gmaj7
```

A bare `-` on its own line just adds a little breathing room between rows.

### An empty bar, or a bar that repeats the last one

Write `*` for a bar you have not worked out yet. Write `%` to repeat the bar before it, or `%%` to repeat the two before it:

```
[Grid]
C F Am G
C % Am *
```

### A label or a note beside a row

A floating title sits on its own line and attaches to the row **below** it. Start it with `<-` to label that row on the left, or `>-` to annotate it on the right:

```
[Grid]
<- Intro
C F Am G
>- second time arpeggiate
Am7 D7 Gmaj7 Gmaj7
```

## The full way: `{start_of_grid}`

In the ChordPro tab, a grid is an environment between `{start_of_grid}` and `{end_of_grid}`. Here a bar is written with real barlines, `|`, and every beat gets a slot. A dot, `.`, is a beat with no new chord:

```
{start_of_grid}
| C . . . | F . G . | Am7 . F . | Dm . . . |
{end_of_grid}
```

This is the form to reach for when the rhythm matters: it places each chord on its beat, and the shared beat count keeps the barlines aligned down every row even when the rows split their beats differently.

A few marks earn their keep here:

- **`~`** packs two chords into one beat: `F~G`.
- **`%`** repeats the previous bar.
- **`|1` … `:|2`** open first and second endings (voltas).
- **`shape="1+4x2+1"`** sets the geometry the rows align to. It reads `left + measures x beats + right`, so that one is: one cell of left margin, four measures of two beats, one cell of right margin.
- **Words outside the bars** label the row. Anything before the opening `|` sits in the left margin, so `A |: C . | F G :|` labels that row `A`. Anything after the closing `|` sits in the right margin, so `| C . | G . | Fade` marks that row `Fade`.

Labels are how the example below gets its `A` and its `Volta 1`. If you would rather not crowd the row, write the same text on its own line with `<- text` for the left margin or `>- text` for the right, exactly as in the simple form. Both spellings land in the same place, so use whichever reads better:

```
{start_of_grid}
<- Verse
|: C . G . | Am . Fmaj7 . :|
>- play twice
{end_of_grid}
```

A floating title normally attaches to the row **below** it. Write one as the last line of the grid, though, and it attaches to the row above instead, so you can annotate a row you have just finished writing.

```
{start_of_grid label="Outro" shape="1+4x2+1"}
A |: C . | F G | Am7 F | Dm . :|
Volta 1 |1 C7 . | C . :|
Volta 2 |2 G7 . | C . |
{end_of_grid}
```

### More about `shape`

Every part of a shape is optional except the middle:

| Written | Means |
| --- | --- |
| `4x4` | Four measures of four beats. No margins declared. |
| `16` | Sixteen beats in one measure. |
| `1+4x4+1` | The same four-by-four, with one cell of margin on each side. |
| `2+4x4` | A double-width left margin, nothing declared on the right. |

The margin numbers are how much room a row's labels get. Raise the left number and the label column gets proportionally wider, which is worth doing when your labels are words like `Instrumental` rather than a letter. Set one to `0` to close that side up. A label you have actually written is never hidden, so a `0` on a side you are using is simply ignored.

Leave `shape` off a later grid and it reuses the one before it, so a song can declare its geometry once at the top. Leave it off everywhere and each grid just sizes itself to its own content.

### Strum patterns

A row of strum codes draws the picking hand instead of chords. There are three base codes: `d` down, `u` up, and `x` a muted hit.

The modifiers attach to a base code and never stand on their own. Write `a` for arpeggiated (`da`, `ua`), `s` for staccato (`ds`, `us`), and a trailing `+` for an accent (`d+`, `da+`). Join two codes with `~` for eighth notes:

```
{start_of_grid shape="1+4x2+1"}
| C . | F . | C . | G . |
|s d dn~up | d dn~up | d dn~up | d u |
{end_of_grid}
```

Open the row with `|s`, as above. That marks it as a strum row: it borrows the bar structure of the chord row above instead of drawing its own barlines.

Give a strum row the same number of measures as the chords it belongs to. On a narrow screen a wide grid breaks into several lines, and the two rows break together, so a strum row that stops early simply has nothing under the last chords. If a measure is deliberately not strummed, write it as empty beats (`| . . . . |`) rather than leaving it off, and the row stays as long as the chords.

When a grid breaks into lines, all of them share the same columns, so bar lines and strums stay lined up from one line to the next. Every line ends on a bar.

## Two looks: Flat and Blocks

Grids draw in one of two skins, and you pick the one you like under **Settings → Display → Chord grid style**. The choice syncs across your devices and applies everywhere a grid appears, including Play Mode.

- **Flat** is the notation look: thin barlines with the chords sitting between them. It is the default.
- **Blocks** fills each measure as a rounded panel, so the bars read as tiles.

The chords and barlines land in exactly the same places either way; only the decoration changes, so switching never reflows a chart.

## Transposing a grid

Grids transpose with the rest of the song. The transpose and capo controls move grid chords through the same engine as the chords in your lyrics, so a whole chart follows the key you set.

## How the two forms convert

Switch editor tabs and Fretlist rewrites the grid to match the view:

- A grid the simple style can express shows as a compact `[Grid]` block in **Chords over Lyrics** and as `{start_of_grid}` in **ChordPro**. Either tab round-trips to the other. A repeat counts even when it spans rows: the `(` sits on the row that opens it and the `)` on the row that closes it.
- Row labels and margin notes convert too, as floating titles: `<- Intro` labels the row that follows it, `>- second time arpeggiate` annotates it on the right. A ChordPro label written outside the bars becomes one of these on the way over, since the simple style has no barlines to sit outside of. A repeat's play count stays attached to its bracket instead, as `(D G)3x`.
- A grid that uses something the simple style has no words for stays in the `{start_of_grid}` form in both tabs. Nothing is dropped; the fuller form is simply kept. That covers empty beats, a `%` repeat, a first/second ending, a strum row, a `/` play mark, and a repeat that opens or closes in the middle of a row.

So you can write the easy grids the easy way and still open the demanding ones, and no edit costs you a chart you already have. For the two editor styles in general, see [Chords over Lyrics](https://fretlist.com/docs/chords-over-lyrics.md) and [ChordPro](https://fretlist.com/docs/chordpro.md).
