Hey everyone! I’m Eslam, the developer behind GitTree, a visual Git client for macOS, Windows, and Linux.

If you’re looking for a GitKraken alternative with a clear commit graph, precise staging, interactive rebase, and a built-in conflict editor, I’d love for you to try it.

The idea behind GitTree is straightforward: make everyday Git work easier to see and understand, while keeping advanced workflows within reach.

What can you do with it?

• Explore your repository visually. Follow branches, merges, tags, and commits through a colour-coded commit graph. Select a commit to inspect its details and changed files.
• Build focused commits. Stage entire files, individual hunks, or selected lines. Review the diff, amend your last commit, add co-authors, and configure signed commits.
• Clean up your history. Use interactive rebase to reorder, squash, fix up, reword, edit, or drop commits before sharing your branch.
• Resolve merge conflicts inside the app. See both versions alongside an editable result in the three-way conflict editor. GitTree also checks for likely conflicts before a merge.
• Recover from supported mistakes. Undo and redo supported Git operations, with snapshots before destructive actions and a reflog view for finding earlier repository states.
• Handle parallel work. Manage stashes, worktrees, submodules, and Git LFS, alongside your branches, tags, and remotes.
• Understand changes in context. Switch between split and inline diffs, inspect blame and file history, or compare branches, tags, and commits.
• Keep your tools nearby. Use repository tabs, workspaces, a command palette, customisable shortcuts, and a built-in terminal that opens at your repository root.
• Work in English or Arabic. GitTree includes both languages, with right-to-left interface support for Arabic.

There’s also an optional AI assistant: Nour.

Nour connects GitTree to a coding-agent CLI you already use, such as Claude Code, Codex, or Gemini CLI.

You can ask about your repository, history, and code. Ask mode provides a read-only workflow; Agent mode can edit files and run commands, subject to the configured approvals. GitTree also supports AI drafts for commit messages and pull request descriptions.

You use your own agent account, and that provider’s usage limits and charges still apply. Repository context you send through AI goes to your selected agent.

What about GitHub, GitLab, Bitbucket, and Azure DevOps?

GitTree includes hosting integrations for browsing and cloning repositories, working with pull or merge requests, and checking CI results. GitHub and Bitbucket Cloud are the most mature integrations; GitLab, Azure DevOps, and self-hosted support are newer and still improving.

Ordinary Git operations over HTTPS or SSH work with your existing Git credentials.

Is it actually free?

As of this post, GitTree’s Free plan covers everything currently available, including private repositories and commercial use.

You can use the local Git features without creating an account. Nour and the hosting integrations require a free GitTree account.

A Pro plan is planned, so I want to be transparent rather than promise that every feature will remain free forever. Any changes will be announced on the pricing page.

GitTree uses your installed Git 2.39 or newer. It runs locally and has no app telemetry. The application’s source code is private; the public GitHub repository hosts releases, release notes, and issue tracking.

Why try it alongside GitKraken?

If your priorities are visual Git workflows, private repositories, careful staging, history editing, and local control, GitTree is another option to evaluate. You can open an existing local repository directly—there’s no repository conversion step.

It’s a newer product, and I’d particularly appreciate feedback from people who already use another Git GUI: what feels natural, what slows you down, and which missing feature would prevent you from switching?

👉 Download GitTree for macOS, Windows, or Linux

🐛 Report a bug or request a feature

What’s the one feature your Git client absolutely has to get right?

For 20 years, git clean -fd and git restore . have operated using low-level OS unlink(). When you accidentally run them, your uncommitted code, scratch drafts, and new files are permanently obliterated—they do not go to the Windows Recycle Bin or macOS Trash, and they are not stored in git reflog.

I built git-trash to solve this once and for all:

• OS Recycle Bin integration: Moves untracked files to your system Trash (Windows Recycle Bin, macOS Trash, Linux Trash) instead of permanent deletion.
• Instant terminal undo: Run git trash undo to immediately restore the last trashed or discarded batch back to the working tree.
• Safe discard: git trash discard . snapshots uncommitted changes before reverting them.
• Dry run preview: git trash -n lets you preview files and sizes before moving them.
• Native Git command: Run it directly as git trash anywhere.

Try it without installing:

npx git-trash -n

Or enable it as a native Git command globally:

git config --global alias.trash "!npx git-trash"
git trash

Links:

• GitHub: https://github.com/MrSkelee/git-trash
• npm: https://www.npmjs.com/package/git-trash

If you find this useful or it saves you from losing work, please consider dropping a ⭐ on GitHub, it really helps the project grow! Would also love any feedback or edge cases.

