glimpse

A lightweight, git-native desktop Git client — the full branch graph, diffs, and everyday git, with first-class WSL support

---

# glimpse drives your real git, per repo — automatically:
git -C C:\dev\repo log --graph                               # a Windows-path repo → Windows git
wsl.exe -d Ubuntu --cd /home/you/repo --exec git log --graph # a \\wsl$ repo → that distro's git

That's it. A slim, fast desktop client that shells out to your own git — no reimplemented engine, no Chromium, and on Windows it transparently uses WSL git for repos that live in the WSL filesystem.

✨ Features

• 🪶 Featherweight — built on Tauri, it uses the OS-native WebView (WebView2 / WebKitGTK) instead of bundling Chromium. Small disk and RAM footprint.
• 🧬 Git-native — never reimplements git; it shells out to your real git binary and parses its porcelain output. Your config, hooks, and credentials apply unchanged, glimpse stores no secrets, signs commits and tags with your GPG/SSH key when configured, and Git LFS-tracked files are detected and surfaced.
• 🪟 First-class WSL (Windows) — a \\wsl$ repository is driven through that distro's git automatically, while Windows-path repos use Windows git. No setup; a per-repo override can still pin the git binary or WSL distro.
• 📂 Get a repo — open a local folder, clone a remote, or init a brand-new repository.
• 🌳 Graph & history — the full multi-branch commit graph, history search by message or content (pickaxe -S/-G), per-commit detail, GPG/SSH signature verification, and a repository-statistics panel (contributors, activity, file churn).
• 🔍 Rich diffs — side-by-side, unified, or whole-file, with syntax highlighting, word-level diff, collapsible unchanged regions, soft word-wrap, image diffs (side-by-side / onion-skin), ignore-whitespace, blame, and file history.
• ✏️ Stage & commit — stage/unstage by file, hunk, or line, discard, commit, amend (optionally signed, with an opt-in conventional-commit composer), and resolve conflicts whole-file or with a region-by-region three-way merge editor.
• 🗂️ Changelists & a CLI — group pending changes into named sets (JetBrains-style) and commit one set at a time. Membership is stored as a git-native, human-readable JSON file, and a bundled headless glimpse cl command lets scripts and AI agents read and drive the same changelists from the terminal.
• 🌿 Branches, tags & stashes — create/switch/rename/delete branches, merge, cherry-pick, revert, reset (soft/mixed/hard), annotated/signed tags, and stash save/pop/apply/drop.
• 🛠️ Advanced git — rebase (interactive or onto a ref), guided bisect, compare any two refs or two selected commits, reflog recovery with one-click undo, export/apply patches, plus worktrees, submodules, and sparse-checkout.
• 🔄 Live refresh — a debounced filesystem watcher repaints status, diff, and graph as files change, with manual and on-window-focus refresh as fallback.
• ⌨️ Fast workflow — command palette, global fuzzy quick-open (files / branches / commits), keyboard shortcuts, drag-reorderable multi-repo tabs, a resizable sidebar, recent repos, and "open in editor / terminal / file manager".
• 🌓 Themed & localized — dark/light follows the OS (manually switchable), with a localized UI.

Full feature list

