Smart Beat

Practice, create and break the era.

Smart Beat is a free tablature editor for musicians and learners on macOS, Windows and Linux. Record your ideas, get the band together with in-person and online jamming, and practice with optional, self-hosted AI tools too.

Status: stable release (1.1.0). Smart Beat opens, plays and edits Guitar Pro files (GP3–GP8), MuseScore, MusicXML and MIDI, with a mixer, practice tools and a fretboard, and saves to its native format (Guitar Pro 7 .gp), to Guitar Pro 5, 4 and 3 and to MuseScore. It exports MusicXML (also compressed), MIDI, alphaTex, ASCII tab, WAV and, on macOS, M4A. docs/file-formats.md lists what each format cannot hold. The AI features are next. The roadmap lives in the project board.

Download

The macOS and Windows buttons start the download of the newest release's installer (.dmg, .msi) right away. The Linux and Latest release buttons open the newest release, where every installer (including the Windows .exe and the Linux .AppImage, .deb and .rpm) is attached. All versions are on the releases page.

⭐ Enjoying Smart Beat? Please give the project a star on GitHub. It helps other musicians find it, and we are always very grateful for every one.

Features

More about the features

• Open Guitar Pro files (.gp3, .gp4, .gp5, .gpx, .gp) with File › Open… (⌘O / Ctrl+O) or by dropping them on the window. Damaged or unsupported files get a clear message.
• Read the music as standard notation, tablature, or both, per track, optionally with rhythm under the tab. Choose the track, and a page or a continuous (horizontal) layout.
• Play it: play, pause, stop (Space plays and pauses), start from any bar by clicking it or typing its number. The cursor follows the music and the score scrolls with it. Tempo changes in the song are respected.
• Mix it: master volume, and volume, pan, mute and solo per track. The mix starts from the file's own settings and is saved per song (by its content, so renaming or moving the file keeps it). Volume, mute and solo apply instantly. Pan applies at the next pause, because changing it mid-song would cut off ringing notes.
• Two built-in sound sets: High quality (FluidR3 Mono, 15 MB, the default) or Standard (Sonivox, 1 MB, quicker to load), switchable in the inspector. Switching during playback keeps the current sounds playing while the new ones download, then continues from the same point after a short pause while they load.
• Add more SoundFonts: SoundFonts… next to Instrument sounds in the inspector opens a dialog where you can import any .sf2 or .sf3 file from your computer, or download one of the recommended banks with its description, size and licence: MuseScore General, GeneralUser GS, FluidR3 GM (stereo), Timbres of Heaven and Arachno. Downloads are checked by the app, stay on your computer, and appear in Instrument sounds right away. You can remove any SoundFont you added to free the space. Timbres of Heaven and Arachno are free for personal use only. Very large banks (Timbres of Heaven is almost 400 MB) take a while to load and need plenty of memory.
• Practice: loop a range of bars (type them, or drag across bars in the score), play at 25–200 % speed, and let the Speed Trainer loop the bars from a slow speed up to a target, a step after each loop (or every few loops). Metronome and count-in, remembered between songs. All in the Playback menu too (Loop ⌘L, Metronome ⇧⌘M).
• Fretboard, keyboard and drum pads (View › Fretboard and Keyboard, ⇧⌘F): the notes being played on the track's instrument, following its tuning and capo. In edit mode, click a fret, key or pad to write that note.
• Write music (Edit › Edit Mode, ⌘E; File › New, ⌘N): an edit cursor on tab and staff. Type frets (two quick digits for 10–29) and pitches by letter (A–G), set note values, dots, rests, ties and tuplets (nested ones too), odd time signatures such as 7/8 and 11/16, write a second voice, select beats (Shift+arrows, drag, ⌘A) to copy, cut and paste them, with unlimited undo and redo (the Edit menu names what it will undo). Moving past the end of a bar or of the song adds beats and bars. The full key list is in Help › Keyboard Shortcuts.

