Lazygit.

The cli because it is consistent everywhere and has all fearures

I mostly use git from the console.

• git with a bunch of aliases for common operations and making the log pretty.
• gitk when I need a UI to browse the history
• kdiff3 as mergetool

Mostly Magit, some CLI

Off topic: day-after-day with these kinds of posts and especially the replies, I need Reddit less and less. That's a very good thing.

Fork on windows, SourceGit on Linux, both have a similar UI layout to SourceTree, but are much faster/snappier.

I really like having a clear overview of the commit history, branches and current local state. I haven't figured out yet how to get such an "at a glance" overview in the CLI.

For advanced stuff the CLI is still very convenient.

TortoiseGit.

Through settings, I move the Show Log to the top context menu level, and it's my entry point to every Git operation.

I see a history tree to see and immediately understand commit and branch relationships and states. I can commit, show changes, diff, rebase interactive or not, push, fetch, switch, create branches and tags, squash and split commits, commit chunk-wise through "restet after commit", … And everything from a repo overview.

/edit: To add; other clients I tried never reached what I want from a UI/GUI, never reached TortoiseGit. Including IDE integrations where I'm already in the IDE; I prefer the separate better TortoiseGit.

GitButler is interesting for it's different approach, but when I tried it out the git auth didn't remember my key password. (Since trying out jj I found out it may have been due to disabled OpenSSH Service.)

Lazygit. Used gitui for a long while but lazygit has vim key bindings which is much nicer and it also seems much more stable.

Is Vscode a git client?

No one take from me though idk what I'm doing when it comes to programming stuff.

CLI with some aliases for viewing commit history and branching, or less frequently an IDE plugin

I use plain old git for the same reasons already mentioned, but magit is the gold standard.

Fork !!!

It's hands down the best git client.

It's free as in: sublime text or winzip where they ask you once a month if you want to pay for it but you can just select: I'm still trying it out, and it gets out of your way.

• It's got a well designed tree graph like in GitKraken except it doesn't lag
• It's interactive rebasing is as smooth as JJ / LazyGit, so you can edit/rename/reorder your commits except you don't have to have to remember CLI flags since it has its own UI
• It's lets you commit individual lines by selecting them instead of adding/removing whole hunks like Sourcetree except it isn't filled with paper cuts where a feature breaks in an annoying way for 2 years and you have to do extra steps to keep using it how you want.

And one killer feature that I haven't seen any other git clients handle: allowing me to stage only one side of the diff. As in: if I change a line (so it shows up as one removed line and one new line in git), I can decide to add the new line change while still keeping the old line.

So changing this:

doThing(1);

into this:

doThing(2);

Shows up in git as:

- doThing(1);
+ doThing(2);

But if I still want to keep doThing(1);, I don't have to go back into my code to retype doThing(1);, or do any manual copy-pasting. I can just highlight and add only doThing(2); to the staging area and discard the change to doThing(1);.

So now the code exists as:

doThing(1);
doThing(2);

Now with a one-liner example like this, we could always re-enter the code again. But for larger code changes? It's far easier to just highlight the code in the diff and say: yes to this and no to the other stuff.

And when you get used to it, it makes it really easy to split what would be large git commits into smaller related changes keeping your git history clean and easy to understand.

Magit is what allowed me to finally commit to switching to Git full time.

It's such an excellent front-end for Git that I've known numerous workmates learn Emacs just to use Magit.

Fugitive, the vim / neovim plugin. It does everything the CLI does, but uses vim interfaces very effectively to enhance the experience. For example it's quite good for selectively staging changes from a file. I also like the option to open a buffer with the version of a file from any specified commit.

I also tried neogit which aims to port magit to neovim. I didn't like it as much. Partly because as far as I could tell at the time it lacked features compared to fugitive. But also because it seemed to want me to do everything through UIs in its own custom windows. Fugitive is integrated more thoroughly into vim via command mode, and special buffers.

GitKraken ❤️

If not present, vscode + gitlens

gitui and the plain old git cli

Git Extensions.

It's what they used at my job when I started, it does the job, and I've gotten used to it. 🤷‍♂️

Lazy git most of the time, sourcegit for heavy duty stuff.

lazygit & gitsigns.nvim