• Repositories — open a local folder, clone a remote, or initialise a new repository.
• Viewing — multi-branch commit graph, commit search by message or content (pickaxe -S/-G), side-by-side / unified / whole-file diffs with syntax highlighting, word-level diff, collapsible unchanged regions and soft word-wrap, image diffs (side-by-side / onion-skin), ignore-whitespace, blame, file history, list/tree file view, compare any two refs or two selected commits, repository statistics (contributors / activity / churn), GPG/SSH signature verification status, Git LFS-tracked files flagged.
• Staging & commits — stage / unstage by file, hunk, or line, discard by file or hunk, discard all, commit, commit --amend, optional GPG/SSH commit signing, an opt-in conventional-commit composer (toggleable globally or per repo), conflict resolution (use ours/theirs, mark resolved, or a region-by-region three-way merge editor).
• Changelists — group pending changes into named lists over one working tree (file-level, JetBrains-style; a permanent Default list, new changes routed to the active list), commit one list at a time without staging the rest. Enabled by default (toggle in Settings → Git for the classic staged/unstaged view). Membership is persisted git-natively (<git-dir>/glimpse/changelists.json, versioned and human-readable) and drivable from a bundled headless CLI (glimpse cl ls|add|mv|rm|active|commit, with --json and -C <dir>) for scripts and AI agents. An opt-in extra lets you review & commit only selected hunks of a list from the GUI.
• Branches & tags — create / switch / rename / delete branches, branch from a commit, publish (set upstream), merge in either direction, create / delete / push tags (lightweight, annotated, or signed), checkout a commit (detached HEAD).
• History rewriting — cherry-pick / revert (one or many commits, incl. merge reverts), reset (soft / mixed / hard), rebase onto another ref or interactively (reword / squash / fixup / drop / reorder), guided bisect, reflog recovery view with undo-last-action, export commits as .patch and apply patches (am / apply).
• Stash — save (selected paths, optionally including untracked), pop, apply, drop, preview contents.
• Worktrees, submodules & sparse-checkout — list / add / remove / open linked worktrees, list / update / sync submodules, enable / disable and edit sparse-checkout paths.
• Remotes & sync — add / rename / remove remotes, fetch, pull (incl. rebase, with per-pull strategy), push (set-upstream, --force-with-lease), push tags.
• Git settings — global defaults, overridable per repo — git identity, commit/tag signing, the git target (auto / native / WSL distro / explicit git path), the conventional-commit composer, and SSH keys & credential helper are all configured globally; a single per-repository switch overrides any of them — including which SSH key the repo authenticates with (core.sshCommand). WSL-aware and environment-labelled, with one-click ed25519 generation.
• App — command palette, global fuzzy quick-open (files / branches / commits), keyboard shortcuts, drag-reorderable multi-repo tabs, resizable sidebar, recent repositories, open in editor / terminal / file manager, built-in auto-update.

📦 Stack

Tauri (Rust) shell + Nuxt 4 (Vue 3) SPA, Tailwind v4 + shadcn-vue, with git accessed by shelling out to the system binary.

Full stack

Layer	Choice
Desktop shell	Tauri (Rust) — OS-native WebView, no Electron/Chromium
Frontend	Nuxt 4 (Vue 3), SPA mode (ssr: false), code in app/
Styling / UI	Tailwind v4 + shadcn-vue (Reka UI)
State	Pinia — per-repo store, persisted to localStorage
Diff rendering	Custom side-by-side / unified / whole-file view; highlight.js syntax highlighting + word-level diff
Graph rendering	SVG generated from structured git log data
i18n	@nuxtjs/i18n — localized UI
Git access	System git binary (shell-out); Windows git or WSL git resolved per repo
FS watcher	Rust notify (debounced), best-effort (incl. \\wsl$)
Updates	Tauri updater against GitHub Releases

🚀 Setup

Download a build from the latest release and install it for your OS; it self-updates from there via the built-in Tauri updater.

• Windows — download glimpse_<version>_x64-setup.exe and run it. It's unsigned for now, so SmartScreen may warn: choose More info → Run anyway.
• Linux (Ubuntu/Debian) — download glimpse_<version>_amd64.deb and install it (an .AppImage and an .rpm are also provided):

  sudo apt install ./glimpse_*_amd64.deb

• macOS (Apple Silicon) — the build produces an unsigned .app bundle (no .dmg installer); extract it from the release assets and move glimpse to Applications.

Warning

The macOS build is untested and unsigned. It compiles in CI alongside Windows and Linux, but those two are the actively tested targets. Gatekeeper blocks it on first launch — right-click the app and choose Open. Use at your own risk.

Manual setup (from source)

Prerequisites: Node 24+, pnpm 11, the Rust toolchain, and the Tauri system dependencies for your platform.

git clone https://github.com/TitusKirch/glimpse.git
cd glimpse
pnpm install
pnpm tauri dev    # desktop dev shell

Tip

For fast UI iteration you can run pnpm dev (the Nuxt dev server) and open http://localhost:3000 in a browser — backend IPC is mocked when not running under Tauri.

🧬 Git-native & WSL

glimpse never reimplements git: it shells out to your real git and parses machine-readable output, so behaviour, config, hooks, and credentials are exactly your own. It stores no secrets and ships no credential UI.

On Windows it picks the right git per repository:

• a Windows path (e.g. C:\dev\repo) → Windows git;
• a WSL path (\\wsl$\<distro>\… / \\wsl.localhost\<distro>\…) → that distro's git, via wsl.exe -d <distro> --cd <linux-path> --exec git ….

The git target is a global default (auto by default) that Settings → Repository can override per repo — pinning a single repository to native git, a specific WSL distro, or an explicit git binary. Because Windows git and WSL git read separate global configs, the Git-identity panel shows the effective identity for each repo's environment; signing and SSH-key/credential-helper status are likewise read from the environment git actually runs in.

