Skip to content
CAI
Software that uses CAICheck a score

gitui-org/gitui

66.1

Adequate · 14 November 2026

43.6k

lines of production code

Rust

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a text-based user interface for Git, built in Rust, that provides a responsive, tabbed experience for managing repositories. It handles core version control operations such as viewing diffs, managing branches, committing changes, and interacting with remotes, while supporting granular actions like line-level staging and file blame. The application features a customizable UI with syntax highlighting, theming, and configurable keybindings, all powered by an asynchronous backend to ensure smooth performance during long-running Git tasks.

How it got here

2020 — Initial release and architecture overhaul

13 changes.

This period marks the initial release of gitui, introducing a text-based TUI for Git operations with a tabbed interface and theme support. The project underwent a significant architectural restructuring into a multi-crate workspace, migrating from tui to ratatui and implementing non-blocking async Git operations to ensure UI responsiveness.

2021–2024 — core feature expansion and modularization

9 changes.

This period focused on expanding the application's core Git capabilities by introducing dedicated modules for remote operations, branch management, and granular line-level staging. The architecture was significantly refactored to support asynchronous background jobs with progress tracking and to organize complex Git workflows into modular popup components. Additionally, new crates were added to handle file tree navigation, configurable key bindings, and programmatic Git hook management, enhancing both usability and testability.

Features

Add invalid\_utf8 utility to create strings with invalid UTF-8

The library now includes an \invalid\_utf8\ function that takes a string prefix and appends invalid UTF-8 bytes to it, returning a Rust \String\. This allows users to construct strings containing invalid UTF-8 sequences, which is useful for testing or handling edge cases in text processing.

invalidstring/src · high confidence

Added scopetime crate for optional scope-based runtime measurement

A new \scopetime\ crate has been introduced, providing a \scope\_time!\ macro that measures the execution time of a code scope and logs the result using the \log\ crate. The measurement is active only when the \enabled\ feature is turned on; otherwise, the macro expands to nothing, incurring no runtime overhead. The implementation uses a RAII struct (\ScopeTimeLog\) that records the start time and logs the elapsed milliseconds upon drop, including metadata such as the module path, target name, file, and line number.

scopetime/src · high confidence

Async Git operations are now non-blocking

The \asyncgit\ library has been restructured to perform Git operations asynchronously, ensuring the user interface remains responsive during potentially slow tasks. New modules such as \AsyncBlame\, \AsyncDiff\, \AsyncCommitFiles\, \AsyncLog\, \AsyncStatus\, \AsyncTags\, \AsyncBranchesJob\, \AsyncFetchJob\, \AsyncPull\, \AsyncPush\, and \AsyncPushTags\ now handle these operations in the background. This change introduces a notification system (\AsyncGitNotification\) to report progress and completion, allowing the UI to update smoothly without freezing.

asyncgit/src · high confidence

Configurable key bindings and symbol hints

Users can now customize both key bindings and the symbols displayed in UI hints. The application loads key bindings from a \key\_bindings.ron\ file and symbol definitions from a \key\_symbols.ron\ file, allowing users to override default mappings and replace default Unicode symbols (like arrows and modifiers) with custom text or symbols via configuration files or CLI arguments.

src/keys · high confidence

Initial release of gitui

The application is introduced as a new text-based UI for interacting with Git repositories. It features a tabbed interface for navigating status, commit logs, file changes, and stashes, along with support for custom keybindings, themes, and various Git operations like branching, merging, and stashing.

src · high confidence

Introduce dedicated popup components for Git operations

The application now uses a set of dedicated, modular popup components in \src/popups\ to handle specific Git workflows, replacing previous inline or less-structured implementations. This change introduces distinct UI modules for file blame (\blame\_file.rs\), branch management (\branchlist.rs\, \checkout\_option.rs\, \create\_branch.rs\), commit editing (\commit.rs\), remote management (\create\_remote.rs\), and file history (\file\_revlog.rs\), among others. Users will experience a more consistent and structured interface for these actions, with dedicated validation (e.g., branch name validation in \create\_branch.rs\), progress indicators (e.g., in \fetch.rs\), and clearer separation of concerns for complex interactions like comparing commits or handling external editors.