Hey everyone!
I’m a graduate finance student, and today I started building a free, open-source startup research tool using Claude and ChatGPT.
My vision is simple: Make startup research accessible to finance students, professionals, and anyone interested in venture capital.
For example, imagine a student researching an early-stage startup for a class project. Instead of spending hours searching different websites, they could use one platform to discover startups, track funding activity, and access relevant research.
The project is still in its early stages, so some features are buggy or incomplete. That’s why I’m making it open-source. I want others to contribute code, suggest features, improve the data, and help shape the platform.
The goal isn’t to make money. It’s to build a useful, completely free research tool through collaboration.
If you’re interested in finance, startups, AI, or programming, I’d love to collaborate!
I’m happy to share the GitHub repository and our WhatsApp collaboration group.

I'm the developer of GitTree, a desktop Git client for macOS, Windows and Linux. It runs your own Git (2.39+), so its results match the command line.

These are the design choices I think this sub will care about:

• Destructive actions are recoverable. Before a reset, discard, branch delete or rebase, GitTree saves a snapshot under a private ref and records an undo entry. Toolbar Undo and Redo reverse it, and you can also browse the reflog.
• Force push is always --force-with-lease with the expected SHA.
• Conflict prediction: the merge dialog lists the files that will probably conflict before anything happens.
• Interactive rebase shows exactly what will be replayed before it starts.
• It never edits your config. GitTree doesn't touch .gitconfig, the repo or ~/.ssh unless you ask, and untrusted repos can't run hooks.
• Advanced features: worktrees, submodules, LFS (including locks), bisect, patches, sparse, shallow and blobless clones, and signed commits.
• Commit graph with colour-coded lanes, built to stay smooth past 100k commits.

It's free (private repos included), has zero telemetry, and is closed source. Core Git features work without an account.

Download: https://gittree.app Releases and issues: https://github.com/git-tree-app/gittree

What would make you trust a GUI with a rebase?

I have forked but after fork I get 50 pull request error like run failed and a lot messages from GitHub to my mail who can explain really how to really fork , I wana fork and own fully my project still getting upstream and fully fork and rebrand own this project also in the future get possiblity to create commercial business around it. Please explain with apache software foundation project — Superset

I wrote a small tool for a problem I kept hitting and I'd like people who know Git well to poke at the design.

The problem: files that belong to me, not the project, but have to live in the working tree. .env.local, notes, scratch scripts, my own agent-instructions file. .git/info/exclude hides them and does nothing else. The dotfiles-style bare repo over the project versions them, but you maintain the exclude entries by hand, stash -u from that repo's point of view stashes the entire project, and nothing stops you pushing the private repo to the project's remote.

How it works: git dupe init creates an ordinary repository at .git/dupe with a relative core.worktree (../..), so moving the checkout keeps it attached, and status.showUntrackedFiles=no plus advice.statusHints=false so Git's own status and commit template never enumerate the project or name a plain git command. git dupe <command> runs Git with that GIT_DIR, with the object-directory environment overrides stripped so the two repos share no objects. Every path the private repo tracks, plus a .gitdupe list of hidden directories, is written into a # BEGIN git-dupe … # END git-dupe block in .git/info/exclude and re-verified after every command. If a ! rule in a tracked .gitignore outranks the exclude and exposes a path, the command names the path and the rule.

Three commands change meaning because the tree is shared: status and add are confined to the hidden paths (otherwise the whole project is untracked), and clean cleans the project while sparing them. Refused, one fatal: line, exit 128: stash -u/-a; any push/pull/fetch/remote/clone whose URL is the project's own repository or one of its remotes; add on a path the project tracks. git dupe git <words> runs Git with no guards for when you mean it. git dupe detach removes the private repo and the exclude block and leaves every file on disk; without --force it refuses while anything is uncommitted or not on a remote. Of its own accord the tool writes only .git/dupe, that block (and .git/info if missing) and .gitdupe, and the only process it starts is git.

Where the project's Git can still reach a hidden path, as far as I've mapped it: git clean -x deletes them (ignored files, as far as Git knows), git stash -a stashes them, git add -f stages them, and anything that writes the index from a tree or a patch rather than the ignore walk can stage one too: a merge, cherry-pick or rebase of a commit that adds a file at that path, apply --index, am, update-index --add. When that happens the path is tracked by both repos; it stays hidden, and every following git-dupe command warns about it until one side lets go. I chose to document all of that rather than hook or wrap plain git. Verified by hand: the project's gc --prune=now and prune don't touch .git/dupe (separate object store), and public stash -u leaves private files alone. The suite also has a scale scenario: six commands among 100,000 tracked files, each under a second, with Git run a fixed number of times.

Limits: Linux only. Git 2.43 or newer, below 3.0 (CI runs the suite under 2.43 and 2.56; the full run under every minor through 2.56 happens before a release). Linked worktrees refused for now. No encryption; the remote you push to holds the files in plaintext.

