The git toolset
you've been missing
AI-powered commits. Visual history. Conflict detection before it's too late. A release pipeline that just works. Machete cuts through git complexity so you can focus on shipping.
App screenshot goes here
Features
Everything you need.
Nothing you don't.
AI-Powered Commits
Generate Conventional Commits messages from your staged changes using Claude. Understands context, follows your project's patterns, and writes meaningful commit messages in seconds.
AI-Powered Pull Requests
Create pull requests with AI-generated titles and descriptions. Summarises changes, highlights key decisions, and structures the PR for fast review.
Visual Git Graph
See your entire commit history as an interactive visual graph. Branch relationships, merge points, and commit details at a glance.
Conflict Radar
Detect merge conflicts before they happen. Scans your branches proactively and shows exactly where conflicts will occur, so you can resolve them on your terms.
Time Machine
Visual undo and redo powered by the reflog. See a timeline of every action, with safety analysis and one-click restore. Never lose work again.
Stacked PRs
Manage dependent pull requests with cascade rebase, sync preview, and branch dependency tracking. Ship large features as reviewable increments.
Release Pipeline
Full git-flow releases: version bump, changelog generation, branch and tag management, GitHub releases, and publish. One click, zero mistakes.
Branch Pruning
Safely clean up merged branches with squash-merge detection and 3-phase commit reachability analysis. No force flags — prune is always safe by design.
GitHub Native
Deep GitHub integration built in. Pull requests, issues, Actions, releases, notifications, and billing — all without leaving your git client.
AI-Powered Commits
You just finished a complex refactor across six files. The diff is clear in your head right now, but in thirty seconds you'll be context-switching to the next task. Writing a good commit message feels like a tax on your momentum.
Machete sends your staged diff and your last five commit messages to Claude. It doesn't just summarise the changes — it reads the diff like a developer would, understands the intent behind the code, and writes a Conventional Commits message that matches your project's existing style.
You see the message before anything is committed. Edit it, accept it, or regenerate. Your commit history stays clean without the mental overhead.
- Analyses your staged diff with Claude to understand intent, not just line changes
- Reads your recent commits to match the voice and conventions of your repo
- Generates Conventional Commits format — type, scope, and a concise summary
- Preview and edit before committing — nothing happens without your approval
- Dry-run mode for reviewing what would be generated without touching the repo
✦ Generating commit message...
feat(auth): add JWT refresh token rotation with sliding expiry
- Add RefreshTokenService with configurable TTL and rotation logic
- Update AuthMiddleware to intercept expired access tokens
- Add migration for refresh_tokens table with composite index
- Wire up /auth/refresh endpoint in router
● Accept ◐ Edit ○ RegenerateMachete commit view showing AI-generated message with diff context
AI-Powered Pull Requests
A good pull request tells a story. It explains what changed, why it changed, and how to verify it works. But after a long feature branch, the last thing you want to do is write a detailed summary of work you've already done.
Machete gathers every commit since your base branch, the full diff stats, and the list of changed files, then sends it all to Claude. What comes back is a structured PR description: a concise summary, a file-by-file breakdown of changes, and a test plan checklist — formatted exactly how reviewers want to read it.
The generated title follows imperative mood and stays under 70 characters. The body is structured with Summary, Changes, and Test Plan sections. You can review and edit in your preferred editor before the PR is created.
- Synthesises all commits into a coherent narrative — not just a commit log dump
- Auto-detects the base branch from config, remote, or prompts you to choose
- Structured output: Summary, Changes per file, and Test Plan checklist
- Opens your editor for final review before creating the PR
- Creates the PR directly via GitHub — no copy-pasting between tools
✦ Generating PR description...
Title: Add JWT refresh token rotation with sliding window expiry
## Summary
- Implements refresh token rotation to prevent token reuse attacks
- Adds sliding expiry window that extends on each valid refresh
- Includes database migration and new API endpoint
## Test plan
- [ ] Verify refresh token rotation invalidates previous token
- [ ] Confirm sliding window extends TTL on valid refresh
- [ ] Test expired refresh token returns 401Machete PR creation view with AI-generated title and structured description
Visual Git Graph
Git history is a graph, but most tools show it as a list. You lose the shape of the work — where branches forked, how they merged, which commits are on which line of development. The information is there, but it's buried in text.
Machete renders your commit history as an interactive lane-based graph. Each branch gets its own coloured lane, with fork and merge lines showing exactly how branches relate. You can see the topology of hundreds of commits at a glance, with virtual scrolling that keeps everything smooth even in large repositories.
Right-click any commit to checkout, cherry-pick, revert, reset, create a branch, or tag it. The graph isn't just for looking — it's a workspace. Navigate your history the way you think about it: visually.
- Lane-based graph with colour-coded branches and merge visualisation
- Virtual scrolling renders 10,000+ commits without performance issues
- Right-click context menu: checkout, cherry-pick, revert, reset, branch, tag
- Full commit details: hash, message, author, timestamp, refs, and tags
- Search and filter commits by message directly from the graph
Machete visual git graph showing colour-coded branch lanes with merge lines and commit details
Conflict Radar
You've been heads-down on a feature branch for three days. You're ready to merge. You run the merge and — conflict. Forty files. The other branch has been refactoring the same module you've been building on. Now you're doing conflict resolution instead of shipping.
Conflict Radar scans your branches proactively, before you try to merge. It runs in three phases: first, a fast file-level overlap check in under 50 milliseconds. If files overlap, it drills into hunk-level analysis to see if the actual line ranges intersect. For the trickiest cases, it can use Claude to perform semantic analysis — understanding whether two changes to the same function will actually conflict.
The radar runs automatically on branch switches, commits, and fetches, plus a periodic background scan. You get a severity indicator in the toolbar — green when you're clear, pulsing amber when overlaps are detected. Click through to see exactly which files and line ranges are at risk, with a side-by-side preview of the competing changes.
- Three-phase detection: file overlap → hunk overlap → AI semantic analysis
- Severity levels from Clean to High, with colour-coded indicators
- Runs automatically on branch switch, commit, fetch, and every 5 minutes
- Toolbar indicator shows conflict status at a glance with pulse animation
- Side-by-side preview of overlapping changes — see the problem before it happens
- Scans active branches only (commits in last 30 days) to stay fast
Machete conflict radar showing branch overlap detection with severity indicators and side-by-side diff preview
Time Machine
Git's reflog records every operation you perform — every commit, rebase, reset, merge, and checkout. It's your safety net. But reading raw reflog output is like reading a database transaction log: technically complete, practically impenetrable.
Time Machine presents your reflog as a visual timeline. Every operation is an event with a coloured icon, a human-readable description, and full metadata. Commits, rebases, resets, merges, cherry-picks, stash operations — they're all there, laid out chronologically so you can see exactly what happened and when.
Select any point in the timeline and Machete runs a safety analysis before restoring: will it cause conflicts? Will unpushed commits be lost? Which branches will be affected? One click to restore, with full awareness of the consequences. You don't have to undo sequentially — jump to any point in your history.
- Visual timeline of every git operation, not just commits
- Undo rebases, resets, merges, cherry-picks, and stash drops
- Safety analysis before restore: conflict detection, data loss warnings, branch impact
- One-click restore to any point in your history — non-sequential undo
- Event icons and metadata make the reflog readable for the first time
Machete time machine showing a visual reflog timeline with event icons, safety analysis, and one-click restore
Stacked PRs
Large features don't fit in a single pull request. A 2,000-line PR gets rubber-stamped or ignored — neither outcome is a real review. The solution is stacking: break the work into dependent branches, each with its own focused PR that reviewers can reason about.
Machete manages the entire stack lifecycle. Define a stack of ordered branches, and cascade rebase keeps them in sync. When the base branch updates, one click rebases the entire stack bottom-up. When the bottom PR merges, the merge waterfall automatically updates the remaining PRs to point at the new base and rebases the chain.
Each branch in the stack has a health indicator: synced, needs rebase, has conflicts, PR in review, PR approved. Drag branches to reorder them, insert new branches mid-stack, or split a branch with interactive rebase. The stack view is your control panel for shipping large features incrementally.
- Cascade rebase syncs the entire stack bottom-up with one click
- Merge waterfall auto-updates remaining PRs when the bottom one merges
- Health indicators: synced, needs rebase, conflict, PR status per branch
- Drag-and-drop reorder triggers automatic cascade rebase
- PRs auto-created with correct base branches and cross-references
- Insert, remove, split, or squash branches within the stack
Stack: auth-overhaul (base: develop)
✅ feature/auth-models → PR #142 approved
⚠️ feature/auth-middleware → PR #143 needs rebase
◐ feature/auth-routes → PR #144 in review
○ feature/auth-tests → no PR yet
[Sync Stack] [Create Missing PRs]Machete stacked PRs view showing branch dependency chain with health indicators and sync controls
Release Pipeline
Shipping a release should be a non-event. Instead, it's usually a ceremony: update the version in three files, write the changelog by scrolling through commits, create the release branch, merge to main, tag it, merge back to develop, create the GitHub release, upload the assets. Miss a step and you're patching the patch.
Machete's release pipeline handles the entire git-flow in one action. It bumps the version across every file that needs it — package.json, Cargo.toml, tauri.conf.json — regenerates lock files, and sends your commits to Claude to generate a grouped changelog: Features, Improvements, Fixes, Documentation, Internal.
Then it creates the release branch, merges to main with a no-fast-forward merge, tags the commit, merges back to develop, and cleans up the release branch. It can create the GitHub release with generated notes and upload build assets. Pre-flight checks ensure you're on the right branch with a clean working tree before anything starts.
- One-click release: version bump, changelog, branch, tag, merge, publish
- Version sync across package.json, Cargo.toml, and tauri.conf.json
- AI-generated changelog grouped by Features, Improvements, Fixes, and more
- Full git-flow: release branch → merge to main → tag → merge back to develop
- GitHub release creation with generated notes and asset uploads
- Pre-flight checks: correct branch, clean working tree, passing tests
Machete release pipeline showing version bump, changelog generation, and git-flow branch management
Branch Pruning
Every repo accumulates stale branches. Feature branches that were merged months ago. Experiment branches that went nowhere. You know most of them are safe to delete, but which ones? Delete the wrong branch and you lose work. So the branches stay, and the list grows.
Machete classifies every local branch through three phases of safety analysis. First, hash-identity checks: are the commits pushed to the remote and present on other branches? Second, patch-equivalence via git cherry: were the commits cherry-picked or applied elsewhere? Third, combined-diff patch-id matching: was the branch squash-merged, flattening multiple commits into one that git can't trace by hash alone?
This three-phase approach catches what other tools miss. When GitHub's "Squash and merge" button flattens your five commits into one, Machete still detects that the work made it to the target branch. Every branch is classified as safe, unsafe, or protected — and only safe branches are ever deleted. There is no force flag. Pruning is safe by design.
- Three-phase safety: hash-identity → patch-equivalence → combined-diff matching
- Detects squash merges that flatten commit history beyond hash tracking
- Clear classification: safe to delete, unsafe (has unique work), or protected
- No force flag — pruning never deletes branches with unreachable work
- Protected branches (main, master, develop) are never touched
- Interactive mode lets you choose which safe branches to clean up
Branch Pruning — 14 local branches analysed
Protected (3):
main, develop, staging
Safe to delete (7):
feature/auth-models → squash-merged into develop
feature/dark-mode → merged into develop
fix/memory-leak → merged into main
chore/deps-update → merged into develop
...
Kept (4):
feature/new-dashboard → 3 unpushed commits
experiment/wasm-build → not on any remote
...Machete branch pruning showing safety classification with safe, unsafe, and protected categories
GitHub Native
Context switching kills flow. You're deep in a commit graph, you spot a failing CI run, and now you're in a browser tab hunting for the right workflow run, scrolling through logs, losing the mental context you had five seconds ago. Then you need to check the PR comments, and that's another tab, another search.
Machete embeds GitHub directly into your git client. Pull requests, issues, Actions workflow runs, releases, notifications, and even organisation billing — all accessible from tabs within the app. Pull requests show full review status, inline comments, and merge controls. Issues support sub-issues, linked PRs, labels, milestones, and type classification. Actions shows live workflow runs with step-by-step logs, re-run and cancel controls, and manual dispatch with input parameters.
Everything is optimised for speed. GraphQL batching loads PR lists with CI status in a single request. ETag caching means repeated fetches that haven't changed don't consume your rate limit. The notification bell shows unread counts with reason-based filtering. You stay in one window, with your code and your GitHub context side by side.
- Full PR management: create, review, merge, comment, request reviewers
- Issues with sub-issues, linked PRs, labels, milestones, and type support
- GitHub Actions: workflow runs, step logs, re-run, cancel, and manual dispatch
- Release management: create, edit, upload assets, generate notes
- Notification bell with unread count and reason-based filtering
- GraphQL batching and ETag caching for fast, rate-limit-friendly data loading
Machete GitHub integration showing PR list with CI status, inline review comments, and Actions workflow runs
Ready to ship faster?
Machete is free for personal use. Download for macOS, Windows, or Linux.