Make a chart with AI

How it works

Two authoring paths, by what your assistant can do:

A good prompt to start with: “Using gigcharts.app, write a ChordPro chart of [song] by [artist] — chords above the lyrics, with the sections marked.”

Path A · ChordPro text

Have your assistant write a plain-text song in ChordPro. Copy it, open the app, and paste — it imports automatically. This works with every assistant, including plain chat.

The body

Two chord notations are accepted, and they can be mixed. Chords above the lyric:

Am         C        D     F
There is a house in New Orleans

…or inline in brackets (the importer splits them into two lines for you):

[Am]There is a [C]house in [D]New Or[F]leans

A blank line separates stanzas — that's the unit sections and cues attach to.

Metadata directives

Whole-line directives of the form {key: value} are lifted into song fields (keys are case-insensitive). Put them at the top. Recognized keys, with aliases in parentheses:

Structure (becomes annotations)

• Sections — wrap stanzas in {start_of_chorus} … {end_of_chorus} (also verse, bridge; short forms {soc}/{eoc}). An optional label is allowed: {start_of_chorus: Chorus 1}.
• Cues — a small labeled chip by the nearest stanza: {comment: Watch the tempo} (also {c: …}).
• Chorus recall — a “play the chorus again” marker: {chorus} on its own line.

Full example

{title: House of the Rising Sun}
{artist: Traditional}
{key: Am}
{time: 6/8}
{tempo: 72}

{comment: Slow, arpeggiated}
Am         C        D     F
There is a house in New Orleans

{start_of_verse: Verse 2}
[Am]My [C]mother [D]was a [F]tailor
{end_of_verse}

Path A can't carry exact annotation placement, per-line voice colors, or precise typesetting. For those, use the import link below.

Path B · One-click import link

The app has an /import route that decodes a whole song and opens it in the studio. Two transports:

Payload in the link (#gc=)

#gc= carries a compressed .gigchart envelope in the URL hash. Build it exactly the way the app does:

import LZString from "lz-string";

const envelope = { format: "gigchart", version: 12, song: /* SongFile */ };
const token = LZString.compressToEncodedURIComponent(JSON.stringify(envelope));
const url = "https://app.gigcharts.app/import#gc=" + token;

(A raw, percent-encoded JSON token also works, but compression keeps links short.)

Fetch a hosted file (?src=)

Point the app at a public .gigchart (JSON) or ChordPro text file, under 256 KB:

https://app.gigcharts.app/import?src=https://gist.githubusercontent.com/…/house-of-the-rising-sun.gigchart

The .gigchart envelope

body is the array of chord/lyric lines ("" is a stanza break) — the same shape Path A produces, so you can start from ChordPro and only add annotations.

{
  "format": "gigchart",
  "version": 12,
  "savedAt": "2026-07-28T09:00:00.000Z", // optional, ISO 8601 (older files wrote ms epoch; both load)
  "song": {
    "properties": {                // song identity — same fields as Path-A directives
      "title": "House of the Rising Sun",
      "artist": "Traditional",
      "originalKey": "Am",
      "timeSig": "6/8",
      "tempo": 72                  // note: exported as `tempo`, stored internally as bpm
    },
    "body": [                      // array of raw text lines; "" = stanza break
      "Am         C        D     F",
      "There is a house in New Orleans",
      "",
      "Am C      D     F",
      "My mother was a tailor"
    ],
    "settings": {                  // presentation/typesetting — GROUPED by function, ALL optional
      "typography": {
        "fontKey": "dejavu",       // 'dejavu' | 'jetbrains' | 'sourcecodepro' | 4 Pro faces
        "fontSizePt": 12,
        "layout": "vertical"       // 'vertical' | 'horizontal' | 'booklet'
      },
      "header":  { "title": { "color": "#334455" } }, // every color key is spelled `color`
      "concert": { "show": false }
    },
    "annotations": [               // cues, sections, repeats, voices, capo, markers, road maps
      { "id": "a1", "kind": "section", "text": "Verse 1", "target": { "kind": "span", "from": 0, "to": 0 } },
      { "id": "a2", "kind": "cue", "text": "Slow, arpeggiated", "color": "#e23b3b", "target": { "kind": "stanza", "stanza": 0 } }
    ],
    "voices": { "roster": [], "defaultVoiceId": null },  // optional colored voices ({ id, name, color })
    "palette": null                                       // optional user color preset
  }
}

settings is grouped by function (page / typography / labels / header / songInfoBox / video / voiceLegend / stamp / capo / depth / notation / concert / annotations), and every color key is spelled color. The full list of keys inside each group is on the format reference.

After import you land in the studio editor, where you review, tweak, and export the PDF.

The .gigchart schema

Everything above is the transport. The file itself has more in it than a ChordPro paste can express — annotation kinds and their exact placement, spacers, voices, inline styling, page geometry, and every typesetting setting — and it is all documented, key by key, with worked examples:

Read the full format reference →

Short version, if you're writing one now: only format, version and song.body are needed. Annotations anchor to stanzas (0-based, blank-line separated), to rows inside a stanza (chord row, lyric row, chord row… so lyric rows are the odd indices), and to the gaps between stanzas ({ "kind": "gap", "gapAfter": 1 }). Out-of-range enum values are clamped to something safe on load rather than breaking the chart, and unknown keys are ignored — but omitting a key you're unsure of is still better than guessing it, because an absent key just means “use the default”.

Defaults & limits

• Page count is a render outcome, not something the text sets directly. Aim for a sensible font size and layout; the final page break depends on the rendered result.
• Size: fetched ?src= files must be under 256 KB; keep link payloads pasteable.
• Chords: use standard names (C, Am, F#m7, G/B). Transpose/concert display comes from key / transpose.
• Copyright: you're responsible for the songs you make charts of — GigCharts is a typesetting tool and hosts none of your content.

Ready? Open the app and paste, or hand your assistant this page.