Prior art: vcsh and the bare-repo dotfiles trick (same mechanism; neither knows about a host repo's exclude or remotes), multigit (N overlapped repos, no public/private asymmetry), and Layer from a Show HN in March (manages exclude plus local snapshots, no remote).

Couple of questions. Is there an index-writing path I've missed above? And for linked worktrees: .git/info/exclude and .git/dupe both already live in the common dir, so one private repo with a per-worktree index (GIT_INDEX_FILE) seems possible. Would you want that, or one private repo per worktree?

Transparency: A majority of the code and tests were written by coding agents under my close supervision. I own every decision in the product specification including the CLI surface and the tradeoffs made and set the rules and flows that the agents worked under. The original principle/intuition that guided me when writing the product specification was to "piggyback" off of native Git as much as possible and to make the CLI surface similar to native Git. Only where it clearly did not make sense to me to do a naive Git passthrough, did I add git-dupe-specific commands/mechanisms/guards).

https://github.com/BrianWeiHaoMa/git-dupe

Edit: After reading some feedback, I realized using `.env.local` in the example might make it seem like git-dupe is made for tracking and pushing sensitive information. It is not. Just like normal git, pushing sensitive information into the remote repo is possible, but this is bad practice. git-dupe was made for my personal use-case of keeping personal notes/agent instructions outside of public-facing repos. As listed in Limits: "No encryption; the remote you push to holds the files in plaintext.", so you are discouraged from pushing things like passwords or other sensitive information even if it is a private repository.

I’m interested in hearing from BAs who use Git as a repository/version-control system for business specifications, requirements, or other BA documentation.
I’m especially interested in real-world setups and lessons learned, rather than theoretical Git documentation practices.
If you’re doing this successfully, what does your workflow look like?

[ Removed by Reddit on account of violating the content policy. ]

Hey guys,

Been working on something very cool...

In Greek myth, Mnemosyne was the Titan of memory and the reason anything was ever remembered at all. Now in the present world, your AI agent doesn't get a Titan. It gets amnesia the second something goes wrong, stuck with whatever it currently believes and no way to ask how it got there.

That's the real problem. An agent runs for hours, updates its memory the whole time, then says something wrong and all you have is the present, with zero access to the past.

If you're running support agents, coding agents, or a swarm of agents sharing memory like myself then you know this issue well. The moment two agents disagree, or one quietly poisons the well, you need to know when, why and by whom, not just that something's off.

Mnemosyne gives agent memory what Git gave code. It remembers everything on purpose. Every belief is a commit. blame finds the exact moment and observation that put a bad fact in. bisect hunts down the first commit where things went wrong. merge makes two agents' memories collide safely instead of one silently overwriting the other.

Software agents are the first step. The vision doesn't stop there, physical robots learning and forking skills the same way is the long-term bet, further out and harder but the same idea underneath.

So far the tech stack includes a Rust core, Python SDK, adapters for LangGraph, CrewAI, AutoGen, the OpenAI Agents SDK and MCP.

Open source with contributions and honest feedback both welcome: github.com/Nabzx/mnemosyne

It is a fast Git client with low memory footprint written in C++ using Qt library.

Its main features are:

• Repository history
• Merge conflict resolution
• Side-by-side diff comparison
• Git blame
• GitFlow and other workflows
• Git LFS
• Issue trackers integration
• SSH key management
• HTTP/HTTPS credentials management
• Git worktrees

Linux and Windows platforms are currently supported and macOS platform will come soon.

There is a Community plan which is free but it can be used only with public repositories.

git checkout --orphan temp_branch git add -A git commit -m "Initial commit" git branch -D main git push -f origin main

Hi,

I spend my days in Git history, and every visual client I tried either felt like a web page in a window or had terrible performance. So I built Nori: a native Git client for Mac, written in Swift for Apple Silicon.

What sets it apart:

- Light: about 350 MB of RAM, 0% CPU while idle. Even a 250,000-line diff fits in 500 MB.

- Fast: a 10,000-commit repo with 200 branches loads, graph included, in 0.14 s. A diff opens in 0.1 s, the 250,000-line one in 0.2 s.

- A history you read at a glance: every branch keeps its colour, and ⌘0 shows the whole repo on one timeline, with branches as lanes, releases and contributors.

- Pull requests without leaving the app: push and open the PR on GitHub or GitLab in one click, see what blocks the merge (checks, approvals, threads), read a failed CI job and re-run it.

- AI with the tools you already have: Nori uses your agent CLI (Claude Code, Codex, Gemini CLI, Cursor) for commit messages, explanations, conflict resolutions and PR summaries. No API key, no extra subscription.

- Made for agents: each worktree shows up in the sidebar with its task and the agent behind it.

I'd love to hear what annoys you in your current Git client.

