Golazo puts live football scores in a Bubble Tea terminal app

Golazo exists for the matches you cannot stream

Golazo is a terminal user interface for people who want to follow football without opening a browser. It presents live matches, finished results and minute by minute events such as goals, cards and substitutions, and it organises more than 100 leagues by region, covering Europe, the Americas and Global, with tab navigation in the Settings menu. The stated audience is developers and terminal enthusiasts who want match updates without leaving their workflow, and the project describes itself as a tool for the moments when you cannot stream or watch a game live. Statistics sit in focused dialogs and cover possession, shots, passes, standings and formations with player ratings. The interface can also surface clickable links for official highlights and instant goal replays. The scope stays narrow on purpose: it reads match data and renders it in text, it does not stream video.

Bubble Tea for the screen, Cobra for the command line

The interface layer sits on the Charm stack. The dependency list names Bubble Tea v2.0.10, Lip Gloss v1.1.0 and Bubbles v2.2.1, which points to the standard Bubble Tea shape where the screen is a function of state and keyboard input produces messages. Command line parsing uses Cobra v1.10.2, and that choice explains why the project exposes named subcommands rather than only root level flags. Desktop notifications rely on github.com/gen2brain/beeep v0.11.2, with github.com/esiqveland/notify and git.sr.ht/~jackmordaunt/go-toast appearing as indirect dependencies, which is the familiar shape for cross platform toast delivery. The module declares go 1.25.0, so building from source needs a current toolchain. The repository root also carries default.nix and flake.nix next to go.mod, which means a Nix based build path exists alongside the Homebrew tap and the two install scripts.

Three install paths, one first run

Homebrew is the path the project puts first, and the tap is scoped to the author, so the formula name is not the bare package name:

# Install
brew install 0xjuanma/tap/golazo

# Update
brew upgrade 0xjuanma/tap/golazo

Two shell installers cover people who are not on macOS package management. On macOS and Linux the project gives a single piped command:

curl -fsSL https://raw.githubusercontent.com/0xjuanma/golazo/main/scripts/install.sh | bash

and on Windows it gives the PowerShell equivalent:

irm https://raw.githubusercontent.com/0xjuanma/golazo/main/scripts/install.ps1 | iex

If you would rather compile it, the documented route clones the repository and builds the binary in place:

git clone https://github.com/0xjuanma/golazo.git
cd golazo
go build 
./golazo

Either way the first real use is the same. Start the app with the installed binary:

golazo

The README lists the navigation keys as up and down arrows or j and k to move, Enter to select, slash to filter, Tab to change the focused view, Esc to go back and q to quit. A self update flag is also available whenever you want the newest build.

Automatic polling is what fills the live timeline

The live view depends on automatic polling rather than a push channel, and that choice explains both the responsiveness and the limits of the live pane. Goals, cards and substitutions arrive on a timeline that the app refreshes on its own, so you can leave the window open while you keep working. Finished matches are grouped by lookback window, with views for today, the last three days and the last five days, which is enough to catch up after a weekend without scrolling an endless list. The Settings menu is where the supported leagues are trimmed, and the region tabs exist so that someone who follows only the Americas does not have to dig through European competitions. Every league and competition is listed in docs/SUPPORTED_LEAGUES.md, so the coverage can be checked before you decide whether the tool covers your team.

golazo match is best-effort against real IDs

The JSON subcommands exist for scripts and agentic tools, and one of them carries an honest warning in the command itself. Five subcommands are listed: capabilities, live, finished, match and leagues. The match subcommand returns full match details, but the documentation describes it as best-effort against real IDs and reliable with the mock flag, which means the detail view is the least trustworthy part of the contract.

golazo capabilities | jq .                       # self-discover the contract
golazo live                                       # live matches right now
golazo finished --include-upcoming                # today's full slate
golazo finished --days 3                          # last 3 days
golazo match 2001 --mock                          # full match details (best-effort against real IDs; reliable with --mock)
golazo leagues --all                              # every supported league

The finished subcommand carries a day window and an include-upcoming switch, which is what lets a script ask for a full slate rather than only matches that already have a final score. The capabilities subcommand is the sensible first call because it returns the contract itself, and the project points to docs/CLI.md for the JSON envelope, error codes, exit codes, retry policy, schema and jq recipes. Documentation for the exit code map is what tells you whether a script should retry or give up.

Goal notifications travel through a system toast layer

Goal notifications are a documented feature rather than a side effect. The README lists desktop notifications for goals as they happen, and the dependency on the beeep library explains the route: the app asks a platform toast API to raise a system level notification rather than drawing anything inside the terminal. Configuration for that behaviour lives in docs/NOTIFICATIONS.md, which the README links alongside the supported leagues page and the CLI page. The practical consequence is that notification delivery depends on what the host operating system provides. The indirect dependencies for dbus and for Windows toast support hint at the platforms involved, but the details of what a given desktop will accept are described only in the notification documentation, so it is worth reading that file before assuming notifications will fire on a given machine.

Golazo versus checking a scoreboard in the browser

The obvious alternative is a sports site in a browser tab. The difference in approach is narrow but real. A browser scoreboard gives you rendered pages and requires you to click to reach match details, whereas Golazo gives you a text view you can filter with the slash key and a keyboard model that never takes focus away from your editor. The larger difference is the CLI side. A browser gives no contract an agent can parse, while golazo live, finished, match and leagues return structured JSON with typed error codes and a documented exit code map, so a script can branch on failure instead of scraping markup. The trade-off runs the other way too: the browser needs no installation and no toolchain, and it will keep working regardless of what a match detail endpoint returns. Golazo trades setup and upstream data reliability for greppable output and a text first workflow.

MIT licence, Go 1.25.0, and a September 2026 release

The licence is MIT, which is a permissive choice with no copyleft obligation attached to derivative work. No legal reading is offered here, and anyone with a specific compliance question should check the LICENSE file in the repository directly. On the maintenance side, the repository is not archived and the last push was on 2026-09-07, with the v0.33.0 release tagged the same day. Two earlier releases sit close behind it, v0.32.0 on 2026-07-24 and v0.31.0 on 2026-06-30. The version numbers are prefixed with a zero, which is the convention for pre 1.0 modules where interfaces may still change, and the project keeps a CHANGELOG.md alongside a CONTRIBUTING.md at the root. Upgrade cost is therefore modest for the single binary case, since golazo --update pulls the latest version and brew upgrade 0xjuanma/tap/golazo does the same through the tap.

Editorial conclusion

Golazo suits developers who want scores, events and statistics without leaving the terminal, and it is a reasonable pick for scripts that need structured match data through a documented JSON contract. It is not a replacement for a streaming service, and the match details endpoint is best-effort against real IDs. Before adopting it, run golazo capabilities and golazo live to confirm the contract and the league coverage you need, and check whether your platform gets desktop notifications through the toast path the project documents.

Frequently asked questions

Official sources

1. 0xjuanma/golazo on GitHub
2. License: MIT
3. Project website
4. README
5. Releases