How I built an AI-powered Git context menu for Windows using Tauri and Rust

Source: Dev.to

GitPop is a lightweight Windows File Explorer extension that adds a modern Git commit UI to your right‑click menu, with an optional local AI commit generator.

GitPop on GitHub

What GitPop Does

From File Explorer, right‑click inside any repository folder and choose GitPop Here to open a small popup that lets you:

• See changed files instantly
• Stage and unstage with a clean UI
• Review diffs (without switching to a separate app) – Coming soon
• Generate commit messages from staged diffs using local models via Ollama (or your preferred API)

The core goal is simple: make the “small commit” workflow as fast as a shell command, but less blind.

Tech Stack & Why Tauri

For a context‑menu popup, startup time is the most important metric. If right‑clicking a folder and selecting GitPop Here feels sluggish, the experience is broken.

I ruled out Electron because it ships a full Chromium runtime, leading to large binaries and higher memory usage. Tauri uses the system webview (WebView2 on Windows) with a Rust backend, which satisfies the “open instantly” requirement far better.

The Engineering Challenges

Windows integration looks simple from the outside, but there are a few spicy corners. These were the big three.

1. Registering a File Explorer Context‑Menu Entry (from Rust)

To show GitPop Here in the right‑click menu, GitPop registers a command in the Windows Registry. Instead of asking users to run a .reg file, GitPop does this programmatically in a “Setup Mode” using the winreg crate.

use winreg::enums::*;
use winreg::RegKey;

#[tauri::command]
fn install_context_menu() -> Result {
    let hkcu = RegKey::predef(HKEY_CURRENT_USER);

    let exe_path = std::env::current_exe()
        .map_err(|e| e.to_string())?
        .to_string_lossy()
        .into_owned();

    // Path for the background (right‑click on empty space) entry
    let bg_path = r"Software\Classes\Directory\Background\shell\GitPop";
    let (bg_key, _) = hkcu.create_subkey(bg_path)
        .map_err(|e| e.to_string())?;

    bg_key.set_value("", &"GitPop Here")
        .map_err(|e| e.to_string())?;
    bg_key.set_value("Icon", &format!("\"{}\"", exe_path))
        .map_err(|e| e.to_string())?;

    // Command that runs the executable; %V resolves to the clicked folder
    let (bg_cmd, _) = bg_key.create_subkey("command")
        .map_err(|e| e.to_string())?;
    bg_cmd.set_value("", &format!("\"{}\" \"%V\"", exe_path))
        .map_err(|e| e.to_string())?;

    Ok(())
}

Why this approach works well

• Self‑contained and reversible – no external .reg files.
• No admin rights required (per‑user install).
• Doesn’t interfere with existing Git configurations.

2. The “Flashing Terminal” Bug When Spawning Git on Windows

GitPop prefers the native Git CLI (git status, git diff, git commit, …) so it automatically respects the user’s SSH keys, credential helpers, hooks, and global config.

On Windows, calling Command::new("git") directly can cause a brief CMD window to flash, which feels janky.

The fix is to set the CREATE_NO_WINDOW flag when spawning the process:

use std::process::Command;

#[cfg(target_os = "windows")]
use std::os::windows::process::CommandExt;

#[cfg(target_os = "windows")]
const CREATE_NO_WINDOW: u32 = 0x08000000;

/// Returns a `Command` that runs the given program hidden on Windows.
fn build_hidden_cmd(program: &str) -> Command {
    let mut cmd = Command::new(program);

    #[cfg(target_os = "windows")]
    {
        cmd.creation_flags(CREATE_NO_WINDOW);
    }

    cmd
}

All Git calls now use build_hidden_cmd("git") instead of Command::new("git"), eliminating the flash.

3. Tauri v2 Capabilities, Window Transparency, and the Invisible‑App Trap

I wanted a transparent, glassy popup, which requires:

{
  "transparent": true,
  "visible": false   // start hidden to avoid a white flash while React loads
}

The window is shown once the UI is ready (window.show()).

However, Tauri v2 locks down frontend APIs by default. Without the proper capability permissions, the window stays invisible while the process runs fine in the background.

The fix is to explicitly allow the needed window operations in capabilities/default.json:

{
  "permissions": [
    "core:window:default",
    "core:window:manage",
    "core:window:visibility",
    "core:window:transparent"
  ]
}

With these permissions, the transparent popup appears instantly and behaves as expected.

TL;DR

• GitPop gives you visual staging and instant commit generation right from Explorer.
• Built with React + TypeScript (frontend) and Rust (backend) on Tauri v2 for ultra‑fast startup.
• Key engineering hurdles (registry registration, hidden Git process, Tauri capabilities) are solved with concise Rust snippets and proper Tauri config.

{
  "permissions": [
    "e:window:allow-show",
    "core:window:allow-close",
    "process:allow-exit"
  ]
}

Fullscreen Controls

Enter fullscreen mode
Exit fullscreen mode

This is one of those “security‑first” defaults that is correct, but it will absolutely prank you the first time you try to do anything window‑related.

The Sparkle Button: AI Commit Generation (Locally, by Default)

Writing commit messages is a small task, but it adds friction. GitPop’s ✨ Sparkle button reduces that friction:

1. Stage files – GitPop runs git diff --cached.
2. Generate a commit message – The staged diff is sent to an LLM to propose a commit message.

Privacy‑First Model Choice

Shipping proprietary diffs to a cloud API is a non‑starter for many developers. Therefore, GitPop defaults to Ollama, running locally. It detects installed models (e.g., llama3.2 or qwen2.5-coder) and generates commit messages without API keys, paid tokens, or network calls.

GitPop also supports:

• OpenAI
• Anthropic
• Gemini
• Custom endpoints

The model selection is an implementation detail; the UX goal is consistent: stage → sparkle → commit → done.

Try It Out

If you are on Windows (macOS support coming soon) and this fits your workflow, grab the latest installer from the repository:

GitHub: https://github.com/vinzify/gitpop

Feedback, issues, and pull requests are welcome. I am also exploring what it would take to bring the same “right‑click commit UI” to macOS Finder, where the integration constraints differ but the pain is identical.

Happy committing!