Its MyTabs: a self hosted tablature player that syncs to audio

A tab player that scrolls with the recording, not a notation editor

Its MyTabs is a web application for reading and hearing tablature. The README describes it as an open source, web based, self hostable guitar and bass tab viewer and player, and it compares itself to Songsterr in its opening line. The scope is narrow on purpose. It is a player and a viewer, not an authoring tool, and the repository has no editor, no score library, and no account system.

The feature list gives the shape of the product. It supports guitar tabs and bass tabs. It syncs tabs with audio files in .mp3 and .ogg or with YouTube videos. It includes a MIDI synth, with the ability to mute tracks and solo tracks. It reads .gp, .gpx, .gp3, .gp4, .gp5, .musicxml, and .capx files, which is a wide net of Guitar Pro generations plus MusicXML, so most tabs found around the web can be imported without conversion.

Reading experience options are configurable. There are three cursor modes: no cursor with automatic scrolling, which the author recommends for learning to play along with the drums, highlighting the current bar, and following the cursor. Notes can be coloured, the tab can be drawn in dark or light colours, and a score view can be shown instead of the tab view. Tabs can be shared with others through a link.

The application is TypeScript, with a frontend and a backend directory, and it runs on Deno.

Deploying with Docker Compose on port 47777

The quickest route is a container, and the repository ships a compose.yaml file that is meant to be downloaded and dropped into an empty folder.

services:
    app:
        image: louislam/its-mytabs:1
        ports:
            # Host Port:Container Port
            - "47777:47777"
        volumes:
            # Host Path:Container Path
            - ./data:/app/data
        restart: unless-stopped

The image tag is louislam/its-mytabs:1, the host port 47777 is mapped to the same container port, and the host folder ./data is mounted at /app/data so uploaded tabs and files survive a container replacement. The restart policy is unless-stopped, so the container comes back after a daemon restart or a reboot.

With that file in place the start commands are short.

docker compose up  # Run in foreground
# or
docker compose up -d  # Run in background

Then the web UI is at http://localhost:47777. The same port is exposed in the Dockerfile, which declares EXPOSE 47777 and runs the app through an entrypoint script with the command deno task start. The image is built for x64 and ARM64, so it runs on the usual server architectures and on Apple silicon.

One caveat from the Dockerfile is worth knowing before you build it yourself rather than pulling the published image. The build stage compiles the frontend, and the file comments that multi-arch builds are extremely slow, and it copies the built dist from the host instead of the builder stage for the same reason. A published image avoids that entirely.

Running it from source with Deno instead of Docker

If you would rather not use containers, the project runs on Deno on Linux, Windows, and macOS. The requirements are Deno 2.4.4 or above and Git.

git clone https://github.com/louislam/its-mytabs.git
cd its-mytabs

# Check out the latest version from Release page
git checkout 1.X.X --force
deno task setup
deno task start

The clone step matters more than it looks. The default branch is master, and the versioned tags are what carry the released state, so the checkout line is not optional if you want a specific release rather than the tip of the branch. The README also links a Windows build as a zip containing its-mytabs.exe, which is the shortest path for a desktop user who has no interest in a server.

The web UI is again on http://localhost:47777 after the start command. The Dockerfile pins the Deno base image to version 2.9.5 through a build argument, so the containerised runtime is a specific Deno release while the source instructions only ask for 2.4.4 or above.

A separate note in the README deserves attention for anyone planning to host this: YouTube videos may not work on a private IP address, for example something in the 192.168.x.x range, so you should use localhost or a public IP or domain instead. That is a constraint on the YouTube sync path specifically, and it is worth checking before you build a plan around it.

The three environment variables and what they change

Configuration is deliberately thin. A .env file at the project root can hold three variables.

# (string) Server Host (Default: not set, bind to all interfaces)
MYTABS_HOST=

# (string) Server Port (Default: 47777)
MYTABS_PORT=47777

# (boolean) Whether to launch the browser when starting the app (Desktop only) (Default: true)
MYTABS_LAUNCH_BROWSER=true

