ChordFlask

ChordFlask is for exploring your own music collection — audio and video — with chords. It browses and plays local MP3, MP4, and WebM files, analyzes chords and beats, and follows the result during browser playback. Completed analyses stay beside the collection and are reused in later sessions.

Analysis runs locally and media files are not uploaded. Automatic chord recognition is a practical starting point for orientation and practice, not a guaranteed transcription; dense mixes and unusual harmony can produce wrong chords.

For users looking for a self-hosted, local-first, open-source alternative to services such as Chordify, ChordFlask provides a similar play-along workflow while keeping the music collection and analysis local.

ChordFlask is an independent project and is not affiliated with Chordify.

Desktop playback with the chord Grid and optional stems.

Design principles

The standalone stays deliberately lean while providing the complete core playback workflow and built-in Chordino chord and QM beat/bar analysis. Heavy optional producers such as Lyrics generation, BTC, Demucs, and Score remain in separate external runtimes rather than becoming core or standalone dependencies. When those runtimes are installed and usable, ChordFlask detects their capabilities and reaches them through narrow helper/subprocess interfaces.

Desktop is the full interactive interface. Tablet and smartphone layouts intentionally expose fewer controls to preserve clarity and usability; responsive design does not imply feature parity with desktop.

What you can do

ChordFlask is designed for exploring a music collection and playing along with whatever catches your interest. Browse your own audio and video directories, open a song, and let ChordFlask analyze it when you need it. You do not have to prepare the whole collection first: analyze one song spontaneously, queue several from the browser, or prepare an entire directory from the command line. Completed analyses stay with the collection and are reused the next time you return.

During playback, the detected chords and beats follow the song in the browser. This makes it easy to pick up an instrument, improvise, or work out a part without first searching for a separate chord sheet. Transpose the displayed chords, set an A/B loop around a difficult passage, or correct individual chords while keeping the original analyzer result available.

The Grid uses equal-width beat cells, larger chord labels, subtle beat lines, and stronger boundaries at supplied downbeats. Empty and repeated beats stay quiet, while a dedicated playhead marks the current beat. Desktop and smartphone layouts use the same beat structure; smartphone follow keeps the next row visible when space permits. Bar boundaries reflect the rhythm data and configured meter, not automatic meter recognition.

On desktop, a per-song Journal keeps Note, Info, and Agent entries for the whole song or a playback position. Timestamps seek playback and briefly highlight as the song passes them. Agent entries record questions, resolutions, and resolved state; Journal itself does not invoke AI. These user-owned sidecars live in .chordflask/journals, independently of analysis and .cho Lyrics sheets. See the Journal guide for details.

Automatic chord recognition is not a perfect transcription, especially with dense arrangements or unusual harmony. It is intended as a practical starting point for playing, orientation, and improvisation. When the analysis is close but not quite right, you can correct it beat by beat instead of starting over.

Optional workflows extend this further. Add synchronized lyrics from local LRC files, embedded lyrics, or LRCLIB; prepare Demucs stems to mute vocals or instruments for practice; and export analyses as Markdown, PDF, ChordPro, or MIDI.

On desktop (1024 px and wider), a compact Prepare menu can run the available optional producers for the currently loaded song. Depending on the installation, it can prepare Lyrics, BTC analysis, Demucs stems, or an experimental piano Score. Only installed capabilities are shown. Tablet and phone layouts have no Prepare controls; directory and batch preparation remains a CLI workflow.

Prepared piano scores add Score to the desktop Grid | Lyrics | Score view switch. Two staves follow playback by measure, with automatic scrolling only on notation line changes and automatic page selection. Standalone and .deb players can display valid prepared scores without installing the Score runtime. To generate them, run make setup-score from a source checkout and use Prepare → Score or the CLI workflow below explicitly. Score is Alpha / experimental and requires existing QM rhythm data. Transkun sometimes produces musically convincing MIDI transcriptions, but the generated notation is often rhythmically cluttered and not reliably readable as music. See Score setup, timing and limits.

At a glance, ChordFlask lets you:

• browse and play local MP3, MP4, and WebM collections;
• filter and sort the file list, or shuffle the playback order;
• analyze one song, a browser batch, or an entire directory;
• compare the default Chordino result with an optional BTC chord track;
• follow detected chords and beats during playback;
• transpose chords, repeat difficult passages with A/B loops, and correct detected chords;
• add synchronized lyrics from LRC, embedded metadata, or LRCLIB;
• keep per-song notes and observations in the Journal;
• prepare Demucs stems for karaoke and instrument practice;
• display prepared experimental piano scores on desktop; and
• export analyses as Markdown, PDF, ChordPro, or MIDI.

