charmbracelet/glow: a terminal markdown reader with a TUI and a CLI

What Glow is for, and who ends up using it

The problem Glow addresses is narrow and real: markdown is the default format for READMEs, changelogs and internal docs, but the terminal shows it as plain text with visible hashes, asterisks and backticks. Glow renders that source into styled output, so headings, lists, code blocks and links are readable at a glance. The README describes it as "a terminal based markdown reader designed from the ground up to bring out the beauty and power of the CLI."

Two audiences follow from that. The first is someone who lives in a shell and wants to read a project's README before cloning it. The second is someone browsing a documentation tree locally, where opening an editor for each file is slower than paging through them. Glow covers both with one binary: run it with no arguments for the interactive browser, or pass a file, a URL or a git path for a single render. It is not a markdown editor, not a static site generator, and not a component you embed in another program. If your goal is to produce HTML or PDF from markdown, this is the wrong tool and the README makes no claim otherwise.

How the renderer, the TUI and the pager fit together

The repository layout shows the split. A `ui/` directory holds the interactive browser, while `main.go`, `style.go`, `url.go`, `github.go` and `gitlab.go` sit at the top level and handle the command line, styling, and remote fetching. The TUI is built on Charm's own stack: `charm.land/bubbletea/v2` for the event loop, `charm.land/bubbles/v2` for components, and `charm.land/lipgloss/v2` for styling. Rendering itself comes from `charm.land/glamour/v2`, a separate Charm project that owns the markdown-to-ANSI conversion and the style definitions.

That dependency boundary matters when you evaluate Glow. Style names such as `dark` and `light`, and the JSON stylesheet format accepted by the `-s` flag, are Glamour concepts. The README links to Glamour's style gallery for additional styles and to Glamour's styles directory for building your own. So customising Glow's output is really customising Glamour, and a change that looks like a Glow limitation may be a Glamour one.

File discovery is the other half. The README states that running `glow` with no arguments searches the current directory and below, and that inside a Git repository it searches the repo. The dependency on `github.com/muesli/gitcha` in `go.mod` is consistent with Git-aware traversal. Remote sources are handled by separate files: `github.go` and `gitlab.go` for repository READMEs, `url.go` for HTTP. A fuzzy matcher (`github.com/sahilm/fuzzy`) backs the TUI's filtering, and `github.com/fsnotify/fsnotify` is present, which suggests the browser can react to files changing on disk.

Installing Glow and rendering your first file

The README lists package managers for most platforms. On macOS or Linux, Homebrew is the shortest path:

brew install glow

On Windows there are three options, and the README gives all three:

choco install glow
scoop install glow
winget install charmbracelet.glow

If you already have a Go toolchain, the module path is the v3 one:

go install charm.land/glow/v3@latest

Building from source needs Go 1.21 or newer according to the README, and the module file declares a much later Go version, so use a recent toolchain. The build steps are three commands:

git clone https://github.com/charmbracelet/glow.git
cd glow
go build

With the binary on your PATH, the first real use is rendering a file. Passing a path is the primary form:

glow README.md

You should see the markdown rendered with styled headings and code blocks instead of raw syntax. The CLI also accepts stdin with a trailing dash, an HTTP URL, or a GitHub or GitLab path, which fetches the README over the network:

glow github.com/charmbracelet/glow

Two flags are worth knowing immediately. `-w` caps the wrap width, and `-p` sends output to your pager, defaulting to `less -r` when `$PAGER` is unset:

glow -w 60 -p README.md

Style selection is automatic by default: the README says Glow detects the terminal background and picks `dark` or `light`. You can override it with `-s dark`, `-s light`, or a path to a JSON stylesheet. If you keep retyping flags, `glow config` opens a `glow.yml` file in `$EDITOR`; the README's example keys are `style`, `mouse`, `pager`, `width`, `all`, `showLineNumbers` and `preserveNewLines`. Run `glow --help` to find the config path on your platform, since the README defers to it rather than naming the directory.