On Linux and macOS git is simply native — there is no WSL concept. Live refresh over the \\wsl$ 9P share is best-effort; the manual + on-focus refresh covers the rest.

🗂️ Changelists & automation

Changelists group your pending changes into named sets over a single working tree — like JetBrains changelists, but git-native. Each changed file belongs to exactly one list (a permanent Default list always exists; brand-new changes land in the active list), and you commit one list at a time without staging the rest. It's enabled by default in the Changes panel; turn it off in Settings → Git to get the classic staged/unstaged view back.

Membership is not locked inside glimpse — it lives in your repository, in a small, versioned, human-readable JSON file:

<git-dir>/glimpse/changelists.json

A headless CLI ships in the same binary, so the very same changelists are drivable from a terminal:

glimpse cl                                    # list changelists and their files
glimpse cl add "Refactor"                     # create a list and make it active
glimpse cl mv Refactor src/a.ts src/b.ts      # move files into a list
glimpse cl active Refactor                     # set the active list
glimpse cl commit Refactor -m "refactor: …"   # commit exactly that list's files
glimpse cl ls --json                          # machine-readable state (the file contract)

<list> matches by id or by name (case-insensitive); --json makes a command emit the JSON contract (and report errors as {"error": …}); -C <dir> targets another repository. A list-commit is index-less — it resets, stages exactly that list's files, then commits, leaving everything else dirty.

Tip

Because the state is a plain JSON file in the git directory (reachable across the \\wsl$ share on Windows) and a list-commit never touches the staging index, scripts and AI coding agents can read and drive changelists too — carving a sprawling diff into reviewable, separately-committable sets, deterministically, without the GUI.

Note

Committing only part of a file (hunk-level) is a GUI-only, opt-in extra (Settings → Git); the CLI works at file granularity. The CLI runs reliably on Linux and macOS today — on Windows its console output is still best-effort.

🧪 Development

pnpm tauri dev for the desktop shell, pnpm dev for fast browser iteration, pnpm check for the CI gate. Rust unit tests cover the risky backend logic — git output parsing and WSL path translation — and CI builds across a Linux + Windows + macOS matrix (cargo fmt --check, clippy -D warnings, cargo test, tauri build).

All commands

Command	What it does
pnpm dev	Nuxt dev server (browser-testable, mocked IPC)
pnpm tauri dev	Desktop dev shell
pnpm tauri build	Packaged binary
pnpm test	Frontend unit tests (Vitest)
pnpm lint	oxlint . --deny-warnings
pnpm format	oxfmt --check .
pnpm cargofmt	cargo fmt --check for the Rust backend
pnpm cargo:update	Refresh Rust deps within semver
pnpm cargo:outdated	Show major Rust-dep upgrades (needs cargo-edit)
pnpm cargo:upgrade	Apply major Rust-dep upgrades (needs cargo-edit)
pnpm check	lint + format + cargofmt — the CI gate
pnpm check:fix	Auto-fix lint, format, and Rust formatting

🎨 Assets & branding

Note

The logo and app icons are placeholder artwork, currently AI-generated with icongeneratorai.com — not final, temporary stand-ins to be replaced at some point, with no fixed timeline.

• Source logo: assets/logo.png (643×643). The platform icon set in src-tauri/icons/ is regenerated from it via pnpm tauri icon assets/logo.png.
• Display variants: assets/logo_256x256.png (README hero) and public/logo.png + public/logo_128x128.png (served in-app — sidebar header, About screen).

Brand colours — the logo is a deep indigo→violet gradient (hue ≈ 289°) with a white mark, read straight from the artwork:

Role	Hex	OKLCH
Gradient (dark)	#120A40	oklch(0.203 0.096 280)
Gradient (base)	#202050	oklch(0.274 0.086 279)
Gradient (violet)	#403090	oklch(0.388 0.151 285)
Mark	#FFFFFF	oklch(1 0 0)

🤝 Contributing

PRs welcome. Conventional Commits required (enforced via commitlint). Husky runs the project's linters/formatters on git commit.

Tip

Run pnpm check:fix before pushing — CI will catch what husky missed.

See CONTRIBUTING.md for the full workflow.

🛣️ Versioning

Semantic Versioning via release-please — see CHANGELOG.md.

📄 License

MIT © Titus Kirch / IT-Dienstleistungen Titus Kirch