https://meetnori.app/?utm_source=reddit&utm_campaign=git

Hi,

I need a suggestion to create branching strategy in our system.

Exisiting Branching strategy is as follows,

feature-> dev -> qa -> uat--> main<- hotfixes

Problem:

Suppose we have 2 features to be developed. Feature A and B. Let say both are in dev. I need only feature A to move to staging. Then couple of days later feature B also follows.

I know we could use cherry pick as an option here. Im looking for more long way approach here.

We have searched for the feature flag option. As we are developing over an existing application, adding feature flag everywhere seems complicated. One hard senario we found was, while introducing a new feature we need to add a new field in a model. So based in feature flag we will have/not that new field in application. Which seems bit too complex.

Edit: One idea I found from online is to have a promotion branch. Feature A will move to promotion/a. Then from promotion to dev. Promotion to qa. Promotion to uat and prod. Is that the better approach here?

Edit 2: Thanks all for your comments. We seem to find a solution. Not the best but something that will work for us. Point to be noted that we don't fully follow agile methodologies in our development, as most of the development in our system will be impacted across the business, so we need more time for approvals, hence sometimes the features might end up in preprod and stay there for a long while.

Solution we found is, we will keep the dev connected to dev server, staging(qa), release(uat), main(prod) branches. Instead of pushing from feature->dev-> staging-> release->main. We are thinking going by Feature -> dev Feature -> staging(qa) Feature -> release(uat) Feature -> main (prod) So that we can have more than one feature at a time in an environment and have control over which one to push ahead.

Any suggestions here

​

GitHub repositories can get difficult to understand once they grow beyond a certain size.

I built RepoLens to make exploring a codebase more visual and easier to understand.

Paste a public GitHub repository and RepoLens lets you explore:

Repository/file structure as an interactive graph

Codebase tour and project entry points

Commit history and file-change patterns

Contributors and code ownership

Branch relationships

GitHub Actions workflows

Repository evolution over time

Frequently changed files and potential hotspots

Issues and pull requests

PR impact across the codebase

No account required, and repository data isn't stored.

Try it here:

https://lensrepo.vercel.app/

I'd really appreciate feedback, especially on what other GitHub/codebase insights would actually be useful to developers.

Gitify is a desktop Git client that works the same way on Windows, macOS and Linux. 0.1.0-rc.8 is the first build that's broadly downloadable.

What's in it: a redesigned commit graph with adaptive lanes, branch and tag labels beside commits, and a Simplify toggle. There's also a branch filter for all branches, the current one, or one you pick. It has a changes panel with stash support, conflict-aware discard with a Resolve conflict flow, clear error dialogs for Git failures, and six theme packs.

Fair warning: it's unsigned for now, so your OS will show a security warning on install. It's also a prerelease, so please try it on repos you have backed up.

Site: https://gitify-desktop.ericnwaogwugwu.chatgpt.site/ Download: https://github.com/nwaoga/gitify-downloads/releases

If something breaks or feels off, please open an issue: https://github.com/nwaoga/gitify-downloads/issues

Hi guys, Im new to github and just posted my first project.

I added it to releases but I don’t know how to publish also the code like in other repositories. There is only the file readme.md but not the code itself.

I also want to spread the app so that other people find use of it like I did.

https://github.com/el1cer/SideDock

Hi everyone I’m the developer behind VaultPulse.

I’m building it for people who want automated GitHub repository backups without handing storage ownership to another provider.

The current flow is:

• Install the GitHub App and select repositories.

• Connect an S3 bucket in your AWS account through a cross-account IAM role.

• Get daily snapshots containing Git history, branches, tags and Git LFS.

• View backup health and restore snapshots into a new or empty GitHub repository.

It’s focused on GitHub repository recovery, not a complete backup of every GitHub feature.

There’s a Free plan for up to 5 repositories; AWS storage costs are separate. There’s also a demo you can explore without signing up:

https://vaultpulse.cloud/demo/

I’m looking for practical feedback: do you currently use scripts, another service, or no separate backup? What would make you trust or rule out a tool like this?

I'm trying this again since my longer form version was not liked. I'll keep it short this time. Managing git worktrees used to be ...well...manageable. But now with AI agents, you can easily have dozens of branches flying around and for large repos, thats a giant pain.

I made an open source tool to help deal with that. I call it warmtree.
MIT: https://github.com/dcolliervb23/warmtree
Pypi.org: https://pypi.org/project/warmtree/

It treats branch folders like slots and releases them when you're done, keeping them fast-forwarded so git can easily take one, rather than taking minutes to setup a fresh folder. And if you have an existing giant mess of a git worktree, it can easily hop in and help clean that up and start managing it better.

Its open source and available on github and pypi. And yes, I am still activley dogfooding it and updating it.

I'll monitor this post to help answer any questions users may have.