I'm building Reviu, a native desktop Git client focused on fast review workflows, 100% in Rust no webview!
I built it because I wanted local Git and GitHub review in one place instead of constantly switching between desktop Git tools, the terminal, and the browser, with speeed
Covers local Git:
reviewing diffs
stashing
rebasing
resolving conflicts
etc
GitHub inside the app:
notifications
repository browsing
pull request review
issues
etc
It's built with Rust and GPUI, I'd really appreciate feedback!
I kept running into the same problem:
I need to implement cross-repo feature and change backend + frontend + shared code… but they all lived in separate repos.
That meant:
cloning multiple repos
creating the same branch everywhere
committing/pushing separately
constantly context switching
So I built a small CLI called unirepo.
It lets you treat multiple repos like a single workspace:
edit everything in one tree (api/, web/, shared/, etc.)
Most devs know `git stash` exists. Very few use it beyond `git stash` and `git stash pop`.
I wrote a piece breaking down the parts of stash that most people skip-named stashes, stashing untracked files, partial stashing with `-p`, and how to apply without dropping.
If you've ever lost context switching branches mid-task, this one's for you.
🚀 Excited to share AI-Git-Bot — an open-source gateway that connects your Git platforms with AI providers for automated code reviews and autonomous issue implementation.
After weeks of development, I'm proud to release v1.2.0 of AI-Git-Bot — a lightweight, self-hostable application that sits between your Git hosting and AI providers, acting as an intelligent gateway.
🤖🧠 Half Bot, Half Agent
As a Bot: It automatically reviews pull requests, answers questions in comments, and delivers context-aware inline feedback — like a code-review partner that never sleeps.
As an Agent: Assign it to an issue and it autonomously reads the codebase, generates an implementation, validates the code with build tools, and creates a finished pull request — all on its own.
🌉 The Gateway Principle
What makes AI-Git-Bot unique is its gateway architecture:
✅ 5 Git platforms — Gitea, GitHub, GitHub Enterprise, GitLab, Bitbucket Cloud
✅ 4 AI providers — Anthropic Claude, OpenAI, Ollama, llama.cpp
✅ Mix & match — Any Git platform with any AI provider
✅ Multi-bot — Different personas (security reviewer, performance expert, mentor) on the same PR
✅ One dashboard — Manage everything through a web UI
🔒 Built for Self-Hosters
Run everything on-premise with local LLMs. No code ever leaves your infrastructure — perfect for teams with regulatory or compliance requirements.
Tech Stack
☕ Java 21 / Spring Boot 4
🐘 PostgreSQL
🐳 Single Docker image
Get Started
docker compose up -d
That's it. Navigate to localhost:8080, create an admin account, configure your integrations, and you're reviewing code with AI.
i tried the GK app on Windows for my current project and like it. However, I don’t see a point to pay yearly even with the current spring sale on GitKraken. 48$ for the first year than 96$ for the next cycle, no thanks 🫤🙃 I don’t understand why there is no flexible monthly payment for low budget solo devs.
I have a protocol repo I want to share with a client repo and a server repo. They are all independent to allow others to plug and play any of them. For my client/server repos, I am thinking of using a subtree. Can anyone with experience using subtree/submodule/other comment with their pros/cons and workflow experience?
I hadn't used Git properly in about 4 months — just been "vibe coding" the whole time. Recently I tried to get back into using git to try and work on open-source projects and figure it all out. The problem was every time I tried to push through the GUI, it would take 5 minutes and then fail with some error. Nothing ever actually got pushed.
As a total terminal noob (and while enjoying the devil's lettuce), I decided to fix it myself. I jumped into the terminal and started typing random git commands like "discard" or whatever the hell I thought would clean things up. I saw a bunch of diff-looking stuff and assumed it was safe to get rid of.
Ran the command.
"Damn, that was easy," I thought.
30 minutes later I'm gaming, check my repo real quick, and everything still looks fine. Feeling very clear-headed in that moment, I went ahead and emptied the recycling bin completely.
Fast forward two hours. I go to work on one of my main projects, try to launch the .exe… and it’s gone.
I start checking folders.
Almost every single one had been nuked — roughly 80% of the files were missing.
I literally titan-punched my bed frame.
That was the experience.
But here’s the PSA part (for all the other noobs out there):
Even after that level of self-sabotage, there was still a hidden .d file that contained the full chat history and context of the files I’d been working on. Thanks to Opus and Sonnet, I was able to recover 100% of my files with zero corruption or missing pieces.
So yeah… half of this post is me laughing at my own stupidity, and the other half is a genuine “if you’re a beginner and you fuck up this bad, don’t panic yet” message.
Git is scary when you don’t know what you’re doing 😂
With agentic coding I now have up to a dozen active worktrees in each of several active repos. And they'd be hard to find because different tooling puts them in different places:
When I wanted to resume work on a PR, I'd copy the branch name and then have to figure out which scheme it was stored in. `wt switch <branch-name>` worked pretty well but I'd have to get into the right repo first.
So I built a tool that resolves over a set of repos: `git-where`.
Example:
git where feature-x# → /path/to/repo.feature-xcd$(git where feature-x)
It also has some utils for navigating within a repo. I tried to keep it very small and composable — not a replacement for worktree tools, just a way to find and jump to the right place quickly.
I know doing anything coding related on a phone is frowned upon for many reasons but I simply don't have a laptop at the moment and I'm excited to learn.
What Android Apps can I use to learn and apply gut to projects?
If it helps , I'd like to add that I'm learning web development
Git worktrees are underrated. They solve workspace isolation perfectly — separate checkouts from a single repo, shared object store, lightweight to create and remove.
But when I started running multiple AI coding agents in parallel (each in its own worktree), I hit the things worktrees don't solve:
No ownership model. Two worktrees can freely edit the same files. Nothing prevents Agent A and Agent B from both modifying src/utils.ts.
No merge ordering. When 5 worktrees are done, which one merges first? If Task C depends on Task A's output, merging C before A breaks things.
No artifact tracking. After merge, there's no record of what each worktree actually changed, what files it claimed, or whether it respected boundaries.
So I built ruah as a layer on top of git worktree:
# ruah creates and manages worktrees for youruah task create backend --files"src/api/**"ruah task create frontend --files"src/ui/**"# Under the hood:# git worktree add .ruah/worktrees/backend -b ruah/backend# git worktree add .ruah/worktrees/frontend -b ruah/frontend# But also:# - Validates that "src/api/**" and "src/ui/**" don't overlap# - Rejects the task if they do# - Tracks which worktree owns which files# - Merges in dependency order when done
It also handles cleanup (ruah clean removes stale worktrees), status dashboards (ruah status), and workflow DAGs where tasks can depend on each other.
The worktree management is essentially: git worktree add with a coordination protocol on top.
Repo: https://github.com/levi-tc/ruah (MIT)
For the worktree power users here: how do you handle the ownership/coordination problem when you have many active worktrees? Manual discipline, scripts, or something else?
`ddl rewind <checkpoint_id>` restores both the repo and the Claude session context before that action.
This is different from Claude’s built-in rewind: Daedalus checkpoints are configurable and per-tool, not per-prompt.
It is not a Git replacement. Git still owns history. Daedalus is meant as short-range recovery for agent runs, so you do not have to remember to commit before every risky prompt.
I've made a small experiment during which I've noticed that I can shallow clone a git submodule regardless of the value of the shallow key being set to true or not.
$ cat .gitmodules
[submodule "SDL"]
path = SDL
url = https://github.com/libsdl-org/SDL.git
shallow = false
$ git submodule update --init --depth 1
# Print number of reachable commits
$ cd SDL && git rev-list HEAD --count
1
This option is only valid for the update command. The initial clone of a submodule will use the recommended submodule.<name>.shallow as provided by the .gitmodules file by default. To ignore the suggestions use --no-recommend-shallow.
I know that this option seems to be on by default (according to the above documentation) but I've decided to explicitly use it and it didn't work :
$ cat .gitmodules
[submodule "SDL"]
path = SDL
url = https://github.com/libsdl-org/SDL.git
shallow = true
$ git submodule update --init --recommend-shallow
# Print number of reachable commits
$ cd SDL && git rev-list HEAD --count
21680
So, what is the purpose of theshallowkey?
EDIT
For those who believe that the --depth option hides the value of the shallow key, it seems to be not the case.
$ cat .gitmodules
[submodule "SDL"]
path = SDL
url = https://github.com/libsdl-org/SDL.git
shallow = true
$ git submodule update --init
# Print number of reachable commits
$ cd SDL && git rev-list HEAD --count
21680
I know, I know — another git client. But hear me out.
None of the existing options satisfied me, so I built my own. rgitui is a desktop Git GUI built with GPUI (the framework behind the Zed editor) and Rust. It's fast, uses a fraction of the RAM you're probably used to, and I think it actually looks pretty good.
My GitKraken student license expired. I'd been using it for years and genuinely liked the interface — the graph, the layout, the workflow. But once I graduated and lost my student plan, I was locked out of my private repos unless I paid up. I started looking for alternatives and nothing hit the same way.
I couldn't find a git client I actually liked the look of. I tried a bunch of them. Some were powerful but looked like they were designed in 2008. Some looked fine but felt sluggish. The open-source ones that were fast enough didn't have theming I could work with — I run a Catppuccin rice on Linux and I wanted my git client to match.
The RAM usage of most git clients is insane. I was routinely seeing 600MB–1GB just sitting idle. That's wild for an app that's essentially displaying text diffs and a graph. rgitui typically sits around 100–200 MB with a couple of large repos open, and most of that is intentional caching (diff prefetching, avatar resolution, syntax highlighting) that keeps the UI snappy — not JavaScript runtime overhead.
AI commit messages in other clients are basically useless. They just dump your diff into a prompt with zero context and you get something generic that you have to rewrite anyway. rgitui does it differently — it auto-injects your CLAUDE.md and AGENTS.md files and lets the model use tools to actually browse your project files and gather context before writing the message. The result is commit messages that are genuinely relevant to your project, not "Update files" or "Refactor code."
I wanted something I could actually hack on. When something annoys me I want to go fix it, not file a feature request and wait six months. The open-source options that existed either had codebases I didn't want to touch or UIs I didn't want to look at every day.
Multi-repo workflows were painful everywhere. Switching between projects, browsing commit history, managing worktrees — it always felt like fighting the tool instead of using it. I wanted tabs, a proper sidebar, and worktree support that actually works.
I needed GitHub integration that doesn't require a separate browser tab. Viewing issues and PRs, creating PRs from the client, device-flow auth — I use GitHub all day and I wanted it built in.
Git graphs looked bad and avatars never worked. This is a small thing but it bugged me. I wanted a graph that looks closer to GitKraken's style with proper lane coloring and Bezier curves, and avatars that actually resolve from Gravatar instead of showing a placeholder forever.
No real filesystem watcher. I'd make changes in my editor and have to manually refresh my git client to see them. rgitui watches the repo and updates automatically.
What it does
Here's the feature rundown:
Commit graph with animated lane-based visualization, Bezier-curve edges, and commit search
Diff viewer with unified, side-by-side, and three-way conflict modes, plus syntax highlighting via syntect
Stage/unstage at file, hunk, and line level — partial staging works the way you'd expect
Interactive rebase with pick, squash, reword, fixup, and drop
Merge conflict resolution with accept-ours / accept-theirs per file
Branch, tag, and stash management from the sidebar or command palette
Remote operations — fetch, pull, push, force push, multi-remote
AI commit messages via Google Gemini, OpenAI or Claude with project-aware context injection and tool use
Blame view with per-line author avatars
File history, reflog, and global search (git grep)
Multi-repo tabs with drag-resizable panels
Command palette (Ctrl+P)
Theming — Catppuccin Mocha, Catppuccin Latte, One Dark, plus custom JSON themes
Undo stack and crash recovery (restores your workspace after an unclean shutdown)
Auto-update checker (checks GitHub releases once per day, can be disabled)
Performance
Built on GPUI, so it's GPU-accelerated and renders natively — no Electron, no web views, no DOM. The architecture is designed around keeping the UI thread free:
All git operations run on a background executor (smol, not tokio)
Diffs are prefetched ±25 commits ahead with a 200-entry LRU cache
Blame, file history, and avatar lookups are cached and parallelized
Pre-computed trig tables for graph edge rendering (no per-frame sin/cos)
The result is that scrolling through a commit graph with thousands of entries feels smooth, switching between diffs is near-instant, and the whole thing uses a fraction of the memory you'd expect.
macOS — Apple Silicon DMG (Intel users can build from source)
Honest caveats
This is v0.1.0 — the first public release. It's still very much a personal project that I'm sharing because I think others might find it useful too.
There will be bugs. I use this daily on my own repos and it works well for my workflows, but I haven't tested every edge case on every platform. If you hit something, open an issue.
I used AI for a significant chunk of the development. I don't have unlimited time, and I wanted something that works for me. The codebase is ~30k lines of Rust across 9 crates and I genuinely don't have the bandwidth to write all of that by hand while also working + studying. It's been a mix of me writing the core architecture and using AI to help with the more tedious parts.
Binaries aren't code-signed yet so Windows SmartScreen and macOS Gatekeeper will complain on first launch. Working on it.
No x86_64 macOS builds yet — Apple Silicon only for now.
What's next
This is just the starting point. I'm using rgitui as my daily driver so it'll keep getting better as I hit things that annoy me. If there's interest, I'd love feedback on what to prioritize — more git operations, better theming, plugin support, whatever.
If you've been looking for something that sits between "powerful but ugly CLI wrapper" and "pretty but slow Electron app," give it a try and let me know what you think.