Download

A prebuilt Linux x86_64 bundle is available for users who do not want to build ChordFlask themselves:

Download chordflask-mint22-x86_64-py3.12-v0.9.25.tar.gz

The Mint 22 build is also suitable for Ubuntu 24.04, since Linux Mint 22 is based on Ubuntu 24.04.

Built from the same ChordFlask release source as the public release. FFmpeg and Vamp plugin binaries are not bundled; see the portable bundle guide for requirements.

Recommended Debian-family package for this build platform: Download chordflask-mint22-x86_64-py3.12-v0.9.25.deb

Install: sudo apt install ./chordflask-mint22-x86_64-py3.12-v0.9.25.deb. Remove: sudo apt remove chordflask. The archive remains a portable fallback needing no root or system installation.

The bundle targets Linux x86_64 in the supported Ubuntu, Mint, and Debian family. FFmpeg and the Vamp plugins remain external requirements. See the standalone bundle guide for installation, included and excluded features, and glibc compatibility.

Quick start

Debian / Ubuntu / Mint package

The recommended download on compatible Debian-family systems, matching the standalone build platform, is chordflask-<platform>-x86_64-py<X.Y>-v<VERSION>.deb from the release assets. It installs the same standalone runtime and helper scripts. Replace <release-package> with the matching download filename:

sudo apt install ./<release-package>
/opt/chordflask/install_vamp.sh
chordflask --check-vamp
chordflask

The bundled scripts are under /opt/chordflask/; Vamp plugins are installed separately as shown above. See the Vamp documentation for details. Remove with sudo apt remove chordflask. The build's Linux/glibc compatibility requirements still apply. FFmpeg is a package dependency. Browser playback and the core chordflask-analyze command use the bundled runtime without a source checkout or ChordFlask virtual environment. New Chordino/QM analysis requires the plugins installed above; existing analyses and .cho files remain usable without them. Other helper launchers still require their documented external environments. See the bundle guide.

Portable standalone archive

The archive remains available as a portable fallback. Extracting and running it needs no root access or system installation (FFmpeg must already be available).

Download the archive above, then run:

tar -xzf <release-archive>
cd <standalone-dir>
./install_vamp.sh
./chordflask.sh

Open http://localhost:5000. Stop the server with Ctrl+C. FFmpeg must be installed on the host; the complete procedure is in docs/STANDALONE.md.

Like the Debian package, the archive runs the player and core Chordino/QM CLI analysis with its bundled runtime: ./chordflask-analyze /path/to/song.mp4 --replace. No development venv, user-provided wrapper, or manually set environment variables are needed. Other CLI helpers still require their documented source installation or external runtimes; see CLI helpers.

From source

Install the system packages on Debian, Ubuntu, Mint, or WSL2:

sudo apt update
sudo apt install --no-install-recommends \
  git curl ffmpeg pkg-config vamp-plugin-sdk python3-venv python3-dev \
  build-essential libasound2-dev libcairo2-dev

Then install and start ChordFlask:

git clone https://github.com/bkl2000/chordflask.git
cd chordflask
make setup-runtime
make plugins
scripts/chordflask

Open http://localhost:5000. The setup uses ~/.venvs/chordflask; you do not need to activate that environment for normal use. Stop the server with Ctrl+C.

The server prints a compact capability overview at startup. supported describes built-in playback/display support; optional runtimes are available only with a valid cached capability result. Cheap file checks distinguish installed (not verified) from not installed; not checked means installation files could not be inspected reliably. Full runtime probes remain deferred to use, so startup does not wait for ML runtimes. Existing lyrics, stems, and scores can be used without their producer runtimes; Prepare controls appear only on desktop (>=1024 px).

First use