Record to tab (beta)

Record to tab is a beta feature. It runs on your computer (no cloud AI), and it gives you a starting point to edit, not a finished transcription.

• Instruments: guitar, bass, piano and drums, one instrument at a time. A recording of a whole band or a full mix is not supported.
• Guitar: roughly 7 of 10 notes are found (note F1 about 72%), and the right string is picked for about 64% of them.
• Piano: the built-in model finds roughly 9 of 10 notes (note F1 about 86%). The High accuracy model, a one-time 55 MB download, finds nearly every note (note F1 about 99%) and processes a take in about half its own length.
• Drums: kick, snare and hi-hat (closed and open) are found well, about 9 of 10 hits on rendered kits. Toms and crash cymbals are experimental and often wrong.
• Measured on rendered audio: these numbers come from rendered piano music and rendered drum kits. A real room and microphone will score lower.
• Review the result: you will probably need to correct it by hand.

Made possible by open source

A heartfelt thank you to the maintainers whose work makes Smart Beat possible. Meet a few of the projects behind the music (hover over a name to see what it does for Smart Beat).

Special thanks to alphaTab (source, MPL-2.0), the heart of Smart Beat: this project would not exist without it. If you like what Smart Beat does with scores, please give alphaTab a star, try it in your own project, and thank its maintainer, Danielku15, and the contributors. alphaTab's logo and the RustAudio logo are shown with the maintainers' permission. Smart Beat is independent and is not affiliated with or endorsed by alphaTab or any of these projects. Record to tab listens with Basic Pitch (Spotify, Apache-2.0) and, for the high-accuracy piano mode, Transkun by Yujia Yan (MIT): thank you both for sharing your work openly. All notices are in Help › Open-Source Licenses.

Optional add-ons you download yourself