src/popups · high confidence

Introduce filetreelist crate with PageUp/PageDown navigation

The \filetreelist\ crate has been added to provide a file tree list component. This new module introduces support for PageUp and PageDown keybindings when navigating the file tree selection, allowing users to scroll through large directory listings more efficiently. It also includes robust error handling for invalid paths and non-UTF8 file names, ensuring the application remains stable when encountering unusual file system entries.

filetreelist/src · high confidence

Introduction of async job abstraction with progress tracking

The \asyncgit\ crate now includes a new \asyncjob\ module that provides an \AsyncJob\ trait and an \AsyncSingleJob\ struct for managing background tasks. This allows users to run time-intensive operations on a thread pool while receiving intermediate progress updates via a \RunParams\ interface, which supports sending notifications and setting progress states. The \AsyncSingleJob\ implementation handles task scheduling, ensuring only one job runs at a time and allowing cancellation of pending tasks.

asyncgit/src/asyncjob · high confidence

Introduction of the tabs module for UI layout

The \src/tabs\ directory now contains the modular implementation for the application's main interface tabs. This includes the \FilesTab\ for viewing file content at HEAD, the \Revlog\ for the revision history with commit details and search, the \Stashing\ and \StashList\ tabs for managing git stashes, and the \Status\ tab for staging changes and viewing diffs. These components replace the previous monolithic or scattered tab implementations, providing a structured way to handle visibility, updates, and user interactions for each distinct view.

src/tabs · high confidence

New UI component library with syntax highlighting and theming

The \src/ui\ module introduces a new set of UI components, including a stateful paragraph with word-wrapping and scrolling, scrollbars, scrollable lists, and a syntax highlighting engine powered by \syntect\. Users benefit from improved text rendering, customizable themes via \src/ui/style.rs\ (supporting selection colors, diff colors, and branch/tag styling), and syntax-aware code display in the file tree and diff views.

src/ui · high confidence

New branch merge strategies and branch metadata support

The branch module now supports three distinct merge strategies for integrating upstream changes: creating a merge commit (which returns None if conflicts arise), performing a fast-forward merge, and using a conflict-free rebase. Additionally, branch information structures have been expanded to include upstream tracking details and remote names, enabling the UI to display tracking status and remote associations for both local and remote branches.

asyncgit/src/sync/branch · high confidence

New git2-hooks crate for programmatic git hook management

A new \git2-hooks\ crate has been introduced to provide structured support for executing and managing Git hooks within applications using \git2-rs\. This library allows users to locate hooks based on \core.hooksPath\ configuration or standard \.git/hooks\ directories, and execute them with proper environment handling (including shell expansion and cross-platform process flags). It exposes specific hook types such as \pre-commit\, \commit-msg\, \prepare-commit-msg\, and \pre-push\, returning structured results that include exit codes and output streams, thereby enabling robust integration of Git hook logic into Rust-based tools.

git2-hooks · high confidence

New git2-testing crate for test repository generation

A new \git2-testing\ crate has been added to provide convenience functions for generating test Git repositories. It exposes public helpers like \repo\_init\, \repo\_init\_bare\, and \repo\_init\_suffix\ to create temporary repositories with optional initial commits, and includes internal logic to sandbox configuration files to prevent interference from user-local \.gitconfig\ settings during tests.

git2-testing · high confidence

New remote operations module with push, tag, and credential handling

A new \remotes\ module has been introduced to manage Git remote interactions, providing dedicated functions for adding, renaming, updating, and deleting remotes, as well as resolving default fetch and push remotes based on Git configuration. The module adds support for pushing branches and tags (including annotated tags) with progress notifications, detecting tags missing on the remote, and handling authentication via basic credentials. It also implements specific error handling for rejected force pushes and ensures credentials are not repeatedly requested on failure.

asyncgit/src/sync/remotes · high confidence

New utility modules for file trees, commit logs, and scrolling