1. Select Roots, then open a directory containing MP3, MP4, or WebM files.
2. Select a file. MP3 uses the compact audio player; MP4 and WebM use the video player.
3. If analysis is missing, ChordFlask queues it automatically. The status above the grid shows whether it is waiting, running, ready, or failed.
4. Start playback after the analysis finishes. The chord grid then follows the current playback position.
5. Use Previous and Next to move through the visible, filtered file list. Repeat repeats the current file; Auto starts the next file when the current one ends.
6. Use Transpose to shift displayed chord names without changing the audio or stored result.
7. Press A at the start and B at the end of a difficult passage, then use ⟳ to repeat that loop. Loop, Repeat, and Auto are mutually exclusive.
8. To prepare more files, set Next to a batch size and select Analyze. ChordFlask queues that many unanalysed files from the current filtered and sorted list. Files already analyzed or queued do not consume the limit.
9. To correct a chord, pause playback, select Edit, choose a beat, and enter or select the replacement chord. ChordFlask switches to the Edited track. Undo reverses the latest edit; Reset discards the Edited version and returns to the original analysis.

Previously analyzed songs are loaded from the collection's .chordflask directory. The original analyzer tracks remain intact when an Edited version is created.

Lyrics view beside the player, with the file browser open.

Desktop Lyrics with chords above the text and optional stem controls.

The updated Grid with quiet held beats, bar boundaries, and the current-beat playhead.

See Analysis, tracks, editing and export for the complete playback, queue, track, and persistence behavior.

Typical workflows

Play along with a song

1. Open the song and wait for its first analysis if necessary.
2. Start playback and follow the chord grid.
3. Use Transpose if a different displayed key is easier to play.
4. Set A and B around a difficult section and repeat it with ⟳.
5. Pause and use Edit if a detected chord needs correction.

Filter filenames and sort by name, size, or modification time in the file browser; Shuffle randomizes the file list and playback order. On desktop, drag the panel divider to adjust the layout and select Dark or Light for the chord panel. Reanalyze refreshes Chordino/QM analysis while preserving Edited chords. See playback controls.

Prepare an album or directory

In the browser, open the directory, choose a value for Next, and select Analyze. For a command-line batch, run:

chordflask-analyze ~/Music/Album

From a source checkout, use the repository launcher:

scripts/chordflask-analyze ~/Music/Album

Directory processing is non-recursive. Existing valid analyses are reused. Preview the work or deliberately replace the Chordino analysis with:

chordflask-analyze --dry-run ~/Music/Album
chordflask-analyze --replace song.mp3

--replace preserves unrelated tracks and user data. See docs/ANALYSIS.md for lifecycle, batch, replacement, and recovery details.

Add synchronized lyrics

chordflask-genlyrics requires a valid existing analysis. By default it tries a same-stem .lrc, then embedded lyrics, then LRCLIB:

chordflask-analyze song.mp3
chordflask-genlyrics song.mp3
chordflask

Open the song and select Grid | Lyrics. To process a directory or add experimental Thai romanization:

chordflask-genlyrics ~/Music/Album
chordflask-genlyrics --romanize song.mp3
chordflask-genlyrics --replace song.mp3

--replace replaces the selected Lyrics sidecar; the older --force spelling remains an alias. --dry-run performs matching and rendering but writes no sidecar, and reports planned work separately from completed writes.

Desktop Lyrics displays the original line with romanization beneath it:

ฉันรักเธอ แต่เธอไม่รู้
chan rak thoe tae thoe mai ru

The original text stays canonical. Romanization is an additional reading aid on the same timeline, not a separate transcription. Lyrics and chord markers are joined to the existing chord/beat timeline; an instrumental gap can remain unhighlighted.

From a source checkout, install the isolated Lyrics runtime for desktop Prepare. A standalone or .deb player can then use that external runtime:

make setup-lyrics
make lyrics-check

For source runs, Lyrics preparation verifies that the runtime's installed Lyrics and shared helper code matches the current source, including same-version edits. If it reports needs update, rerun make setup-lyrics from the current checkout. make lyrics-check verifies the same identity. Older runtimes without an identity marker also need this setup refresh; existing .cho files are left unchanged.

Source installations retain their installed chordflask-genlyrics command; the standalone invokes only the external runtime helper. Source priority, embedded-tag limits, LRCLIB matching, all CLI options, alignment, romanization engines, and copyright considerations are in docs/LYRICS.md.

For experimental, fully local Lyrics V2 from audio:

make setup-qwen3-asr
make qwen3-asr-check
chordflask-genlyrics --analyzer qwen3 song.mp3
chordflask-genlyrics --analyzer qwen3 --replace song.mp3