MuScriptor by Kyutai and Mirelo powers the AI mode of Record to tab and Import from Audio. It is not part of Smart Beat: you download it once from inside the app (the weights come straight from the GGUF mirror on Hugging Face, converted to float16 without retraining by DamRsn, and run with muscriptor.cpp, MIT), accept its terms on the official model card and confirm that you only use music you have the rights to. The weights are licensed CC BY-NC 4.0: non-commercial use only. Transcription runs on your computer; your recordings never leave it. More: online demo (runs on Kyutai's servers, not on your computer), paper, announcement, reference code. Smart Beat is independent and is not affiliated with or endorsed by Kyutai or Mirelo (no logos of either are used).

Sponsors

We are looking for sponsors. Smart Beat is free, and we want to keep it that way, including the features that cost money to run. Sponsorship would pay for the server and AI work behind them, for example:

• signing the Windows installer, so Windows stops warning people before they install;
• hosting an AI model and making it available in the app, so the AI features work without a powerful computer of your own;
• training our own model for turning audio, recordings and humming into tab.

If you or your company would like to support Smart Beat, write to [email protected]. Sponsors will be thanked here.

Not a sponsor? A star on GitHub helps too, and we are very grateful for it.

Installing

Download the installer for your system from the newest release on the releases page.

• macOS: the DMG is signed with a Developer ID and notarized by Apple, so it opens without a warning. Open the DMG and drag Smart Beat to Applications.
• Windows and Linux: the installers are not signed. You can still install them, but Windows will warn you first. Signing a Windows installer needs a code-signing certificate or a signing service from Microsoft, which is a paid subscription (about 10 USD a month, plus an identity check), and Smart Beat is a free project without a foundation or funding behind it yet. The plan to sign them later is in docs/code-signing.md.

Windows (.exe or .msi) without a signature: Windows SmartScreen shows "Windows protected your PC". Click More info, then Run anyway, and the installer starts as usual.

Linux without a signature: Linux shows no warning.

• AppImage: make it executable and run it: chmod +x ./*.AppImage && ./*.AppImage (in the folder where you saved it)
• Debian and Ubuntu (.deb): sudo apt install ./<downloaded file>.deb
• Fedora and similar (.rpm): sudo dnf install ./<downloaded file>.rpm

Only install files you downloaded from the releases page of this repository. Once installed, the app updates itself (Help › Check for Updates…).

Tech stack

Layer	Technology
Desktop shell ("backend")	Tauri 2 in Rust (src-tauri/): native window, menu bar, IPC commands
UI	React 19 + TypeScript, Vite, Tailwind CSS 4, shadcn/ui (Radix primitives)
Score and playback	alphaTab (MPL-2.0): Guitar Pro import, notation rendering, SoundFont synthesizer (alphaSynth) in a worker
Tests	Vitest + Testing Library + axe-core (UI), Playwright + axe (browser integration), cargo test with tauri::test (Rust)
Quality	ESLint (typescript-eslint, React Hooks, jsx-a11y), Prettier, rustfmt, clippy, cargo-deny

Prerequisites

Install these once per machine.

	macOS	Windows	Linux (Debian/Ubuntu)
Node.js 24	nvm install (uses .nvmrc)	nodejs.org or nvm-windows	nvm install
pnpm	corepack enable	corepack enable	corepack enable
Rust (stable)	rustup	rustup (MSVC toolchain)	rustup
System	Xcode or Xcode Command Line Tools (xcode-select --install)	Microsoft C++ Build Tools ("Desktop development with C++") and WebView2 (preinstalled on Windows 10/11)	sudo apt install libwebkit2gtk-4.1-dev build-essential curl wget file libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev libasound2-dev
CMake 3.24+	brew install cmake (the AI model engine, src-tauri/native)	cmake.org (the Visual Studio generator works)	sudo apt install cmake (or pip install cmake if apt is older than 3.24)
License tooling	cargo install cargo-about --locked --features cli and cargo install cargo-deny --locked	same	same

Optional: to build the universal (Apple Silicon + Intel) macOS app, run rustup target add x86_64-apple-darwin aarch64-apple-darwin.

Check your setup with pnpm tauri info.

Getting started

corepack enable
pnpm install
pnpm tauri dev      # desktop app with hot reload

pnpm dev runs only the UI in a browser at http://localhost:1420. Native features (menu, About details) show a friendly "desktop app only" message there. Files open through the browser's file picker or drag and drop, and the mix is not saved.

pnpm tauri dev and pnpm tauri build first download the optional FluidR3 SoundFont (15 MB, checksum-verified, cached in node_modules/.cache). The Sonivox SoundFont and the music font are copied from alphaTab by its Vite plugin. Both end up in public/ and are not committed.

Scripts

Command	What it does
pnpm tauri dev	Run the desktop app in development mode
pnpm tauri build	Build installers for the current OS (see Packaging)
pnpm lint / pnpm format / pnpm format:check	ESLint / Prettier
pnpm typecheck	TypeScript project check
pnpm test / pnpm test:watch / pnpm test:coverage	Vitest unit and integration tests (UI)
pnpm test:e2e	Playwright browser integration tests (Chromium and WebKit, a11y and responsive checks). Run pnpm exec playwright install chromium webkit once first
pnpm test:e2e:smoke / pnpm test:e2e:additional	The two CI groups of pnpm test:e2e: core flows, and the guided-tour tests (the tour*.spec.ts files)
pnpm rust:test / pnpm rust:lint / pnpm rust:fmt	Rust tests, clippy (-D warnings), rustfmt check
pnpm licenses:check	Enforce the license policy for npm packages and Rust crates
pnpm licenses:generate	Regenerate public/third-party-licenses.txt (runs automatically before tauri build)
pnpm soundfonts:fetch	Download the FluidR3 SoundFont into public/soundfont/ (runs automatically before tauri dev and tauri build)
pnpm docs:check	Fail on a stale contact address or repository URL, or a broken relative link in the Markdown docs
pnpm version:check	Check that package.json, Cargo.toml and Cargo.lock carry the same version
pnpm release:patch / release:minor / release:major

Testing

Layer	Where	Tool
UI unit	src/**/*.test.ts(x) next to the code	Vitest, Testing Library, axe-core
UI integration	src/App.test.tsx, score-workspace-editing.test.tsx	Vitest with @tauri-apps/api/mocks: the whole UI plus a mocked Rust IPC (commands, menu events and menu state), editing a real score
Browser integration	e2e/	Playwright in Chromium (≈ WebView2 on Windows) and WebKit (≈ WKWebView on macOS, WebKitGTK on Linux): WCAG 2.2 AA scans in light and dark mode, keyboard navigation, focus management, reduced motion, layouts at 375/768/1280 px
Rust unit	#[cfg(test)] modules in src-tauri/src	cargo test
Rust integration	src-tauri/tests/ipc.rs	tauri::test mock runtime: real command wiring over IPC and menu routing

The frontend fixtures in src/test/tauri.ts mirror the JSON returned by the Rust commands. The Rust integration tests assert the same shape.

alphaTab needs a real browser to render and play, so Vitest tests use a fake player (src/test/fake-score-player.ts) while parsing and editing run for real on alphaTab's model. The Playwright tests in e2e/ (score, practice, editing, instrument-view and tracks specs) drive the real renderer and synthesizer. Their songs in e2e/fixtures/ are original and generated by scripts/make-fixtures.mjs. Don't commit commercial transcriptions.

Packaging

pnpm tauri build                                   # installers for the current OS
pnpm tauri build --target universal-apple-darwin   # macOS: one app for Apple Silicon + Intel

Output lands in src-tauri/target/<target>/release/bundle/:

OS	Artifacts
macOS	macos/Smart Beat.app, dmg/Smart Beat_<version>_<arch>.dmg
Windows	msi/*.msi, nsis/*-setup.exe
Linux	appimage/*.AppImage, deb/*.deb, rpm/*.rpm

The release workflow renames the installers it publishes: a stable name for the website's links (SmartBeat_macos_universal.dmg) and a versioned copy (SmartBeat-0.2.0-macOS-universal.dmg), see docs/release.md. Local macOS builds are ad-hoc signed. See docs/code-signing.md for signing and notarization.

Project layout

src/                 React UI
  components/        App components (+ ui/ generated by shadcn)
    score/           Song screen: toolbars, score view, instrument panel, transport and
                     practice tools, mixer, tracks panel and dialogs
  hooks/ providers/  Theme, menu (actions and state), editor keys, file-open/drop hooks
  lib/tauri.ts       Typed bridge to the Rust commands and events
  lib/score/         alphaTab adapter (player.ts), parsing, mixer and practice models,
                     editor (editor.ts, history.ts, snapshot.ts, model.ts), tracks,
                     instrument view data, music vocabulary (music.ts), SoundFonts
  test/              Test setup, IPC mocks, fake player, axe helper
src-tauri/           Rust core
  src/menu.rs        Native menu bar and shortcut formatting
  src/menu_state.rs  Menu labels, check marks and enabled items, sent by the UI
  src/commands.rs    IPC commands (thin wrappers)
  src/score_file.rs  Reading Guitar Pro files (signature and size checks)
  src/mixer.rs       Per-song mixer settings in the app data folder
  src/zoom.rs        View → Zoom levels
  tests/ipc.rs       Integration tests on the Tauri mock runtime
e2e/                 Playwright tests (+ fixtures/ test songs)
scripts/             License check, notice generation, SoundFont download, test songs
docs/                Licensing, code signing, releases and updates, ADRs
.github/workflows/   CI (every PR) and Release (installers)

How the UI talks to Rust

• Commands (invoke), defined in src-tauri/src/commands.rs and wrapped with types in src/lib/tauri.ts:
  • app_info and menu_shortcuts (About and Keyboard Shortcuts dialogs);
  • read_score_file(path) returns a Guitar Pro file as raw bytes. It only reads files with a Guitar Pro extension and signature, up to 100 MB, and fails with { kind, message };
  • load_mixer_settings(fileKey) / save_mixer_settings(fileKey, settings) store a song's mix as <app data>/mixer/<sha256>.json;
  • update_menu_state(state) keeps the menu bar in step with the UI: "Undo Add note", check marks for Edit Mode, Fretboard, Loop, Metronome and Count-In, and song-only items disabled while no song is open.
• Plugins: the dialog plugin shows the native Open dialog (dialog:allow-open).
• Events: clicking a native menu item goes to menu::handle_event. Window actions (zoom, full screen, close, quit) are handled in Rust. Everything else is emitted as a menu-action event, which the UI handles in useMenuActions (the app handles New, Open and dialogs; the song workspace handles Undo/Redo, edit mode, tracks and practice). Undo and Redo are custom items so they undo score edits; in a text field they fall back to the field's own undo. Cut, Copy, Paste and Select All stay the platform's own items, and the score editor handles those keys itself. Files dropped on the window arrive as Tauri drag-and-drop events with their paths (useFileDrop).

CI/CD

• CI runs on every PR and every push to main:
  • lint, format, types and Vitest with coverage;
  • Playwright, in two groups so neither is too slow: E2E smoke tests (the core flows) and E2E additional functions (the guided tour), each with one job per browser (Chromium and WebKit);
  • Rust fmt, clippy and tests, plus an app compile on macOS, Windows and Linux;
  • the license policy (npm and cargo-deny, including advisories);
  • a secret scan of the files and the full git history (gitleaks, settings in .gitleaks.toml).
• Analytics Worker tests the usage-counter backend in analytics/ and deploys it to Cloudflare from main (docs/analytics.md).
• Release builds .dmg (universal), .msi and .exe, and .AppImage, .deb and .rpm installers. Push a tag matching package.json (e.g. git tag v1.0.0 && git push origin v1.0.0) to create a draft GitHub Release, or run it manually to get the installers as workflow artifacts. PRs that change packaging configuration (tauri.conf.json, icons, EULA, the workflow itself) also build the installers as artifacts. A release also contains signed updater bundles and latest.json, which the app's Help › Check for Updates… and its daily automatic check read: see for how to cut a release, the signing key and the stable download links.

Privacy and usage statistics

Smart Beat counts anonymously how often features are used (Loop, Metronome, Export and so on), per day, together with the app version, your operating system and the installer type. There is no identifier of any kind, so the counts cannot be tied to you or your computer, and nothing about your songs, file names or sounds is sent. Counts are kept on your computer while you are offline and sent in one batch later. Turn it off in Help › Settings…; that also deletes counts that have not been sent. Development and pull-request builds never send anything. Details, the exact list of counted features and the backend: docs/analytics.md.

Licensing

Smart Beat is source-available, not open source. The code is under the PolyForm Noncommercial License 1.0.0: you may use it for personal use, learning and research. Selling it, wrapping it in another product, offering it as a service, or using it inside a company needs permission or a fee: see COMMERCIAL-LICENSE.md. The released installers are free to download and use, including for making and selling your own music, under the EULA.md. Questions about licensing: [email protected].

We only use dependencies whose licenses allow commercial, closed-source distribution, and CI enforces this.

• docs/licensing.md: how the source licence, the EULA, third-party licences, model licences and commercial licences fit together, the component review, and the list of projects we must not copy code from.
• ADR 0002: why we chose this license (it replaces ADR 0001).

Contributing

Pull requests, bug reports and ideas are welcome: see CONTRIBUTING.md for what contributing does and does not give you.

Contributors

Smart Beat is a personal project, not a company: it is created and maintained by @mbalyi, and everything is published under that GitHub account. Thank you to everyone who has helped build it.