MYTABS_HOST is empty by default, which means the server binds to all interfaces rather than to loopback only. That default is convenient for a container on a home network, and it is also the setting to change if the instance should not be reachable from the network.

MYTABS_PORT defaults to 47777, matching the port in the compose file and the Dockerfile, so changing one without the other is how you end up with a container that publishes 47777 while the app listens elsewhere.

MYTABS_LAUNCH_BROWSER defaults to true and is documented as desktop only, which points at a launcher behaviour that opens a browser window when the app starts. There is no configuration in the README for a database, a secret, an admin user, or an external storage service, and the only persistent state described anywhere is the /app/data volume. Authentication is not documented at all, so if you expose this to anything other than a home network, put your own access control in front of it.

What the author wanted, and what the alternatives got wrong

The README explains the motivation in unusually plain terms, and it is the best part of the documentation. The author picked up a bass, spent a long time with a music game, and concluded that following a screen is not the same as learning an instrument. Looking for tools, he tried MuseScore and Soundslice, then subscribed to Songsterr and liked the interface. The complaint was that many songs do not sync correctly with the audio or video source, that the cursor is confusing when the sync drifts, and that there is no manual sync feature. Soundslice and Guitar Pro 8 do offer sync tools, but they are hard to use.

The goal that followed was narrow: since most favourite songs follow the bpm perfectly, sync the first bar and be done with it. A subscription model was also unwelcome. The search for an open source project like Songsterr came up empty, which is why this one exists.

That is the honest comparison to make with the hosted alternatives, and the difference in approach is specific. The hosted tools offer deep editing and manual timing adjustment. This project optimises for the read and play loop: import a tab file, point it at an audio file or a YouTube URL, align the first bar, and read along. The keyboard shortcuts support that loop, with Space toggling play and pause, arrow keys moving the cursor between bars, Arrow Up restarting from the highlighted range, and S playing from the first bar that contains notes.

The gap in that story is worth naming too. The README does not document a manual sync or offset control in Its MyTabs, which is the exact feature the author complained Songsterr lacked. On the evidence available, aligning the first bar is left to the user, and the author says as much when describing the goal of the project.

MIT licence, Deno runtime, and a September 2026 push

The project is MIT licensed and is released on GitHub, with version 1.7.0 published on 2026-08-14, 1.6.2 on 2026-03-28, and 1.6.1 on 2026-03-02. The default branch is master and the last push was on 2026-10-19.

That release cadence and the recent push indicate ongoing work, and the versioning shows the project is past the early churn of a 0.x series. The MIT licence permits use in a commercial or private deployment without any disclosure obligation beyond keeping the licence text.

The runtime choice has a cost worth naming. Deno is not the most common way to deploy a web app, so a team that already has a Node or Python deployment pipeline will be adding a new toolchain and a new dependency for the container base image. The upside is that the whole application is a single Deno process, the entrypoint script handles startup, and the Dockerfile stays short.

The repository also links a Reddit post in r/selfhosted about building the project, and it credits AlphaTab in its special thanks, which suggests the tablature rendering is delegated to an existing library rather than written from scratch. The README closes with a pointer to free tab sources such as Ultimate Guitar, 911Tabs, MuseScore's free downloads, and GProTab, and the demo instance is hosted on a public address.

Editorial conclusion

Its MyTabs fits a musician or a small group who want one shared instance of a tab player with audio sync, and who are comfortable running a Deno or Docker container that exposes port 47777 and keeps its data in a mounted volume. It is the wrong tool for a reader who wants a notation editor or a score library, since the app consumes tab files rather than producing them. Before deploying it, check that the tab and the audio file can actually be aligned, because the README lists no manual sync control, confirm that YouTube playback works from your address, since the README warns it may not work on a private IP, and note that the MIT licence, the 1.7.0 release from 2026-08-14, and the last push on 2026-10-07 describe a project that is still moving.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. louislam/its-mytabs on GitHub
4. README
5. Releases