V1 remains song.cho; V2 is song.v2.cho. Existing targets are kept unless --replace (or its --force alias) is given, and replacement affects only the selected version. Desktop shows Lyrics V1 / Lyrics V2 when both exist; export uses the selected version. Prepare continues to generate V1; V2 generation is CLI-only. Delete V2 with rm -- song.v2.cho; no maintenance command or persistent version registry is needed. A valid existing Demucs vocal set may be reused, otherwise ASR reads original audio, without starting Demucs.

Qwen runs in a separate venv, downloads its models during setup and then works offline. Compatible CUDA is selected automatically, with CPU fallback. Core, DEB and standalone gain no Torch packages or model weights. ASR detects the language automatically; unsupported alignment languages (including Thai) fail with no V2 write. Singing alignment remains experimental. See the Lyrics V2 guide for setup, language limits, CPU/CUDA options and the separate text/alignment steps.

Prepare karaoke or instrument practice

Install the optional Demucs runtime once, check it, and prepare a directory:

make setup-demucs
make demucs-check
chordflask-demucs --dry-run ~/Music
chordflask-demucs ~/Music

Then start ChordFlask normally and open a prepared song. Use STEMS to switch to separated playback, mute Vocals for karaoke, mute Bass for bass practice, or set the volume of Drums, Bass, Vocals, and Other individually. Already prepared stem sets are reused.

Remove one song's registered stems and owned stem files through maintenance; preview the exact removals first:

chordflask-maintain stems remove song.mp3 --dry-run
chordflask-maintain stems remove song.mp3

See docs/DEMUCS.md for CPU/CUDA setup, preparation status, storage, browser behavior, and limitations.

Prepare an experimental piano Score

Score is Alpha / experimental. Generation accepts MP3/MP4 and requires valid existing QM rhythm analysis plus a separate optional runtime. From a source checkout:

make setup-score
make score-check
scripts/chordflask-analyze song.mp3
scripts/chordflask-score --device cpu song.mp3
make score SCORE_ARGS="--dry-run ~/Music/Album"

make setup-score requires Python 3.12 and installs the isolated runtime; see optional Python installation with uv if needed. make score-check diagnoses it without inference or downloads. make score SCORE_ARGS="..." invokes the same helper; --dry-run previews a file or non-recursive directory without writing or running transcription. Use --replace to regenerate an existing score deliberately.

--quantization mixed|binary selects the notation grid (mixed is the default: sixteenths and eighth-note triplets). binary uses sixteenths only and can reduce unwanted tuplets and rests, but shifts genuine triplets; use mixed for those. For example: scripts/chordflask-score --quantization binary --replace song.mp3. Changing the grid requires --replace; previous generations are retained. Original MIDI, Transkun events and QM playback timing remain unchanged.

Open the prepared song and select Score on desktop. Valid prepared scores can be displayed in source, standalone and .deb players without the generation runtime. The notation is not reliably playable; see Score setup and limitations for installation, CPU/CUDA options, existing no-vocals stems, and timing constraints.

Export a leadsheet

chordflask-export song.mp3
chordflask-export --format pdf song.mp3
chordflask-export --format markdown song.mp3
chordflask-export --format chordpro song.mp3
chordflask-export --format midi song.mp3
chordflask-export --format score-midi song.mp3
chordflask-export --format all song.mp3

• Markdown is an editable leadsheet representation.
• PDF is a printable A4 layout.
• ChordPro is a reusable chord-grid or lyric-bearing song sheet.
• Chord MIDI (--format midi) is an editable piano chord sequence from the displayed beat grid, with a tempo map matching the analyzed beat times. It retains the selected track, edits, and transposition; it is not a full music transcription.
• Score MIDI (--format score-midi) contains Transkun's recognized individual notes from the valid active Score generation, saved as <song>-score.mid. It copies the original MIDI without generating analysis or transcription; missing, stale or invalid Score data produce an error.

The browser Export menu offers Markdown, PDF, ChordPro, Chord MIDI, or All formats (.zip). Individual formats download directly; only All formats produces a ZIP. Score MIDI is shown only for a valid current Score generation. All formats includes the previous files plus Score MIDI when available; the CLI's --format all does the same for separate files, ignoring unavailable Score MIDI. Existing Score MIDI exports need no Transkun runtime, including in standalone and .deb players. Browser exports may include existing local Lyrics and romanization; chordflask-export does not include lyrics. Journal entries are not exported. The CLI prints each output path and reports when it had to create missing analysis. Options, track selection, naming, and storage locations are documented in docs/ANALYSIS.md.

Command-line tools