Where Glow stops being the right tool

Glow renders to a terminal, and that constraint produces several sharp edges. Anything that depends on exact layout, such as tables with wide columns or diagrams that assume a fixed width, will reflow or truncate depending on your terminal size and the `width` setting. The README does not document an option for emitting plain markdown or HTML.

The pager behaviour is a second source of friction. `-p` defaults to `less -r` when `$PAGER` is not set. The `-r` flag tells `less` to pass raw control characters through, which is what makes the colours survive, but it also means a pager configured without `-r` will show escape codes as literal characters. That is a configuration problem rather than a Glow bug, and it is the kind of thing you discover only after the output looks broken.

Mouse support and line numbers are TUI-only, per the config comments, so a workflow built around the CLI cannot use them. And the README does not document rollback or downgrade steps between the v2 and v3 module paths. The import path changed from `github.com/charmbracelet/glow` to `charm.land/glow/v3`, so anyone pinning the older path should treat the upgrade as a migration and read the release notes for v3.0.0 rather than assuming a drop-in replacement.

Glow against pandoc and against your editor's preview

The closest general-purpose alternative is pandoc, and the difference is architectural rather than cosmetic. Pandoc is a document converter: it parses markdown and writes out another format, with the terminal being just one possible target among many. Glow is a viewer. It takes markdown and paints it onto a terminal, and that is the end of the pipeline. If you need a PDF, a Word file or a static HTML page, pandoc does that and Glow does not attempt it.

The other comparison is the markdown preview built into editors such as Neovim, which is a common enough pairing that people search for it directly. An editor preview renders in a split pane inside the editor, which keeps you in one window and lets you edit and preview simultaneously. Glow runs as a separate process and is aimed at reading, not editing. For a documentation directory you want to skim without opening anything, the separate process is the advantage: `glow` with no arguments searches the current directory and below, so you get a browsable list rather than a file you have to open one at a time.

Glow's real differentiator against both is the combination of remote fetching and local discovery in one binary. `glow github.com/charmbracelet/glow` pulls a README over the network, and the same command with no argument browses what is already on disk. Pandoc does neither, and an editor preview does the second but not the first.

Maintenance, licence and what an upgrade costs

The repository is not archived, and the last push was on 2026-10-05. Release v3.0.0 landed on 2026-08-11, following v2.1.2 in April 2026 and v2.1.1 in May 2025. That cadence suggests the project is maintained, though the gap between v2.1.1 and v2.1.2 is roughly ten months, so releases are not frequent.

The licence is MIT, which is permissive and places few obligations on redistribution beyond preserving the copyright notice and licence text. That is a description of the licence terms, not legal advice; if you are vendoring the binary into a commercial product, have your own counsel read the LICENSE file at the repository root.

The upgrade cost is concentrated in the v3 module path change. `go.mod` declares `module charm.land/glow/v3`, and the README's install command is `go install charm.land/glow/v3@latest`. A Go project that previously imported the GitHub path will need its imports updated, and the dependency list shows a broad Charm stack (`bubbletea/v2`, `bubbles/v2`, `lipgloss/v2`, `glamour/v2`) that moved to the `charm.land` domain as well. The README documents no migration guide, so the release notes for v3.0.0 are the place to check before upgrading a pinned installation.

Editorial conclusion

Adopt Glow if you read markdown files from a shell and want syntax highlighting, word wrapping and a pager without opening an editor. Skip it if you need a graphical preview, a rendered HTML pipeline, or a library you call from your own Go program; Glow ships as an application, not as a rendering API. Before committing, check that a prebuilt binary exists for your platform on the releases page, confirm which style your terminal background resolves to, and read `glow --help` to find the config path on your OS, because the README points there instead of naming it.

Frequently asked questions

Official sources

1. charmbracelet/glow on GitHub
2. Issues
3. License: MIT
4. README
5. Releases