Do Jujutsu & jjui count? The backend is still git.

sourcegit, fork

I mostly use the cli, but also Sublime Merge. It makes some things really convenient (like committing only some lines in a changed file), and looking at diffs is snappy too.

I'm a big fan of tig for visualizing the graph and looking over history (then I don't need to leave the terminal, and it's snappier, in my experience, than most full-GUI programs like Sourcetree), but for actual Git commands, I like the CLI

I use Sourcetree for routine stuff, though I occasionally have to hit the command line when shit gets real.

Vscode with the Git Graph extension.

Mostly vscode, and GitHub desktop for projects that I don’t use vscode for. I want to learn how to use the CLI, I just didn’t get around to it yet.

Vscode and gitlens for routine stuff, and then just CLI when push comes to shove and I need some more advanced feature.

I'm an Emacs users, so unsurprisingly I use magit, but perhaps surprisingly I use it sparingly, using Emacs's VC most of the time.

Whatever's built into pycharm or vscode for looking at diffs. Command line for push pull squash etc

I use VSCode and SourceGit. SourceGit is similar to Fork (which I've used before), but it's FOSS and cross-platform (Windows/macOS/Linux).

i loved fork on windows but i'm too lazy to set up wine to try and get it to work now i just use git cola and the cli.

cli and meld for mergetool

I use GitHub Desktop on Mac and PC. It works fine with local repos, too.

Tried idea community edition, honestly not bad, like vs code slightly more even tho with an extension or two you can make how they function very similar. Wanted to use idea because it matched the gtk theme, but if I was gonna use an extension for vs code like navigation might as well use vs code. Both easy to use with git as a dabbler.

For professional use I’ve heard good things about SmartGit, unfortunately my work refused to buy me a license and the trial period wasn’t long enough for me to really form an opinion.

Work suggests to use SourceTree but it is way too sluggish.

These days I use git CLI for most things, and VSCode to review changes and submit PRs. Of course this also assumes you use a decent shell with git support, like Oh-My-Posh or similar, so it is always clear what you are working on.

When I learned Git I think there were not decent tools, so I got used to the command line.

I occasionally use gitk for reviewing my commits- it's nicer to see the files modified and be able to jump back and forth, although I get I could use git log -p instead.

I'm an Emacs user, but I don't use magit (!)

I like some of the graphical tools- some colleagues use Fork and I like it... but as I've already learned the CLI, I don't see the point for me.

I could use learning some jj because it automates some of the most tedious parts of my workflow, but I'm getting too old.

I made some automation in python for common git tasks and use the cli otherwise. I tried a couple like sourcetree and the built in automation for VS but they're either slow or lack features i'd like.

Mainly the official git CLI for controlling branches and sub modules, and sometimes the GitHub CLI if quickly checking out a pull request from a forked repo.

Also use the source control tab in VSCode rather often, as it's really convenient to review and stage individual line changes from its diff view, and writing commit messages with a spell check extension.

If it's a big diff or merge conflict, I'll break out the big guns like Meld, which has better visualizations for comparing file trees and directories.

About a decade ago, I used to use SmartGit, then tried GitKraken when that came around, but never really use much of the bells and whistles and wasn't keen on subscription pricing. Especially as the UX for GitHub and other code hosting platforms online have matured.

CLI for me. I do use the GitLens plugin in vs code but only so I can see commit info inline. I never commit anything from vs code.

I like Kaleidoscope (v3) for diffs but not for merging. I could probably use any graphical difftool for this purpose but it’s what I’m used to.

I have tortoise git on a windows machine and GitHub desktop on a Mac. I do some things from the command line when I'm not feeling lazy.

Github desktop, despite the name it's just a git client. Absolutely clownish that there's no official Linux support (there's a fork which works perfectly). I use it to interact with self-hosted gitea, codeberg and github, pretty happy with it, I'm Aldo testing git butler

vscode with edamagit and the cli

Lazygit and magit

Git Graph VS Code extension

I’ve used source tree, gitkraken, etc. this simple extension is just as good. I spend most my day with it

LazyGit and GitKraken. I try to use LazyGit as much as possible, but a few things are easier for me in GitKraken (as I'm more used to it).