The chordflask player is available in each installation (the archive uses ./chordflask.sh). Most separate chordflask-* helpers are installed by the source setup; in a checkout, use the matching scripts/chordflask-* launchers. The standalone archive and .deb also provide core chordflask-analyze through the bundled runtime, without a source installation. Use ./chordflask-analyze in the extracted archive or chordflask-analyze after DEB installation. chordflask-export, chordflask-maintain, and the Demucs CLI launcher still need a source-installed ChordFlask environment; optional producers additionally need their respective external runtimes. Browser display of existing analyses does not require those optional runtimes.

The portable scripts/chordflask-score launcher uses the separate runtime installed by make setup-score. Copy or symlink it to a directory on PATH to use chordflask-score from any working directory. See Score installation.

Command	Purpose
chordflask	Interactive player
chordflask-analyze	Generate chord/beat analysis
chordflask-demucs	Generate optional stems
chordflask-export	Export analysis data
chordflask-genlyrics	Generate lyric/chord sidecars
chordflask-maintain	Diagnose and maintain generated data
chordflask-score	Generate Alpha piano scores using the optional Score runtime

Typical calls:

chordflask-analyze song.mp3
chordflask-analyze ~/Music
chordflask-genlyrics song.mp3
chordflask-export --format pdf song.mp3
chordflask-maintain doctor
chordflask-maintain validate song.mp3
chordflask-maintain storage report song.mp3
chordflask-maintain storage cleanup ~/Music --orphan-temp --dry-run

Reports and validation are read-only. Cleanup and stem removal require explicit operations; use --dry-run to review candidates without changing data. A single-media storage report covers direct .chordflask artifacts, but not Demucs stem directories or lyrics sidecars beside the media. See docs/MAINTENANCE.md for the exact boundaries.

In a source checkout, prefix the command with scripts/, for example scripts/chordflask-analyze. Installed launchers work from any current working directory. See docs/HELPERS.md for command ownership and docs/ANALYSIS.md for analysis and export options.

Optional features

Automatic beat-grid correction

Automatic beat-grid correction is disabled by default. It conservatively replaces small timing variations only when a detected sequence is consistent with an approximately constant tempo. The original detected rhythm track is preserved whenever a correction is accepted.

For new analysis requests:

CHORDFLASK_AUTO_CORRECT_BEAT_GRID=1 chordflask

From a source checkout, or to reanalyze an existing song:

CHORDFLASK_AUTO_CORRECT_BEAT_GRID=1 scripts/chordflask
CHORDFLASK_AUTO_CORRECT_BEAT_GRID=1 \
  scripts/chordflask-analyze --replace song.mp3

Existing analysis files are not changed merely by enabling the option. The exact acceptance criteria, diagnostic fields, preserved tracks, limitations, and distinction from forced quantize_beats are in docs/ANALYSIS.md.

BTC analyzer

Chordino remains the default. BTC is an optional pretrained analyzer that adds a separate btc chord track; it does not replace the existing Chordino result. Its isolated runtime can use CPU or a compatible CUDA setup.

make setup-btc BTC_ACKNOWLEDGE_WEIGHTS=1
make btc-check
chordflask-analyze --analyzer btc song.mp3

Select the resulting BTC track in the browser. The required weights acknowledgement, runtime matrix, Python/PyTorch/CUDA details, limitations, and standalone status are in the BTC runtime documentation.

The desktop Prepare menu in source and standalone runs can use the bundled lightweight connector when the isolated BTC runtime is complete. It reloads the track list on completion; Chordino and Edited data remain separate.

Experimental research

These features and research projects remain experimental. Availability differs: optional producers need their own runtimes, and private prototypes are not part of the normal distribution.

• Score (Alpha): optional Transkun piano transcription and QM-aligned notation. Desktop displays valid prepared scores without the generation runtime; notation is often rhythmically cluttered and not reliably playable. See the Score guide.
• Lyrics V2: experimental local vocal transcription and synchronization with Qwen3-ASR and Qwen3-ForcedAligner. Initial practical results are available; reliability and hardware requirements are still being investigated.
• Chord Analysis V3: a private experimental analyzer selected through chordflask-analyze --analyzer chordflask-v3. It requires a configured private runtime and adds a separate chord track; stored results remain displayable without that runtime. It is not distributed with normal installations. See V3 analysis.
• Chord Analysis V4: an experimental ML approach to reranking existing chord candidates. A private research prototype includes offline evaluations and listening tools; musical usefulness is still under investigation. It is not integrated into production analysis, the GUI, or release bundles.

