pianoplayer 3.0.1

Automatic piano fingering generator. Finds and shows in 3D the best fingering combination to play a score.

Automatic piano fingering generator for MusicXML and MIDI scores.
PianoPlayer searches for a low-effort fingering sequence for one or both hands.

Download and Install:

pip install pianoplayer

Optional extras:

pip install "pianoplayer[visual]"  # 3D rendering with vedo
pip install "pianoplayer[midi]"    # MIDI input support
pip install "pianoplayer[sound]"   # enable playback
pip install "pianoplayer[all]"     # all optional extras

Standalone executable (basic, no 3D visualization)

Build a standalone executable with PyInstaller:

pip install "pianoplayer[build]"
python scripts/build_standalone.py

Output executable:

• Linux/macOS: dist/pianoplayer
• Windows: dist/pianoplayer.exe

Python Setup (Beginner-Friendly)

If you are new to Python, use one of these two approaches.

Option A: Anaconda (recommended for beginners on Windows)

1. Install Anaconda from https://www.anaconda.com/download
2. Type Anaconda Prompt in your windows search and open it.
3. Install PianoPlayer, type:

pip install pianoplayer

4. Run:

pianoplayer --help

Option B: Python from python.org

Windows:

1. Install Python 3.10+ from https://www.python.org/downloads/windows/
2. During installation, enable Add Python to PATH.
3. Open Command Prompt and run:

python -m pip install --upgrade pip
pip install pianoplayer
pianoplayer --help

macOS/Linux:

python3 -m pip install --upgrade pip
pip install pianoplayer
pianoplayer --help

To visualize the output annotated score (output.xml) install the latest musescore, or any other renderer of MusicXML files. You can also inspect playback in 3D with vedo.

CLI Usage:

Example command line: pianoplayer scores/bach_invention4.xml -n 10 -r -v -z -m
This annotates the first 10 measures for the right hand, opens 3D playback, and then opens MuseScore.

The output is saved as a MusicXML file with name output.xml.

Pre-fingered notes are supported: if a note already has a fingering mark, PianoPlayer keeps it and uses it as an anchor for the following optimization. In the output score, these anchored fingers are rendered as circled numbers.

pianoplayer         # if no argument is given a GUI will pop up
# Or
pianoplayer [-h] [--gui] [-o] [-n] [-s] [-d] [-rbeam] [-lbeam] [--quiet] [-m] [-b] [-v]
            [-z] [-l] [-r] [--hand-size {XXS,XS,S,M,L,XL,XXL}] [--chord-note-stagger-s]
            filename
# Valid file formats: MusicXML, compressed MusicXML, MuseScore, MIDI, PIG
# (.xml, .mxl, .mscz, .mscx, .mid, .midi, .txt)
#
# Optional arguments:
#   -h, --help            show this help message and exit
#   --gui                 Launch the Tkinter GUI
#   -o , --outputfile     Annotated output xml file name
#   -n , --n-measures     [1000] Number of score measures to scan
#   -s , --start-measure  Start from measure number [1]
#   -d , --depth          [auto] Depth of combinatorial search, [5-9]
#   -rbeam                [0] Specify Right Hand beam number
#   -lbeam                [1] Specify Left Hand beam number
#   --quiet               Switch off verbosity
#   -m, --musescore       Open output in musescore after processing
#   -b, --below-beam      Show fingering numbers below beam line
#   -v, --with-vedo       Play 3D scene after processing
#   -z, --sound-off       Disable sound
#   -l, --left-only       Fingering for left hand only
#   -r, --right-only      Fingering for right hand only
#   --hand-size           Hand size preset [XXS, XS, S, M, L, XL, XXL]
#   --chord-note-stagger-s [0.05] Small note staggering used to represent chords

GUI Usage

Run pianoplayer with no filename to open the GUI, then:

• press Import Score (valid formats: MusicXML/MXL, MuseScore, MIDI, PIG)
• press GENERATE (output.xml is written)
• press Musescore to visualize the annotated score (Linux/macOS only)
• press Quit (or q / Ctrl+W) to close the GUI

Example output, as displayed in musescore:

(If fingering numbers are not visible enough try -b option.)

How the algorithm works:

The algorithm minimizes the fingers speed needed to play a sequence of notes or chords by searching through feasible combinations of fingerings.

One possible advantage of this algorithm over similar ones is that it is completely dynamic, which means that it takes into account the physical position and speed of fingers while moving on the keyboard and the duration of each played note. It is not based on a static look-up table of likely or unlikely combinations of fingerings.

Fingering a piano score can vary a lot from individual to individual, therefore there is not such a thing as a "best" choice for fingering. This algorithm is meant to suggest a fingering combination which is "optimal" in the sense that it minimizes the effort of the hand avoiding unnecessary movements.

Parameters you can change:

• Your hand size (from 'XXS' to 'XXL') which sets the relaxed distance between thumb and pinkie.
• The beam number associated to the right hand is by default nr.0 (nr.1 for left hand). You can change it with -rbeam and -lbeam command line options.
• Depth of combinatorial search, from 5 up to 9 notes ahead of the currently playing note. By default the algorithm selects this number automatically based on the duration of the notes to be played.

Limitations

• Some specific fingering combinations, considered too unlikely in the first place, are excluded from the search (e.g. the 3rd finger crossing the 4th).
• Hands are always assumed independent from each other.
• In the 3D representation with sounds enabled, notes are played one after the other (no chords), so the tempo within the measure is not always respected.
• Small notes/ornaments are ignored.