The \src/components/utils\ module has been restructured into dedicated sub-modules to improve code organization and add new capabilities. A new \emoji\ module provides markdown-to-Unicode emoji conversion (e.g., \:hammer:\ to 🔨) for commit messages, controlled by the \ghemoji\ feature flag. The \filetree\ and \statustree\ modules introduce a new hierarchical file tree implementation with support for folder collapsing, selection retention, and navigation (including PageUp/PageDown). The \logitems\ module refactors commit log entry handling, integrating the new emoji support and improving time formatting. Additionally, \scroll\_horizontal\ and \scroll\_vertical\ modules provide reusable, state-managed scrolling logic with visual indicators for both horizontal and vertical panes.

src/components/utils · high confidence

Project configuration and documentation overhaul

The repository now includes standardized configuration files for Rust tooling and development workflows, including \.clippy.toml\ (setting MSRV to 1.88.0 and cognitive-complexity threshold), \.editorconfig\ (enforcing tab indentation for Rust), \rustfmt.toml\, \deny.toml\ (dependency security and license checks), \tombi.toml\ (TOML formatting rules), and \typos.toml\. A new \Makefile\ provides targets for building, testing, and linting, while \rust-toolchain.toml\ pins the toolchain to stable. Documentation has been restructured with new files for \CONTRIBUTING.md\, \FAQ.md\, \KEY\_CONFIG.md\, \NIGHTLIES.md\, and \THEMES.md\, alongside a comprehensive \CHANGELOG.md\ and updated \README.md\. The \build.rs\ script now supports reproducible builds via \SOURCE\_DATE\_EPOCH\ and \BUILD\_GIT\_COMMIT\_ID\ environment variables, and \.gitignore\ has been updated to exclude release artifacts and IDE files.

(repo-wide) · high confidence

Support for staging, unstaging, and discarding individual lines

Users can now selectively stage or unstage specific lines within a file's diff, as well as discard selected lines from the working directory. This change introduces new capabilities in the staging module to handle granular line-level operations, allowing for more precise control over changes before committing.

asyncgit/src/sync/staging · high confidence

Behavioural changes

Introduce dedicated commit details and compare views

The commit details panel now uses a new modular component structure to display commit information. A new \CompareDetailsComponent\ renders side-by-side details for two commits when in compare mode, while the \DetailsComponent\ handles single-commit views with improved message wrapping and scrolling. The layout logic in \mod.rs\ now dynamically adjusts the split between the commit details and the file tree based on focus state, and a new \style.rs\ module centralizes the styling for detail fields like author, date, and message.

_src/components/commit\details · high confidence

New sync API implementation for git operations

The \asyncgit/src/sync\ module has been restructured with a comprehensive new synchronous API layer. This includes dedicated modules for blame (\blame.rs\), commit management (\commit.rs\, \commit\_revert.rs\), commit details and filtering (\commit\_details.rs\, \commit\_filter.rs\, \commits\_info.rs\), file diffs and hunks (\diff.rs\, \hunks.rs\), git hooks (\hooks.rs\), and configuration (\config.rs\). The implementation introduces caching for branch names (\cached/branchname.rs\), supports GPG/SSH commit signing, handles credential extraction, and provides robust error handling and logging for core git interactions.

asyncgit/src/sync · high confidence

Rework of core UI components to use ratatui and new text input system

The \src/components\ module has been restructured to replace the previous TUI implementation with \ratatui\ and \ratatui-textarea\. This change introduces new component implementations for the changes list (\ChangesComponent\), commit log (\CommitList\), diff view (\DiffComponent\), and file tree (\StatusTreeComponent\), among others. The \TextInputComponent\ now utilizes \ratatui-textarea\ to support multiline editing, password masking, and character counting, replacing the previous text input mechanism. These components are wired together via the \mod.rs\ module, which defines the \Component\ and \DrawableComponent\ traits and manages event pumping and command gathering across the application's UI elements.

src/components · high confidence

Windows installer now includes Visual C++ runtime

The WiX installation manifest (main.wxs) has been updated to explicitly merge and install the Visual C++ 2019 (VC142) runtime alongside the gitui binary. This ensures that Windows users do not encounter missing DLL errors when running the application, as the required runtime dependencies are now bundled directly into the MSI package.

wix · high confidence

Dependencies

Project restructured into a multi-crate workspace with updated dependencies

