glab-tui

A terminal user interface (TUI) for GitLab and GitHub, built on top of glab and gh. Browse issues, pull requests / merge requests, pipelines, runners, and releases without leaving your terminal.

Features

GitHub & GitLab Dual Support — Automatic detection of repository host, dynamically translating TUI actions and metadata updates to gh or glab CLI commands.
Group & Organization Scopes — Browse and manage issues, merge requests / pull requests, pipelines, and members across entire GitLab groups or GitHub organizations (-g/--group). Create and edit entities directly within group views with target project selection and scoped attribute pre-fetching.
Mouse support — click to navigate tabs, scroll tables, and interact with all overlays and modals
Bulk editing & Visual Select Mode — select multiple issues, merge requests, or branches with Space or enter yazi-style select mode with v, then press e to apply labels, assignees, or milestone across all selected items with full selection preview
Custom commands — bind a key to your own shell command with the highlighted issue, MR/PR or pipeline as gh-dash-style template arguments ({{.PrNumber}}, {{.HeadRefName}}, {{.PipelineId}}, {{.RepoPath}}, …), e.g. to open a worktree in a new tmux window. See Custom commands.
Single-Column Inspector — unified fullscreen details preview and inline editing with full-width markdown description on top and stacked metadata fields below
Interactive Submit Dialogs — explicit Submit/Cancel confirmations with configurable options (squash, delete source branch, auto-merge) for mutating actions
Issues — list, filter, create, and edit issues (title, labels, assignees, milestone, due date, weight, confidentiality, description) with in-menu template selection
Merge Requests / Pull Requests — list, filter, create MRs from issues with auto-linking, approve, merge, view diffs in terminal with code reviews, and edit MR/PR metadata
MR/PR review state at a glance — color-coded Approval (APPROVED, AWAITING, REVIEW REQ, …), Mergeable (CONFLICT, REBASE, CLEAN), and Workflow (Returned / Review req / Yours / Approved / By others / Inactive) columns; rebase with R, revoke your approval with A (GitLab)
Code Reviews & Diff View — draft inline comments, multi-line selections, code suggestions with syntax highlighting, mark files as reviewed (m/M), and atomic review submission
Side-by-Side Diff — toggle between unified and side-by-side diff layouts with theme-aware syntax highlighting and tab-stop expansion
Pipelines / Actions — inspect pipelines and their jobs, retry/cancel pipelines/actions and individual jobs, stream build traces; trigger pipelines with workflow_dispatch input prompts
Runners — list runners with structured details panel and monitor live runner status; pause/resume and edit descriptions (GitLab)
Releases — browse, create, and edit project releases directly in the terminal
Todos / Notifications — tab with badges, relative timestamps, fuzzy search, and an Updated column
Milestones — progress bar column, inline editing, and milestone issue caching
Branches — browse branches with commit details, ahead/behind status, and default/protected markers; switch/checkout (C), create MR/PR from branch (m), visual and bulk selection (Space, v, Ctrl+a), create and bulk delete branches inline
Environments & Deployments — browse environments and their deployment status, walk an environment's deployment history with Enter, inspect each deployment's commit, deployer, job and notes, roll back with R, stop an environment with d and copy its URL with y
Terminal — live log of every glab/gh command the TUI executes, with success/failure status and unified error toasts
Real label colors — the Labels column renders each label with its actual color from the API (glab label list / gh label list), falling back to the theme palette for light GitHub-style background-fill colors; toggle with fetch_label_colors in config.toml
Columns Config Modal — press Tab / , to open a centered popup overlay to toggle column visibility (Space), group by any column, set sort order, page size, and theme
Value-based Column Filtering — press Enter on any column inside the configure popup to filter rows by that column's values (e.g. Issues → State → opened); multi-select supports multiple values per column
Live Search — fuzzy-filter across all visible columns by pressing /
Jump to issue/MR by ID — press g from any tab to jump straight to an issue/MR by ID (rows show as #123 / !456); type an ID such as #123 or !456 into the fuzzy search — rows not already loaded are fetched from the API
Switch Repository — press Ctrl+S to switch to another local repository without restarting
Inline editing — full edit menus with searchable multi-select selectors for labels, assignees, reviewers, and milestones
Interactive Date Picker — calendar widget for Due Date / Start Date fields in edit menus
External editor — descriptions and freeform fields open in your $EDITOR / $VISUAL (also via Ctrl+E)
Self-update — press u in the TUI (or run glab-tui --update) to check for and install updates. Needs curl (not gh), and the download is checked against the release's published SHA-256 before it replaces the binary
CLI subcommands — doctor (system diagnostics), clean-cache (stale cache cleanup), cache (list cached data), open (open entity in browser), repos (list recent repositories), review (read threads and post review comments as JSON, for scripts and agents)
Lazy-load tabs — data for each tab is only fetched the first time you switch to it; refresh with F5 / Ctrl+R
Themes — 38 built-in color themes (including oled, github-dark-hc, light variants, Catppuccin, Tokyo Night, Kanagawa, Cyberpunk, etc.); fully customizable via config.toml or custom .toml files
Configurable keybindings — every action is remappable in ~/.config/glab-tui/config.toml

Demos

Overview & Navigation

Tab navigation across Issues, Merge Requests, Pipelines, Runners, and Releases with interactive detail scrolling and built-in help.

Code Review & Diff View

Review MR/PR diffs in unified or side-by-side view, navigate files, mark files as reviewed, and leave comments.

GitHub does not serve diffs over 20,000 changed lines. For those PRs glab-tui builds the diff with git in a local clone of the repository (any clone you have run glab-tui in): it fetches the PR's commits if they are missing and diffs them, without checking anything out.

Fullscreen Preview & Inspector

Inspect markdown descriptions, discussion threads, and metadata with zoomable single-column inspector views.

Fuzzy Search & Column Configuration

Live fuzzy search across all visible columns, configure visible columns, group rows, and apply value-based column filters.

Field Editing & Selectors

Inline entity editing with searchable multi-select overlays for labels, assignees, reviewers, and milestones.

Prerequisites

Requirement	Notes
Rust (stable, edition 2024)	Install via rustup
`glab` / `gh`	Either `glab` (for GitLab repos, authenticated via `glab auth login`) or `gh` (for GitHub repos, authenticated via `gh auth login`) must be on `$PATH`. You only need the CLI for the service you use.
`git`	Used to auto-detect the current project from the `origin` remote, or from the default repository `gh` recorded for the clone
A terminal emulator	Any terminal that supports 256 colours and Unicode. Icons use a Nerd Font by default; without one, set `icons = "ascii"` in `config.toml`

Windows note: the binary works on Windows. Editor integration uses cmd /c automatically when $OS is Windows.

Installation

Package Manager

Package Manager / Channel	Installation Command
Crates.io	`cargo install glab-tui-crate`
GitHub Releases (Binaries)	Manual / Self-update (`glab-tui -u`)
Homebrew	`brew install rcieri/glab-tui/glab-tui`
Scoop (Windows)	`scoop install glab-tui`
Docker Container	`docker run --rm -it ghcr.io/rcieri/glab-tui`

From source

git clone https://github.com/rcieri/glab-tui
cd glab-tui
cargo build --release
# The binary is at ./target/release/glab-tui

Copy the binary somewhere on your $PATH, e.g.:

Linux / macOS:

cp target/release/glab-tui ~/.local/bin/

Windows (PowerShell):

Copy-Item target\release\glab-tui.exe $env:USERPROFILE\.local\bin\

With `cargo install` (from crates.io)

cargo install glab-tui-crate

With `cargo install` (from the repo root)

cargo install --path .

Install script (Linux / macOS)

curl -sSfL https://raw.githubusercontent.com/rcieri/glab-tui/main/install.sh | sh

Or with wget:

wget -qO- https://raw.githubusercontent.com/rcieri/glab-tui/main/install.sh | sh

The binary is installed to ~/.local/bin/ (configurable via PREFIX environment variable). The script verifies the archive against the release's published .sha256 before installing and aborts on a mismatch; it needs sha256sum or shasum.

Install script (Windows)

iwr -useb https://raw.githubusercontent.com/rcieri/glab-tui/main/install.ps1 | iex

The binary is installed to $env:USERPROFILE\.local\bin\ (configurable via -Prefix parameter). The script verifies the archive against the release's published .sha256 before installing and aborts on a mismatch.

Docker

docker run --rm -it -v "$PWD:/workspace" ghcr.io/rcieri/glab-tui:latest

The image includes both glab and gh CLIs and expects a Git repository mounted at /workspace.

Homebrew

brew tap rcieri/glab-tui
brew install glab-tui

Installs the glab-tui binary on macOS (Intel and Apple Silicon) and Linux (x86_64 and ARM64) from the homebrew-glab-tui tap. Requires either gh or glab (only the CLI matching the repository hosting service you use is needed).

Scoop (Windows)

scoop bucket add glab-tui https://github.com/rcieri/scoop-glab-tui.git
scoop install glab-tui

Installs glab-tui from the scoop-glab-tui bucket. The manifest uses Scoop's autoupdate — version bumps are pulled automatically from GitHub releases.

Configuration

Authentication

glab-tui delegates all API calls to the glab or gh CLI depending on the hosting service (you only need to authenticate the one you use):

glab auth login   # for GitLab repos
gh auth login     # for GitHub repos

The active project is detected automatically from the origin remote in the current working directory. If gh has recorded a default repository for the clone, that one is used instead. gh repo fork --clone records the original repository as default, so a fork opens its upstream project. gh repo set-default changes the choice, and --repo overrides both. For GitHub Enterprise or unusual hosting setups, set the backend explicitly in the repo-local config:

backend = "github" # or "gitlab"

The repo-local override takes precedence over automatic detection. Automatic detection recognizes github.com and checks both gh auth status and glab auth status for other hostnames; SSH aliases and hosts serving both platforms require the override.

Config file

The config file is optional; the app boots from in-memory defaults when none exists. To create one, open the Configure View popup (default Tab) and submit Save View, which writes the current view layout to either ~/.config/glab-tui/config.toml (global) or .glab-tui/config.toml (repo-local, when inside a git repo). Locations:

~/.config/glab-tui/config.toml          # Linux / macOS (XDG)
$GLAB_TUI_CONFIG                         # override: set to the full file path

The generated file is fully annotated. Key sections:

# Pick a built-in theme preset
theme_preset = "default"   # default | tokyo-night | gruvbox | nord | catppuccin-mocha | dracula | oled | github-dark-hc | rose-pine | rose-pine-moon | rose-pine-dawn | clean | ...

# Tab to open on launch. Valid: issues, mrs, pr, pipelines, runners, releases,
# todos, milestones, branches, environments, terminal. Case-insensitive.
# Overridden by the --tab CLI flag.
# active_tab = "mrs"

# Items per API request (1-100) — lower this if your GitLab instance truncates
# large JSON response bodies. GitLab-only; GitHub paginates with --limit.
# api_per_page = 100

# Seconds one gh/glab call may run before it is killed and shown as an error.
# Raise it for a slow self-hosted instance.
# command_timeout_seconds = 120

# Label colors: use the real colors from `label list` (GitLab/GitHub) when
# available, falling back to the theme palette. Set to false to always use the
# theme palette.
# fetch_label_colors = true

# Icon glyphs. "nerd" (default) needs a Nerd Font in the terminal; without one
# the glyphs fall back to other fonts, often double-width, and borders and
# columns drift out of line. "ascii" draws every icon as one ASCII character.
# icons = "nerd"

# Override individual colors (takes precedence over theme_preset)
# [theme]
# bg = "#121214"
# border_focused = "#31bf67"
# ...color tokens (see bundled themes for the full list)

# Remap any keybinding. A binding is one key ("l", "Ctrl+x", "PageDown", "F5")
# or a sequence of plain characters typed one after the other ("gg", "gcc").
# While the keys typed so far start a sequence, glab-tui waits for the next one.
# A sequence that is also the start of a longer one ("g" next to "gg") fires
# after keybinding_timeout_ms (default 1000) without a key, and a key that
# completes nothing drops what was typed.
[keybindings.global]
next_tab = "l"
submit_edit = "Ctrl+x"
scroll_top = "gg"
# ...

[keybindings.issues]
create_issue = "n"
edit_entity = "e"
copy_reference = "y"
# ...

# Persist default column visibility / grouping / filters per pane.
# On a GitHub repository, a State filter with a single state also makes
# `gh issue list` / `gh pr list` fetch only that state (`--state open`).
# For PRs, `--state closed` also returns merged PRs, which the State filter hides.
# [issues]
# columns = ["ID", "State", "Title", "Labels"]
# group_by_column = "State"
# group_ascending = true
# [issues.column_filters]
# State = ["opened"]

# [mrs]
# columns = ["ID", "State", "Status", "Title", "Labels"]
# [mrs.column_filters]
# State = ["opened"]

Custom themes

Drop any <name>.toml file into ~/.config/glab-tui/themes/ and set theme_preset = "<name>" in config.toml. The file must define the same 29 color tokens as the bundled themes: the 19 semantic tokens (backgrounds, borders, text, status colors) plus the 10-entry label_palette_0…label_palette_9 used for label and fallback rendering. The theme's bg token paints the table backgrounds, popup overlays (edit menus, selectors, confirm dialogs), and the diff view, so custom themes render consistently even on terminals whose default background differs.

Editor

Set $EDITOR or $VISUAL to control which editor opens for description and freeform fields:

export EDITOR=nvim   # or vim, nano, hx, code, etc.

The default fallback is helix (hx). Inside any edit menu you can also press Ctrl+E to open the editor directly.

Custom commands

Bind a key to a shell command of your own, in the same shape as gh-dash (its prs table name is accepted as an alias for mrs, so gh-dash examples port unchanged):

[[custom_keybindings.mrs]]
key = "w"
name = "worktree + devbox shell"   # optional; shown in the help modal
command = "tmux new-window -c {{.RepoPath}} 'lazyworktree create --from-pr {{.PrNumber}} --update-on-existing --exec \"devbox shell\"'"

[[custom_keybindings.mrs]]
key = "C"
name = "review in editor"
command = "tmux new-window -c {{.RepoPath}} 'nvim -c \":DiffviewOpen {{.BaseRefName}}...{{.HeadRefName}}\"'"

[[custom_keybindings.universal]]
key = "L"
name = "lazygit"
command = "cd {{.RepoPath}} && lazygit"

A commented set of ready-to-copy bindings (worktrees with lazyworktree, Neovim at the diff line, lazygit, bulk runs) lives in examples/custom-keybindings.toml. Try it without touching your config: glab-tui --config examples/custom-keybindings.toml.

Table	Template arguments
`custom_keybindings.mrs` (alias `prs`)	`RepoName`, `RepoPath`, `PrNumber`, `HeadRefName`, `BaseRefName`, `Author`
`custom_keybindings.issues`	`RepoName`, `RepoPath`, `IssueNumber`, `IssueTitle`, `Author`
`custom_keybindings.pipelines`	`RepoName`, `RepoPath`, `PipelineId`, `Ref`, `Sha`
`custom_keybindings.jobs`	`RepoName`, `RepoPath`, `JobId`, `JobName`, `Stage`, `Status`
`custom_keybindings.branches`	`RepoName`, `RepoPath`, `BranchName`, `CommitSha`
`custom_keybindings.universal`	`RepoName`, `RepoPath`
`custom_keybindings.diff` (diff view)	`RepoName`, `RepoPath`, `PrNumber`, `HeadRefName`, `BaseRefName`, `Author`, `FilePath`, `LineNumber`

The command runs through $SHELL -c (falling back to sh, or cmd /C on Windows) with the terminal handed over until it exits, then the TUI comes back. Every run is logged in the Terminal tab; a non-zero exit also raises an error toast. While a command has the terminal, Ctrl+C stops the command, not glab-tui.
diff bindings run from the MR/PR diff view (D). FilePath is repo-relative and LineNumber is the new-side line under the cursor; a removed line maps to where it was, a file-tree row to the file's first changed line. For example, to open that spot in a worktree of the PR branch:
```
[[custom_keybindings.diff]]
key = "o"
name = "open in nvim (worktree)"
command = "lazyworktree create --from-pr {{.PrNumber}} --update-on-existing --exec 'nvim +{{.LineNumber}} {{.FilePath}}'"
```
background = true runs the command without handing over the terminal: the TUI stays on screen, the command gets no input, its output is not shown, and the Terminal tab logs it when it finishes; a failure toasts its last stderr line (e.g. lazyworktree refusing a closed issue). Use it for commands that open their own window or pane, such as tmux new-window or herdr pane split. Background commands run in their own session without a controlling terminal, so tools that query the terminal through /dev/tty (lazyworktree, gh) cannot inject the reply into glab-tui as keypresses. Place new herdr panes with --pane "$HERDR_PANE_ID" (glab-tui's own pane): --current follows whichever pane is focused in the herdr UI.
Bulk runs: with issues, MRs/PRs, pipelines, jobs, or branches selected (Space, or v select mode), an issues/mrs/pipelines/jobs/branches binding runs once per selected item, in number/name order, within a single terminal handoff — e.g. one worktree per selected issue. A failing or refused item does not stop the others; each run is logged and one toast summarises the failures.
Row arguments come from the highlighted issue, MR/PR, pipeline, job, or branch. RepoPath is the local checkout: the repository glab-tui runs in (it follows the Ctrl+S switcher), or in group scope the recently used checkout whose origin is the row's project. GitHub jobs have no stage, so {{.Stage}} is refused there. JobName is the full name GitLab or GitHub reports, so a matrix job's (rspec: [3.2, pg], build (ubuntu, 3.2)) holds spaces and brackets: pass it as "$GLAB_TUI_JOB_NAME".
Every argument is also exported as an environment variable: GLAB_TUI_REPO_NAME, GLAB_TUI_REPO_PATH, GLAB_TUI_PR_NUMBER, GLAB_TUI_HEAD_REF_NAME, GLAB_TUI_BASE_REF_NAME, GLAB_TUI_AUTHOR, GLAB_TUI_ISSUE_NUMBER, GLAB_TUI_ISSUE_TITLE, GLAB_TUI_PIPELINE_ID, GLAB_TUI_REF, GLAB_TUI_SHA, GLAB_TUI_BRANCH_NAME, GLAB_TUI_COMMIT_SHA, GLAB_TUI_FILE_PATH, GLAB_TUI_LINE_NUMBER, GLAB_TUI_JOB_ID, GLAB_TUI_JOB_NAME, GLAB_TUI_STAGE, GLAB_TUI_STATUS. Titles, branch names and file paths are written by third parties, so a {{.Arg}} is spliced into the command only when its value is a single plain word: a value that starts with - or + (an option, or a +cmd that vim, nvim and less run as a command), or contains whitespace, a control character or any of ` $ ; & | < > ( ) \ " ' ~ * ? [ ] { } # =, is refused. The environment variable is the only safe way to pass free text such as IssueTitle: quote it, and put it after -- when the value could start with - or +, e.g. echo "$GLAB_TUI_ISSUE_TITLE" or some-tool -- "$GLAB_TUI_ISSUE_TITLE".
Built-in keys always win. Several fixed keys (q, j/k/h/l, ?, ,, Enter, Esc, and in the diff view every key it handles) are taken whatever the modifier, so Ctrl+q or Ctrl+d counts as taken. J/K and PageUp/PageDown are reported as taken even though they only scroll while the detail pane is open. A custom key that a built-in action (including the fixed keys such as j, q, u, f) takes first is reported in the Terminal tab at startup; remap the built-in under [keybindings.<pane>] to free the key. A pane-specific binding overrides a universal one on the same key.
Invalid entries (missing key or command, an unbindable key, an argument the table does not offer, an unsupported table) are skipped and reported the same way instead of breaking the rest of the config. A custom key is a single key: a key sequence such as gg counts as unbindable here. A repo-local config.toml that defines a table replaces the global list for that table.

Usage

# Run from inside a GitLab or GitHub repository:
cd /path/to/your/repo
glab-tui

# Specifying optional flags:
glab-tui --repo organization/project-name
glab-tui --group organization-name
glab-tui --dir /path/to/other/repo
glab-tui --tab pipelines

Options

Flag / Subcommand	Argument	Description
`-r`, `--repo`	`owner/repo`	Launch glab-tui for a custom remote repository
`-g`, `--group`	`group`	Launch glab-tui for a GitLab group or GitHub organization context
`-d`, `--dir`	`/path/to/dir`	Launch glab-tui in a custom repository directory
`-c`, `--config`	`/path/to/config.toml`	Use this config file instead of `~/.config/glab-tui/config.toml` (a repo-local `.glab-tui/config.toml` still applies on top); `Save View → Global` rewrites that file without its comments
`-t`, `--tab`	`issues\|mrs\|pr\|pipelines\|jobs\|runners\|releases\|todos\|milestones\|branches\|environments\|terminal`	Tab to open on launch (overrides `active_tab` in `config.toml`)
`-u`, `--update`		Check for and install updates
`-h`, `--help`		Print usage help details
`-V`, `--version`		Print version information
`doctor`	(subcommand)	Check system health — backend CLI availability, config integrity, cache status
`clean-cache`	`[-n, --dry-run]`	Remove stale cache entries for repos that no longer exist (preview with `--dry-run`)
`cache`	(subcommand)	List cached data files with sizes
`open`	`<entity> <id>`	Open an entity in the browser without launching the TUI — valid entities: `issue`, `mr`, `pr`, `pipeline`, `job`, `milestone`
`repos`	(subcommand)	List recently-used and sibling repositories
`review`	`threads\|comment\|submit\|reply\|resolve <n>`	Read and post MR/PR review comments without launching the TUI; prints JSON (see Review from scripts and agents)

The TUI will launch in the terminal, auto-detecting the project context and fetching the Issues tab immediately.

CLI subcommand examples

glab-tui doctor                     # run system diagnostics
glab-tui clean-cache --dry-run      # preview stale-cache cleanup
glab-tui clean-cache                # actually remove stale cache entries
glab-tui cache                      # list cached data files with sizes
glab-tui open issue 42              # open issue #42 in your browser
glab-tui open mr 7                  # open MR/PR #7 in your browser
glab-tui repos                      # list recently-used repositories

Review from scripts and agents

glab-tui review runs the diff view's review operations without starting the TUI, so coding agents, scripts and CI bots can read threads and post review comments. It honours -r/--repo and -d/--dir (before or after review) and the same GitHub/GitLab detection as the TUI.

glab-tui review threads 42                                    # review threads as JSON
glab-tui review comment 42 --file src/a.rs --line 10 "body"   # one inline comment
glab-tui review comment 42 --file src/a.rs --line 10 --end-line 14 --side old "body"
glab-tui review submit 42 --event approve --body "LGTM" --input comments.json
glab-tui review submit 42 --event request-changes --input -  # comments from stdin
glab-tui review reply 42 --thread <id> "body"
glab-tui review resolve 42 --thread <id> [--unresolve]         # GitLab only

Output: JSON on stdout. On failure (CLI not authenticated, MR/PR not found, a line outside the diff) nothing is printed to stdout, the error goes to stderr, and the exit code is non-zero.
--input (file, or - for stdin): a JSON array of comments. side is new (default) or old and says which side of the diff line/end_line count on. Every anchor is checked against the MR/PR diff before anything is posted.
```
[
  { "file": "src/a.rs", "line": 10, "body": "single line" },
  { "file": "src/a.rs", "line": 3, "end_line": 6, "side": "old", "body": "range on removed lines" }
]
```
One review: submit posts every comment together. GitHub gets a single pulls/{n}/reviews call; GitLab gets one draft note per comment followed by one bulk_publish, then glab mr approve for --event approve and the --body summary as a note. GitLab has no request-changes verdict, so request-changes there only publishes the comments and summary. comment is a one-comment review.
Unchanged lines carry both line numbers (GitLab requires both); GitHub anchors them on the new side.
threads prints, per thread: id (pass it to reply/resolve), classification (general, in-diff, outdated against the current diff), anchor (file, line, side), resolvable, resolved and the notes (id, author, body, created_at). On GitHub only pull-request review comments are listed, and a thread id is the id of its first comment.
resolve on GitHub exits non-zero: it is not supported there.

Filtering, Grouping & Columns

Every table tab (Issues, MRs/PRs, Pipelines, Jobs, Runners, Releases, Todos, Milestones, Branches, Environments) can be tailored with column visibility, value-based filters, grouping, and sort order — all from a single Configure View popup.

Column configuration & value-based filtering

Press Tab (or ,) to open the Configure View popup.
The COLUMNS section lists every available column for the active tab. Use j/k (or arrows) to move through it.
- Space toggles whether a column is shown in the table.
- Enter opens a value-based filter for that column: a searchable multi-select of the distinct values currently loaded. For example, on the Issues tab, Enter on the State column lets you filter to just opened issues — or on the Labels column, to specific labels.
Inside the filter selector: Space toggles values on/off, / or f fuzzy-searches the values, Enter applies the filter, Esc cancels. Selecting multiple values is supported (e.g. opened and closed).
Applied filters are shown as a count next to the column, e.g. [x] State (1). Re-open the column, uncheck every value, and press Enter to clear the filter for that column; uncheck only some to widen it.

Grouping & sort order

The GROUP BY section lets you group rows by any column: move to a column and press Space or Enter to toggle grouping. Grouped rows are visually separated by headers.
The ORDER section toggles between Ascending and Descending sort order for the current group-by column (or the default ordering when no group is set).

Page size & theme

PAGE SIZE controls how many items are fetched per tab. Enter on it puts it into edit mode.
THEME lets you switch the color theme on the fly; selections persist via Save View below.

Saving & persistence

The Save View button at the bottom of the popup writes the current layout — enabled columns, group-by, order, filters, and page size — to config.toml (repo-local .glab-tui/config.toml or global ~/.config/glab-tui/config.toml).

A note on filtering

Column filters are applied client-side, after data is fetched — they only ever see the rows that were loaded. If you have many closed/merged items and want more open ones in the list, raise the PAGE SIZE in the Configure View popup (or set page_size in config.toml) so more rows are fetched to filter across.

Key Bindings

All tables below show the default keys. The Config column shows the key name to remap in config.toml (e.g. under [keybindings.issues], create_issue = "n"). — means the binding is fixed and not remappable.

Global

Remappable via [keybindings.global] in config.toml.

Key	Action	Config
`l` / `→`	Next tab	`next_tab`
`h` / `←`	Previous tab	`prev_tab`
`Tab` / `,`	Open column configure popup (`Space` toggle column, `Enter` filter by column values)	`configure`
`Esc`	Close configure popup / overlay	—
`j` / `↓`	Move selection down	—
`k` / `↑`	Move selection up	—
`J`	Scroll description panel down	`scroll_down`
`K`	Scroll description panel up	`scroll_up`
`Home`	Jump to the top of the description panel	`scroll_top`
`End`	Jump to the last line of the description panel	`scroll_to_end`
`PageDown` / `PageUp`	Scroll description panel by one page	`scroll_page_down` / `scroll_page_up`
`Ctrl+d` / `Ctrl+u`	Scroll description panel (or the list when it is hidden) by half a page	`scroll_half_page_down` / `scroll_half_page_up`
`f` / `/`	Open search / filter bar	`search`
`Enter` / `Esc` (in search)	Close search bar	—
`?` / `F1`	Show help: type to filter; `↑`/`↓`, `Ctrl+N`/`Ctrl+P`, `PgUp`/`PgDn`, `Ctrl+D`/`Ctrl+U`, `Home`/`End` or the mouse wheel scroll the list	`help`
`g`	Jump to issue/MR by ID; fetches from the API if not cached	`jump_to_id`
`>` / `<`	Sort list by next / previous visible column	`sort_next` / `sort_prev`
`=`	Reverse sort order	`sort_reverse`
`Ctrl+S`	Switch repository	—
`F5` / `Ctrl+R`	Refresh current tab	`refresh`
`u`	Check for updates	—
`q` / `Esc`	Quit (or close current overlay)	`quit`

Issues tab

Remappable via [keybindings.issues] in config.toml.

Key	Action	Config
`n`	Create new issue (prompts for title)	`create_issue`
`e`	Open edit menu for selected issue (opens bulk edit menu when multiple are selected)	`edit_entity`
`m`	Create MR/PR from selected issue	`create_mr`
`c`	Close selected issue	`close_entity`
`r`	Reopen selected issue	`reopen_entity`
`d`	Delete selected issue (with confirmation)	`delete_entity`
`y`	Copy selected issue as `[#42: Title](URL)`	`copy_reference`
`o`	Open selected issue in browser	`open_in_browser`
`Space`	Select issue for bulk editing	`select_issue`
`v`	Toggle select mode (yazi-style contiguous selection)	`selection_toggle`
`M`	Jump to related Merge Requests / Pull Requests (single target jumps directly; multiple targets open a selector)	`jump_related_mrs`
`J`	Scroll description panel down	`scroll_down`
`K`	Scroll description panel up	`scroll_up`

Issue edit menu fields

Field	Input method
Title	Inline text input
Labels	Searchable multi-select (fetched from GitLab/GitHub)
Assignees	Searchable multi-select (fetched from project members)
Milestone	Searchable single-select (fetched from project)
Confidential	Single-select: Public / Confidential (GitLab only)
Due Date	Interactive calendar date picker (`Enter` to open; `h`/`l` month, `j`/`k` day) (GitLab only)
Weight	Inline text input (integer) (GitLab only)
Description	Opens `$EDITOR` (or press `Ctrl+E`)

Merge Requests tab

Remappable via [keybindings.mrs] in config.toml.

Key	Action	Config
`n`	Create MR from issue ID (prompts for issue IID)	`create_mr`
`e`	Open edit menu for selected MR (opens bulk edit menu when multiple are selected)	`edit_entity`
`a`	Approve selected MR	`approve_mr`
`A`	Revoke your approval (GitLab only)	`revoke_mr`
`R`	Rebase source branch onto target	`rebase_mr`
`m`	Merge selected MR (squash + remove source branch). On GitHub, a stacked PR merges together with every open PR below it in its stack, all or nothing, and the dialog lists them first	`merge_mr`
`y`	Copy selected MR/PR as formatted Markdown link (`[!42: Title](URL)` / `[#42: Title](URL)`)	`copy_reference`
`Y`	Browse and jump to PR in a GitHub stacked PR chain	`view_stack`
`I`	Jump to linked issues from selected MR	`jump_linked_issues`
`D`	View diff of selected MR in terminal	`view_diff`
`P`	View related pipelines from MR detail	`view_related_pipelines`
`Space`	Select MR for bulk editing	`select_mr`
`v`	Toggle select mode (yazi-style contiguous selection)	`selection_toggle`
`o`	Open selected MR in browser	—
`s`	Toggle Draft / Ready status	`toggle_draft`
`c`	Close selected MR	`close_entity`
`r`	Reopen selected MR	`reopen_entity`
`d`	Delete selected MR (with confirmation)	`delete_entity`
`J`	Scroll description panel down	`scroll_down`
`K`	Scroll description panel up	`scroll_up`

MR edit menu fields

Field	Input method
Title	Inline text input
Labels	Searchable multi-select
Assignees	Searchable multi-select
Reviewers	Searchable multi-select
Milestone	Searchable single-select
Target Branch	Inline text input
Status (Draft/Ready)	Single-select
Description	Opens `$EDITOR` (or press `Ctrl+E`)

Diff View

Press D on an MR/PR to open its diff. Use Tab to move focus between the file tree and the diff pane.

Diff View keys are fixed and not remappable in config.toml.

Key	Action
`q` / `Esc`	Exit diff view (or cancel current selection / search). With draft comments pending, asks to Submit, Keep drafts (close, keep them for later), Discard them, or Cancel (`Esc`, back to the diff)
`Tab`	Toggle focus between file tree and diff pane
`h` / `←`	In file tree: collapse directory; in diff: focus file tree
`l` / `→`	In file tree: expand directory / open file
`j` / `↓`	Move down (file tree or diff lines)
`k` / `↑`	Move up (file tree or diff lines)
`J` / `K`	Scroll 10 lines / jump 10 files
`Ctrl+d` / `Ctrl+u`	Move half a page (file tree or diff lines)
`Enter` / `Space`	In file tree: open file; in diff: toggle zoom (hide/show file tree)
`[` / `]`	Previous / next hunk
`z` / `Z`	Collapse / expand all files
`m`	Mark / unmark file as reviewed (on a directory: every file below it)
`M`	Hide / show reviewed files in the file tree
`d`	Toggle unified / side-by-side layout
`v` / `V`	Start / stop multi-line selection for comments
`c`	Add comment on current line / selection
`C`	Add comment via external `$EDITOR`
`e`	Add code suggestion via `$EDITOR`
`a`	Open comment actions menu (reply, resolve, edit, delete)
`T`	Review threads overview: every thread, including general and outdated ones
`r`	Submit review (Approve / Request Changes / Comment)
`/` / `f`	Search within diff
`Ctrl+N`	Next search match
`Ctrl+Shift+N`	Previous search match
`?` / `F1`	Show help

Marking files as reviewed. On a large MR, press m to tick off a file you are done with — from the file tree, or from the diff pane, where it marks the file you are currently reading. Reviewed files get a check indicator and fade to muted; a directory fades and folds itself once every file below it is reviewed — cascading up through parents, so a finished branch collapses to a single line — and the tree header shows your progress (12/200). Unmarking reopens the directory, and a completed directory you reopen by hand stays open. Press M to hide reviewed files altogether and leave only the pending ones. Marks are stored per MR/PR in ~/.cache/glab-tui/<repo>.json and restored the next time you open the same diff (files that are no longer part of the diff are dropped). They are local to glab-tui — GitLab's own "viewed" checkboxes are not synced.

Review threads overview. Inline comments only appear under a line that is still in the diff, so plain MR/PR comments and threads whose line was rebased away are otherwise invisible. Press T to list every thread with its status (UNRESOLVED / RESOLVED), its location (file:line, GENERAL, or OUTDATED), the author, an excerpt and the reply count; the lower pane shows the full thread. j/k move and wrap around at either end like the other lists, Ctrl+d/Ctrl+u move half a page, g/G jump to the first/last thread, u narrows the list to unresolved threads, J/K scroll the thread, Enter jumps the diff cursor to the thread's line (or to its file when the line is gone), a opens the usual reply / resolve / edit / delete actions, and Esc closes it. Jumping to a file you marked as reviewed unfolds its directory, and if M was hiding it, reviewed files are shown again. On GitHub the overview lists pull-request review comments only; top-level PR conversation comments are not fetched, and GitHub reports no resolved state through this endpoint, so every thread shows as unresolved.

Pipelines tab

Remappable via [keybindings.pipelines] in config.toml.

Key	Action	Config
`Enter`	Drill into selected pipeline (show downstream pipelines or jobs)	—
`Alt+j`	View selected pipeline's own jobs directly (skip downstream pipelines)	`enter_jobs`
`Esc` / `Backspace`	Go back (jobs → pipelines, trace → jobs)	—
`n`	Create / run a pipeline with an interactive form (branch/ref, workflow inputs, variables)	—
`p`	Trigger a new pipeline from the current branch (`glab ci run --mr`)	`trigger_pipeline`
`r`	Retry selected pipeline (or all checked pipelines). GitLab reruns its failed and canceled jobs, GitHub the whole run	`retry`
`R`	Retry only the failed jobs of the selected pipeline (or all checked pipelines)	`retry_failed`
`s`	Filter by status: All → Running → Failed → Success → All	`cycle_status_filter`
`i`	Show / hide the inspector: triggering commit, who triggered it, and each failed job with its failure reason	`toggle_preview`
`d`	Cancel selected pipeline	`cancel`
`y`	Copy selected pipeline URL	`copy_url`
`Y`	Copy selected pipeline ID (`#123`)	`copy_id`
`C`	Copy selected pipeline commit SHA	`copy_sha`
`o`	Open pipeline in browser	`open_in_browser`
`Space`	Check/uncheck pipeline for bulk retry	—
`j` / `↓`	(in job view) move down	—
`k` / `↑`	(in job view) move up	—

Inside a pipeline (job view)

Remappable via [keybindings.jobs] in config.toml.

Key	Action	Config
`Enter`	Fetch and display job trace (toggle zoom when trace is open)	`view_trace`
`r`	Retry selected job (or all checked jobs)	`retry`
`S`	Start manual (blocked) job. GitLab only: hidden on GitHub	`start_job`
`c`	Cancel selected job (or all checked jobs)	`cancel`
`d`	Download job artifact	`download_artifact`
`y`	Copy job web URL	`copy_url`
`Y`	Copy job ID	`copy_id`
`Alt+y`	Copy pipeline commit SHA	`copy_sha`
`E`	Jump to the next failure line in the job trace (fetches the trace first when it is not shown)	`jump_to_failure`
`o`	Open job in browser	`open_in_browser`
`e`	Open job trace in `$EDITOR`	`view_trace_editor`
`p`	Switch to pipeline selector	`enter_pipeline`
`s`	Select all jobs in the current stage	`select_stage`
`w`	Toggle trace word wrap	`toggle_trace_wrap`
`f`	Follow the trace of a running job: every 5 seconds, append what the log gained (GitLab asks only for the new bytes)	`toggle_trace_follow`
`m`	Collapse / expand matrix jobs	—
`Space`	Check/uncheck job for bulk retry/cancel	`select_job`
`Esc` / `Backspace`	Go back (trace → jobs → pipelines)	—
`j` / `↓`	(in trace view) scroll down	—
`k` / `↑`	(in trace view) scroll up	—
`PageDown` / `PageUp`	(in trace view) page down / up	—
`Ctrl+d` / `Ctrl+u`	(in trace view) scroll half page down / up	—
`Home` / `End`	(in trace view) jump to top / bottom	—

glab-tui reads at most the first 16 MiB of a job log. A longer one is marked [TRUNCATED: first 16 MiB] in the pane title (press o to open the full log in the browser). A diff larger than 32 MiB is refused with an error rather than shown in part.

Runners tab

Remappable via [keybindings.runners] in config.toml. Pause, resume and edit are GitLab-only: GitHub's runner API has no pause, resume or description endpoint, so on GitHub these keys do nothing. The tab lists a single repository's runners, so it is unavailable in group scope.

Key	Action	Config
`p`	Pause selected runner	`pause`
`r`	Resume (un-pause) selected runner	`resume`
`e`	Edit runner description (inline text input)	`edit_description`
`o`	Open runner in browser	`open_in_browser`
`s`	Cycle the Status filter: Online, Paused, Offline, all (Online, Offline, all on GitHub, whose runners cannot be paused)	`cycle_status`
`y`	Copy runner URL	`copy_url`
`Y`	Copy runner ID	`copy_id`

The preview lists each runner's type (instance, group or project), tags, version, last contact, IP address and URL. On GitLab the tags, version, last contact and IP address come from one glab api graphql query over the project's runners, and the IP address only appears when a runner manager reports one (GitLab 17 and later no longer report the runner's own IP). On GitHub the runner's labels are its tags, and type, version, last contact and IP address are not available. A runner that is paused shows PAUSED whatever its connection state. The Tags column (shown by default) can be searched and filtered by tag from the column configurator, where the Type, Version and Last Contact columns can be enabled too.

Releases tab

Remappable via [keybindings.releases] in config.toml.

Key	Action	Config
`Enter`	View release details in terminal	—
`n`	Create a new release (tag, name, description)	`create_release`
`e`	Edit selected release	`edit_release`
`d`	Delete selected release (with confirmation)	`delete_release`
`o`	Open release in browser	`open_in_browser`

Milestones tab

Remappable via [keybindings.milestones] in config.toml.

Key	Action	Config
`n`	Create new milestone (title, description, start & due date)	`create_milestone`
`e`	Edit selected milestone	`edit_milestone`
`c`	Close selected milestone	`close_milestone`
`r`	Reopen selected milestone	`reopen_milestone`
`d`	Delete selected milestone (with confirmation)	`delete_milestone`
`o`	Open milestone in browser	`open_in_browser`

Todos tab

On GitLab this tab shows Todos, on GitHub it shows Notifications. It lists unread items only until r toggles read (GitHub) or done (GitLab) items on, and the tab title shows the active filter (Unread / All). Every action updates the list as soon as the CLI call succeeds, and a failed call raises an error toast.

The State and Type columns are badges (NEW / READ, Issue / MR or PR). p opens the preview, which renders the comment that triggered the item as Markdown, or the target's description when there is none, with the reason and author. GitLab todos carry it in the list. GitHub fetches the latest comment (or the issue / PR body) once the cursor rests on a notification.

Select items with Space, or with v and the cursor (yazi-style), then press Enter or d to mark every selected item read or done in one go. Esc clears the selection.

Remappable via [keybindings.todos] in config.toml.

Key	Action	Config
`Enter`	Mark item as read and jump to its issue / MR in the item's own project (an item outside the current scope reports an error instead and stays unread, open it with `o`). With a selection, marks every selected unread item read without leaving the tab	`mark_as_read`
`d`	Mark item (or every selected item) as done (GitHub removes it from the inbox. GitLab has no read state, so read and done are the same there)	`mark_as_done`
`A`	Mark all items as read (with confirmation)	`mark_all_as_read`
`U`	Unsubscribe from the item's thread (GitLab: issues and MRs only)	`unsubscribe`
`r`	Toggle showing read / done items	`toggle_show_read`
`o`	Open item in browser	`open_in_browser`
`Space`	Toggle the item in the selection	`select_todo`
`v`	Toggle select mode (paint selection while navigating)	`selection_toggle`
`Ctrl+a`	Select every filtered item	`select_all`
`y`	Copy the target's URL	`copy_url`
`Y`	Copy the target's reference (`#123`, or `!456` for a GitLab MR). Targets glab-tui has no view for, such as releases or check suites, have none	`copy_reference`
`p`	Show / hide the preview	`toggle_preview`

Branches tab

Remappable via [keybindings.branches] in config.toml.

Key	Action	Config
`n`	Create a new branch (prompts for name; based on the selected branch)	`create_branch`
`d`	Delete selected branch or bulk delete marked branches (with confirmation)	`delete_branch`
`C`	Checkout / switch to branch	`checkout_branch`
`m`	Create Merge Request / Pull Request from branch	`create_mr`
`Space`	Toggle branch selection	`select_branch`
`v`	Toggle select mode (yazi-style contiguous selection)	`selection_toggle`
`Ctrl+a`	Select all visible branches	`select_all`
`y`	Copy selected branch name	`copy_branch`
`o`	Open branch in browser	`open_in_browser`

Environments tab

Enter lists the highlighted environment's deployments, newest first, above the selected deployment's details, and moves the focus to them: j/k, Home/End then select a deployment instead of an environment. Tab moves the focus back and forth, Esc returns it to the environment list. While deployments are listed Tab is taken, so open the Configure View with ,. Selecting another environment drops the listed deployments.

Remappable via [keybindings.environments] in config.toml.

Key	Action	Config
`Enter`	List the selected environment's deployments and focus them	`view_deployments`
`Tab`	Move the focus between the environment list and its deployments	`focus_deployments`
`R`	Roll back to the selected deployment (with confirmation). GitLab re-runs the deployment's job. GitHub creates a deployment record of its commit, which only deploys if a workflow runs `on: deployment`	`rollback_deployment`
`e`	Open the selected deployment's job log in `$EDITOR`. GitLab only: hidden on GitHub, whose deployments carry no job	`view_deployment_log`
`d`	Stop the environment (with confirmation). GitLab runs its stop action. GitHub, which has no stop, marks its live deployment (the newest whose latest status is success) inactive	`stop_environment`
`y`	Copy the environment's external URL	`copy_url`
`o`	Open environment in browser	`open_in_browser`

Terminal tab

Logs every glab / gh command the TUI executes and the git calls its backends make, with success/failure status. The log keeps the most recent 1,000 entries and drops older ones. The search bar (/ or f) filters it by command or status, and s narrows it to failed or successful commands. Without wrapping, the bottom row of the view is highlighted and is the entry the inspect, copy and re-run keys act on. While wrapping, they act on the newest entry.

Enter (or P) opens the command inspector: the full command line, exit code, start time, duration, the error, and the command's stderr and stdout (each kept up to 16 KiB). y, Y and r work inside it too, on the inspected entry. Re-running asks for confirmation, runs the exact recorded glab / gh / git call again (including the request body of an api --input - call) and logs it as a new Rerun: entry. It does not refresh any tab. Entries that only describe an action, such as custom commands, record no call and cannot be re-run.

Remappable via [keybindings.terminal] in config.toml.

Key	Action	Config
`j` / `↓`	Scroll log down	—
`k` / `↑`	Scroll log up	—
`Enter` / `P`	Inspect the highlighted entry (`P` is fixed)	`inspect_command`
`s`	Cycle the status filter: All, Errors, Success	`cycle_status_filter`
`r`	Re-run the highlighted entry's `glab` / `gh` / `git` call after a confirmation	`rerun_command`
`w`	Toggle line wrapping	`toggle_wrap`
`y`	Copy the highlighted entry's command line to the clipboard (the newest entry while wrapping)	`copy_command`
`Y`	Copy the highlighted entry's output (stdout, then stderr), or its error when it printed nothing	`copy_output`
`C`	Clear the log	`clear_log`

In the inspector, j/k, g/G and the [keybindings.global] scroll keys (J/K, Home/End, PageUp/PageDown, Ctrl+d/Ctrl+u) scroll, and Esc, q, Enter or P close it.

Selector overlays (labels, assignees, etc.)

Searchable multi-select popups are used for choosing labels, assignees, reviewers, milestones, and for value-based column filtering (see Filtering, Grouping & Columns).

Selector keys are fixed and not remappable in config.toml.

Key	Action
`j` / `↓`	Move down
`k` / `↑`	Move up
`Space`	Toggle selection
`f` / `/` / `i`	Enter filter/search mode
`Backspace`	Delete last character in filter
`Enter`	Confirm selection and apply
`Esc`	Cancel and return to edit menu

If you type a value that doesn't exist in the list, a + Create "…" option appears at the top, letting you create a new label inline.

Dependencies

Crate	Version	Purpose
`ratatui`	0.30.2	TUI rendering framework
`crossterm`	0.29.0	Cross-platform terminal I/O and event streaming
`tokio`	1.53 (full)	Async runtime for concurrent data fetching
`serde`	1.0 (derive)	Serialization / deserialization
`serde_json`	1.0	Parsing JSON responses from `glab api`
`toml`	1.1	Parsing `config.toml` and theme files
`anyhow`	1.0	Ergonomic error handling
`async-trait`	0.1.92	Async trait support for Backend trait
`clap`	4 (derive)	CLI argument parsing for subcommands
`serde-saphyr`	1.1 (deserialize)	Parsing `workflow_dispatch` inputs from GitHub workflow files
`chrono`	0.4	Timestamp formatting ("2 hours ago")
`tempfile`	3.10	Temporary files for editor integration
`fuzzy-matcher`	0.3	Fuzzy search/filter across table columns
`syntect`	5	Syntax highlighting in diff and preview panes
`pulldown-cmark`	0.13.0	CommonMark and GFM markdown renderer for details panes
`arboard`	3.6	System clipboard integration for copy shortcuts
`libc`	0.2	POSIX process management and terminal session isolation

All API calls are made by shelling out to gh api or glab api (depending on the repository host; you only need the CLI matching the service you use) — no personal access token or direct HTTP client is required inside the binary.

Project Structure

src/
├── main.rs          # Entry point, event loop, all key-binding handlers
├── app.rs           # App state, Tab enum, DiffView, DatePicker, filtering logic
├── config.rs        # Config/Theme loading, keybinding structs, TOML generation
├── event.rs         # Async event handler (keyboard, tick, async data events)
├── fetch.rs         # Per-tab data-fetching dispatch
├── git_helpers.rs   # Git remote parsing, current branch, workflow file detection
├── editor.rs        # External editor integration ($EDITOR)
├── entity_editor.rs # Edit-menu field change logic
├── templates.rs     # Default issue/MR/PR description templates
├── cli.rs           # CLI subcommands (doctor, clean-cache, cache, open, repos, review)
├── cli/review.rs    # `review` subcommand: threads/comment/submit/reply/resolve as JSON
├── themes/          # Bundled theme TOML files
├── backend/         # CLI backend layer
│   ├── mod.rs       # Backend trait (~40 methods)
│   ├── glab.rs      # GlabBackend — shells out to glab CLI
│   └── gh.rs        # GhBackend — shells out to gh CLI
├── domain/          # Domain models + API logic
│   ├── mod.rs       # Module declarations
│   ├── client.rs    # GitlabClient wrapper (backend + page_size + event tx)
│   ├── issues.rs    # Issue struct + list/get/create/edit
│   ├── mr.rs        # MergeRequest/PR, DiscussionNote, NotePosition
│   ├── review.rs    # ReviewEvent + DraftComment, shared by the diff view and `review`
│   ├── pipelines.rs # Pipeline + Job types, dedup, retry logic, unit tests
│   ├── runners.rs   # Runner type + list/edit logic
│   ├── releases.rs  # Release type + list/create/edit
│   ├── milestones.rs# Milestone type + list/edit
│   ├── notifications.rs # Todo/notification type + list
│   ├── branches.rs  # Branch type + list/create/delete
│   └── deployments.rs # Environment + Deployment types
├── handlers/        # Keypress handlers
│   ├── mod.rs
│   ├── tabs.rs      # Per-tab keybinding handlers
│   └── overlays.rs  # Overlay keybinding handlers
├── ui/              # Ratatui render functions
│   ├── mod.rs       # Re-exports
│   ├── inspector.rs # Unified entity inspector (preview/edit single-column layout)
│   ├── tabs.rs      # Tab-specific render functions
│   ├── overlays.rs  # Overlay render functions (SubmitDialog, selectors, date picker)
│   ├── helpers.rs   # Shared UI helpers (badge styling, fuzzy cells)
│   ├── diff.rs      # Diff view render functions
│   └── modal.rs     # Unified modal component
└── utils/
    ├── mod.rs
    ├── cache.rs     # Offline caching
    ├── format.rs    # Time formatting, tab expansion, text wrapping
    ├── markdown.rs  # CommonMark and GFM Markdown rendering
    ├── ui.rs        # StatefulTable generic helper
    └── update.rs    # GitHub releases self-updater (curl, checksum-verified) with multi-target Linux selection

Running Tests

cargo test

Unit tests live in several modules:

src/domain/pipelines.rs — pipeline job deduplication and stage-ordering logic.
src/domain/mr.rs — discussion note and review comment logic.
src/app.rs — selector fuzzy-matching and filter logic.

Releasing

Releases are prepared and distributed from a maintainer's machine; CI only builds the cross-platform release binaries.

scripts/release.sh [patch|minor|major|nightly]   # default: patch

scripts/release.sh walks the whole release in one pass: it bumps the crate version, regenerates CHANGELOG.md/AGENTS.md/README.md and the demo GIFs via a headless opencode run, opens a chore: prepare release vX.Y.Z PR, pauses for you to review it, squash-merges it, tags and pushes the version, waits for the CI release build, then writes the release notes and pushes the Homebrew formula, Scoop manifest, Docker image, and crate.

Prerequisites: gh (authenticated), opencode, cargo (docker for the final publish step), jq, and vhs/ttyd/ffmpeg/JetBrainsMono Nerd Font for the demo recordings. The script fails fast with a clear message when a prerequisite is missing.

Contributing

Fork the repo and create a feature branch.
Keep commits atomic and follow Conventional Commits.
Run cargo fmt and cargo clippy -- -D warnings before opening a PR.
Add or update tests where relevant (run unit tests with cargo test --lib --bin glab-tui and e2e tests with cargo nextest run --test e2e, which needs cargo-nextest).

Development & Tasks (`just`)

The repository includes rust-toolchain.toml to automatically pin the Rust version (1.88.0) and required components (clippy, rustfmt, llvm-tools-preview) via standard rustup.

A Justfile is provided for running common tasks that mirror CI:

just check      # runs fmt check, clippy, unit tests, and single-threaded e2e tests (mirrors CI)

Available recipes:

just run [args] — run a debug build, passing args to glab-tui
just build — build the release binary (target/release/glab-tui)
just install — build, then copy the binary to the first directory in PATH
just fmt / just fmt-check — format code or verify formatting
just lint — run Clippy with -Dwarnings
just test — run unit tests (cargo test --lib --bin glab-tui)
just e2e — run the e2e mock suite, one process per test (cargo nextest run --test e2e, requires cargo-nextest)
just deny — check advisories, licenses, duplicate versions and sources (requires cargo-deny)
just fuzz <target> — fuzz diff_parser, markdown or ansi_trace for 60 seconds (requires nightly and cargo-fuzz)
just check — run the full CI check matrix locally
just cov — generate test coverage summary (requires cargo-llvm-cov)

License

MIT

Name		Name	Last commit message	Last commit date
.cargo		.cargo
.github		.github
assets		assets
docs		docs
examples		examples
fuzz		fuzz
scripts		scripts
src		src
tests		tests
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
Cargo.lock		Cargo.lock
Cargo.toml		Cargo.toml
Dockerfile		Dockerfile
Justfile		Justfile
LICENSE.md		LICENSE.md
README.md		README.md
deny.toml		deny.toml
install.ps1		install.ps1
install.sh		install.sh
rust-toolchain.toml		rust-toolchain.toml

Latest commit

History

Folders and files

Repository files navigation