Piano Trainer: a Tauri desktop app for drilling scales, chords and fifths

A practice program organised around four drills

The project's own description is unusually blunt about intent: a piano practice program with MIDI support that should be treated as an interactive reference manual rather than a course. That framing matters, because it tells you what the app will never do. Nothing here assigns repertoire, teaches note reading, or tells you why a fingering is the correct one.

The README's feature checklist is a flat list of checked boxes, and it is worth reading as the complete scope of the program. MIDI compatibility is the first item, with home row keyboard input nested under it. After that come cross-platform support, interactive scale practice, interactive chord practice, interactive fifths practice, an interactive quiz, hard mode and shuffle mode. Eight capabilities, all interactive, no library of content.

The repository topics confirm the shape of the thing: tauri, rust, midi, midir, music-theory, circle-of-fifths, quiz, trainer and music-learning. The tree makes the two-language layout explicit. `src/` holds the frontend and `src-tauri/` holds the Rust side, with `public/` for static assets, `flatpak/` for the Linux packaging manifest and `app-icon.png` at the root. So this is a desktop application with a web frontend, not a page you open in a browser. The download page is an itch.io listing, and the repository is licensed MIT under a `LICENSE.md` file. The last push was on 2026-04-24.

Running from source means installing Rust and the Tauri CLI

There is no npm-install path here, because there is no published package to install. The README's Run Locally section sends you to a Tauri prerequisites guide, then gives three commands:

$ git clone https://github.com/ZaneH/piano-trainer.git
$ cd piano-trainer
$ yarn tauri dev

The third line works because `package.json` defines a `tauri` script as `tauri` and a `tauri:dev` script that runs `cross-env BROWSER=none tauri dev`, so yarn can forward the `dev` subcommand. The same file also carries `start` for `react-scripts start`, `build` for `react-scripts build` and `test` for `react-scripts test`, which means the frontend can be developed in a browser without the Rust host running, though the MIDI features would not be available there.

The manifest pins the toolchain in ways that are worth knowing before you start. `react-scripts` is at 5.0.1 and `typescript` at 4.7.4, which is a much older compiler line than the `^19.0.0` React and the `@types/react` 19 typings in the same file expect. There is also a `prepare` script running `husky install`, so installing dependencies wires up the git hooks the README mentions. If you hit type errors during development, that gap between the TypeScript version and the React typings is the first thing to look at.

MIDI in Rust, an on-screen keyboard in React

This is the part of the project that is genuinely worth reading the code for. The Credits section names `ruohki/tauri-midi-example` as the source of the MIDI side and `kevinsqi/react-piano` for the keyboard, and the dependency list backs both up: `react-piano` at 3.1.3 and `soundfont-player` at 0.12.0 for the sound. The `midir` topic on the repository is the Rust MIDI library, which places the actual device handling in `src-tauri/` rather than in the browser layer.

Splitting it that way is what makes the app feel immediate. Hardware key events arrive through a native backend instead of a Web MIDI permission prompt, get forwarded to React, and the on-screen keyboard reflects them. The home row keyboard input listed under MIDI compatibility is the companion feature for players without a MIDI keyboard, letting you drive notes from the computer keyboard the way you would from the physical one.

The sound side is thinner than the input side. Under the Coming Soon heading, Change keyboard sound is the one sub-item already ticked, while the settings panel itself and the toggle for questions in quiz mode are both unticked. Translation is handled by `i18next` and `react-i18next`, and `@tauri-apps/plugin-store` 2.2.0 is present, which is the plugin that persists key and value state to disk. The README does not say what gets written there, so treat saved progress as an undocumented implementation detail rather than a feature you can rely on.

Three ways to get a build: itch.io, release assets, Flatpak

The README points at two download sources, itch.io and the GitHub releases page, and the release history explains where the third came from. Version 1.3.1, published 2025-07-04, added shuffle mode from issue 32, described as selecting multiple scales to switch between while practicing. Version 1.3.2 followed six days later and added Flatpak support, with a release note telling existing installs they should not notice a difference. The newest tag is `app-v1.3.3` from 2026-02-24, whose body is just a pointer to the assets. Notably, the release notes are changelogs of one or two lines rather than migration guides, so upgrading from an old build carries no documented upgrade cost.

Building a binary yourself is one command, and the README names the output path:

$ yarn tauri build

Results land in `./src-tauri/target/release/bundle`, which is where Tauri's per-platform installers accumulate. The Linux Flatpak path is more demanding, and the README is upfront that it needs `flatpak`, `flatpak-builder` and `appstream` installed first, describing the Flatpak as a self-contained runtime for non-FHS distros:

$ flatpak-builder --force-clean --user --install-deps-from=flathub --install builddir flatpak/com.zane.piano-trainer.yaml
$ flatpak run com.zane.piano-trainer

The manifest path in that command matches the `flatpak/` directory in the tree. An `@tauri-apps/plugin-updater` dependency is also present, so an in-app update path exists in the code even though the README directs you to itch.io and the releases page instead. A `.taurignore` file controls what Tauri packages into the bundle.

Two places where the version numbers disagree

Reading the repository closely turns up two inconsistencies that will cost you time if you take the docs at face value, and neither is fatal.

The first is the application version. `package.json` declares `"version": "0.1.0"` alongside `"private": true`, while the release tags run to `app-v1.3.3`. The manifest field is a leftover from the Create React App scaffolding that the build tooling still expects, and it is not the app version. The operative number is the release tag, so if you are pinning a build, pin the tag rather than the manifest.

The second is the Tauri major version. The README's prerequisites link points at `tauri.app/v1/guides/getting-started/prerequisites`, but the dependencies are `@tauri-apps/api` at 2.2.0 and `@tauri-apps/cli` at 2.2.7. Following the v1 prerequisites page exactly will get you a toolchain one major version behind what `yarn tauri dev` expects. The dependency block is the authority here: install the current Tauri 2 CLI, and treat the v1 URL as a stale link rather than a compatibility promise. When in doubt, the `flake.nix`, `flake.lock` and `.envrc.example` files at the root are worth reading, since a Nix development shell can pin the exact toolchain the author used.

What the checklist admits is not finished

The Coming Soon section is short and it is the most honest part of the README. More scales is unticked, meaning the set of keys and fingerings you can drill is whatever shipped in 1.3.1. The settings panel is unticked, and the only sub-item marked done inside it is changing the keyboard sound. Toggle questions in quiz mode is also unticked, which means quiz mode behaves one way rather than offering a choice.

Set against that, the README's feature list names no metronome, no tempo control, no recording or playback of your own playing, no repertoire library and no sight-reading material. Those absences are not oversights in the documentation, they describe what kind of program this is: a repetition trainer with immediate input feedback. If your practice problem is that you cannot find your way around the keyboard on a major scale, it addresses that directly. If your problem is that you cannot read music or do not know which piece to learn next, it has nothing to offer.

Error reporting is wired up through `tauri-plugin-sentry-api` 0.4.1, which tells you crashes are being collected somewhere, though the README does not document where. The repository also carries an `AGENTS.md` at the root, which is a sign that the author keeps coding instructions in the repo itself rather than in a wiki page.

How it compares with a method book or a metronome app

The honest comparison is not against other practice software so much as against the tools a beginner actually reaches for. A method book teaches reading, posture and repertoire in a sequence, and none of that is here. A metronome app gives you a tempo and a click, and this app has neither. Hard mode is the closest thing to a tempo aid, and it raises the difficulty rather than setting a beat.

What Piano Trainer does instead is narrow the feedback loop on one specific skill. Because MIDI events come through the Rust backend and land on an on-screen keyboard, you see immediately whether you pressed the right key in the right order, which is the specific feedback a scale drill needs and the specific feedback an audio recorder gives you badly. Shuffle mode, added in 1.3.1, exists because drilling one scale repeatedly is less useful than rotating several, which is a pedagogical choice rather than a feature checkbox.

It also stands on other people's work rather than reinventing it. `react-piano` and `soundfont-player` supply the keyboard and the samples, `ruohki/tauri-midi-example` supplied the MIDI bridge, and the Tauri Discord community is credited alongside them. That is a sensible division of labour for a solo project, and it also means the MIDI layer is the part most worth reading if you want to understand how it works. Contributions go through pull requests against the `dev` branch, with stable builds merged into `main`, and formatting is handled by husky and lint-staged through the git hooks.

Editorial conclusion

Piano Trainer is a good fit for a player who already reads music and wants a fast feedback loop on fingerings, and a poor fit for someone who needs a curriculum, a metronome or repertoire. Its real contribution is the input path: a Rust MIDI backend feeding a React keyboard, with home row mapping so two hands can play without leaving the computer keyboard. The gaps are equally concrete. The Coming Soon list still shows more scales and a settings panel as unchecked, so the mode set will not change for a while, and the README's prerequisites link points at Tauri v1 while the manifest depends on Tauri 2. Start by grabbing app-v1.3.3 from the itch.io page or the releases page, run it against a MIDI keyboard for five minutes, and only then read the Technical Breakdown wiki if you plan to contribute on the dev branch.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. ZaneH/piano-trainer on GitHub