LAN, phone, and tablet use

To listen on a trusted LAN and restrict browsing to one media directory:

chordflask --listen 0.0.0.0 --roots "/home/user/Music"

Then open http://<host-ip>:5000 on the other device. Responsive layouts for desktop, tablet and smartphone are included. Mobile support is functional but still undergoing broader real-device testing. Narrow layouts remain Grid-only and do not show Lyrics, romanization, or Prepare controls. Desktop Chromium-based browsers are recommended for multi-stream STEMS playback: Chromium works reliably and Vivaldi appears reliable in local testing, while Firefox can experience audible dropouts even on localhost with --stem-cache enabled; see docs/DEMUCS.md.

ChordFlask has no authentication or TLS. Use LAN listening only on a trusted network. --roots limits which media directories the server exposes.

Troubleshooting

General diagnosis

For DEB and standalone analysis prerequisites, use chordflask --check-vamp (or ./chordflask --check-vamp in the portable directory). For a source installation's complete core dependency check:

chordflask-maintain doctor

The command checks the core Python environment, FFmpeg, required Vamp plugins, and application-state directory without modifying data.

FFmpeg is missing

sudo apt install ffmpeg

Restart ChordFlask afterward.

Vamp plugins are missing

From a source checkout:

make plugins

From an unpacked standalone bundle:

./install_vamp.sh

For a DEB installation, run /opt/chordflask/install_vamp.sh as your normal user. Verify with chordflask --check-vamp (portable: ./chordflask --check-vamp). Restart the running application after installation, then click the song in the file browser to retry; for existing analysis use Prepare → Reanalyze. The CLI can simply be run again. Analysis errors for the selected song remain visible until retried or another song is selected.

Port 5000 is already in use

chordflask --port 5050

Then open http://localhost:5050.

No files appear

Check that the selected Root contains files ending in .mp3, .mp4, or .webm, and that --roots permits the directory.

Analysis cannot write files

The user running ChordFlask needs write permission in the media directory so ChordFlask can create .chordflask. Source media are not modified.

A standalone reports a GLIBC_* error

The bundle was built against a newer glibc than the target provides. Use a bundle built on an older compatible distribution or build on a system matching the target. See docs/STANDALONE.md and docs/COMPATIBILITY.md.

Storage reports, validation, migration, cleanup, and repair-oriented workflows are in docs/MAINTENANCE.md.

Security

The default listener is localhost. ChordFlask has no authentication or TLS, so only expose it on a trusted LAN and always constrain network access with --roots:

chordflask --listen 0.0.0.0 --roots "/home/user/Music"

See SECURITY.md for the trust model and filesystem boundaries.

Build a standalone bundle

This is an advanced workflow for producing a transferable Linux x86_64 bundle:

make setup
make standalone

Build naming, compatibility, external dependencies, transfer, and diagnostics are documented in docs/STANDALONE.md.

More documentation

• Analysis, tracks, editing, beat-grid correction, and export
• Per-song Journal: notes, information, and Agent observations
• Lyrics, LRC, embedded lyrics, LRCLIB, and romanization
• Demucs stems and practice workflows
• Experimental piano Score: setup, display, MIDI and limitations
• Maintenance and storage
• Standalone bundle
• Platform and Python compatibility
• Vamp plugins
• Architecture and developer map
• Supported command-line helpers
• Development and tests

Development transparency

ChordFlask's primary development takes place in a privately hosted repository. The public GitHub repository is a curated, functional source snapshot; private experiments, internal documentation, and development tools are excluded from publication.

ChordFlask is developed through human-directed, AI-assisted software engineering. The maintainer defines requirements, architecture, scope, quality assurance, integration, and releases. AI systems support activities such as analysis, implementation, testing, review, and documentation, while the maintainer remains responsible for evaluating and accepting their results.

Issues and pull requests are welcome. Accepted contributions may be integrated privately and published in subsequent snapshots rather than merged directly on GitHub. See CONTRIBUTING.md before starting substantial work.

License

ChordFlask-owned source is available under the MIT License. FFmpeg, Vamp plugins, and Python dependencies retain their own licenses. See LICENSE and THIRD_PARTY_NOTICES.md.

ChordFlask is independent of and not endorsed by the Pallets project, which maintains Flask.