The project has been reorganized from a single crate into a workspace containing \asyncgit\, \filetreelist\, \git2-hooks\, \git2-testing\, and \scopetime\. This restructuring introduces new dependencies such as \ratatui\ (replacing \tui\), \gix\ (replacing \git2\ for certain operations), and \bwrap\, while updating core libraries like \git2\ to 0.21, \clap\ to 4.5, and \serde\ to 1.0. The minimum supported Rust version (MSRV) has been raised to 1.88, and the main application package name has been changed to \gitui\.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 72 → 66 (-5.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 90 → 83 (-7.3)
  • Architecture 91 → 91 (+0.0)
  • Maturity 70 → 70 (+0.1)
  • Readiness 69 → 79 (+10.2)
  • Security 67 → 53 (-14.0)
  • Event Sourcing 100 → 100 (+0.0)

Resolved (19)

  • Duplicated block (10 lines × 2) (asyncgit/src/sync/cred.rs)
  • Duplicated block (10 lines × 2) (src/popups/push.rs)
  • Duplicated block (11 lines × 2) (asyncgit/src/push.rs)
  • Duplicated block (11 lines × 2) (asyncgit/src/remote_tags.rs)
  • Duplicated block (11 lines × 3) (asyncgit/src/branches.rs)
  • Duplicated block (11–12 lines × 2) (src/popups/compare_commits.rs)
  • Duplicated block (12 lines × 2) (src/popups/blame_file.rs)
  • Duplicated block (12–15 lines × 3) (asyncgit/src/blame.rs)
  • Duplicated block (14 lines × 3) (src/popups/branchlist.rs)
  • Duplicated block (14 lines × 3) (src/popups/checkout_option.rs)
  • Duplicated block (22 lines × 2) (asyncgit/src/blame.rs)
  • Duplicated block (6 lines × 2) (asyncgit/src/blame.rs)
  • Duplicated block (6 lines × 2) (src/ui/scrollbar.rs)
  • Duplicated block (8 lines × 2) (asyncgit/src/sync/remotes/mod.rs)
  • Duplicated block (9 lines × 3) (src/popups/pull.rs)
  • Flaky test: gitui::bin/gitui.gitui::tests::gitui_starts
  • No ADRs found
  • Off-boarding risk: anonymized user #1
  • Off-boarding risk: anonymized user #2

New (166)

  • Duplicated block (10 lines × 2) (asyncgit/src/sync/cred.rs)
  • Duplicated block (10 lines × 2) (src/popups/push.rs)
  • Duplicated block (11 lines × 2) (asyncgit/src/push.rs)
  • Duplicated block (11 lines × 2) (asyncgit/src/remote_tags.rs)
  • Duplicated block (11 lines × 3) (asyncgit/src/branches.rs)
  • Duplicated block (12 lines × 2) (src/popups/blame_file.rs)
  • Duplicated block (12–15 lines × 3) (asyncgit/src/blame.rs)
  • Duplicated block (14 lines × 2) (asyncgit/src/pull.rs)
  • Duplicated block (14 lines × 3) (src/popups/branchlist.rs)
  • Duplicated block (14 lines × 3) (src/popups/checkout_option.rs)
  • Duplicated block (18 lines × 2) (asyncgit/src/blame.rs)
  • Duplicated block (19 lines × 2) (asyncgit/src/sync/rebase.rs)
  • Duplicated block (22 lines × 2) (asyncgit/src/blame.rs)
  • Duplicated block (22 lines × 2) (src/components/commit_details/compare_details.rs)
  • Duplicated block (23–24 lines × 2) (src/popups/compare_commits.rs)
  • Duplicated block (6 lines × 2) (asyncgit/src/blame.rs)
  • Duplicated block (6 lines × 2) (src/ui/scrollbar.rs)
  • Duplicated block (7 lines × 2) (asyncgit/src/sync/sign.rs)
  • Duplicated block (8 lines × 2) (asyncgit/src/sync/remotes/mod.rs)
  • Duplicated block (9 lines × 3) (src/popups/pull.rs)
  • …and 146 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

gitui-org/gitui was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit d7214eccb3cac52ce3f8d9ca18f218671821eeee — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.