Is anyone here using a GUI for git? If yes - which one and why?

kwj🌐🇺🇦 ⚪🔵🟡⚪@szmer.info to Programming@beehaw.org – 46 points –

I ask because I like console, but at the same time have difficulties remembering all the commands. I'd like to try a GUI that is comfortable to use with only a keyboard.
[edit]
My inbox got fediversized, fantastic feeling.

136

It's a paid app only available for Windows and Mac at the moment, but Fork may be worth a look: https://git-fork.com

I am using it too and I love it. I only know source tree as a competitor and in comparision it sucks....

You dont have to pay for it, even when using it comercially (unpess they changed that)

It has a "free evaluation" that I think can be as long as you want it to be / honor system.
Its been worth it to me to pick up a license and support the development though. Its reasonably priced (for a dev tool) / no subscription and definitely beats the free clients I was using before (Sourcetree/GithubDesktop).

Came here to recommend it too, really neat and practical tool and I haven't found a better alternative yet. Honestly I don't know why are people so against GUI git tools, it makes visualizing branches and commits so much more easier. I don't think you can use it only with your keyboard as OP asked though, dunno how important that is to them.

Magit with emacs (doom emacs to be fully honest). More a TUI, but definitely fully keyboard driven :)

Yeah this is THE best interface for git. Worth getting into Emacs just to use it id say.

Same here. I don't even use emacs for development anymore (I use IntelliJ since all my work is on the JVM and Typescript) but I still have an emacs running in the background for magit and org-mode. Magit is insanely effective for performing complex rebasing and cherry-picking tasks.

I used to use SourceTree but it runs horribly and switched to Fork years ago and never looked back. I use VSCode for merge conflict resolution.

I'm still using SourceTree, I've tried a few others but have always gone back. Never heard of Fork tough, guess I'll try that out.

Lazygit changed how I use git, it is so easy to do all the daily essentials like branching, committing, and merging, but also also does more advanced things like interactive rebasing when needed.

I had searched for a proper git client, that was free and open source plus worked on both Linux and Windows, for a long time and I haven't looked back after finding lazygit.

No, I find typing faster than clicking and I've been using git for so long the commands are second nature to me.

What I prefer most about having a UI is the better sense of overview over the repository and it's branches.

I find, when compared to people I've worked with that prefer plain git, that I'm much quicker at finding certain changes or seeing what is in which branch with GitExtensions.

I use a 50%-50% mix between git CLI and the built-in git tools in JetBrains IDEs.

To be honest, I could quite easily get by with just the JetBrains GUI - they have a super sophisticated GUI that can easily handle things like interactive rebase, cherry-picking, etc + they have a great conflict resolution tool. I just use the cli every now and then if I want to get something done quickly while I don't have an IDE window open.

This one. It's sophisticated and easy to navigate.

I generally do conflict resolution in Jetbrains IDEs and everything else in CLI. Occasionally, I might commit from the IDE if I only want a single file.

I mostly use the CLI but when I used to use PyCharm the JetBrain git GUI was the shit. The closest to it in a standalone program I've seen is maybe sublime merge, which is also great.

These days I can run everything I need to with the git cli. I use the JetBrains visual merge tool to resolve conflicts, because doing that by hand is so awfully error prone, it very very intuitively maps to a visual process

Sublime Merge has been wonderful to work with

It is one of the few tools that doesn't misrepresent the core git paradigm.

I also love how fast Sublime Merge is. The built in merge tool is great too. I'm a sucker for apps with a command palette for easy access to every command.

I use IntelliJ's built-in git GUI.

I don't understand why people use command line only. Sure, learn the commands so if you need to use them you can, but most GUIs are far more feature rich than command line. With IntelliJ, I can easily view differences before committing, have it do code quality scans, automatically clean up any code it can, more easily choose which files I want to commit vs the typical 'git add .' I see most people do with command line, have separate changelists when pair programming, and much more.

One argument that continually comes up is that command line is faster. I completely disagree. If I want to just commit the code without reviewing it, I can use 2 hot keys and the code is committed and pushed. But as I do a quick readthrough of all the code first and review issues from the code quality analysis it does take more time, but still less than it would to do comparable things with command line.

I'm a heavy intellij user, but the git log UI always confuses me. When I open 'git log' via the action menu IntelliJ doesn't focus my current branch. I am not sure if there's some other menu I'm supposed to use to achieve that.

I do use the commit local changes, pull changes, merge branches functionality a good bit. My only feedback there is that I haven't found a way to quickly commit changes without running git hooks. Each time it requires me to open up the gear icon and deselect 'git hooks'. This is slower than using the command line where I can write git commit --no-verify and repeat the same command again and again. I know it's a niche need, but it's necessary for testing a rather archaic system we maintain.

The IntelliJ merge UI is the only way I ever want to deal with merge conflicts. So much better than any of the alternatives I’ve tried!

TortoiseGit user here. Love that it integrates with Windows Explorer so I don't have to constantly be opening an app first to fire off some Git commands.

I use Lazygit, which is a TUI. It is entirely controlled by keyboard shortcuts and has a lot of quick ways to do tedious things.

+1 for Lazygit. It doesn't cover all of my needs so I have to use the CLI for a few small things, but for 99% of your typical git usage this tool is such a gift.

I'm curious: what's missing for you?

I needed a few smaller features (like rebasing onto any commit, not just HEAD) and found the code quite easy to adapt to my needs (had to take half a day to learn Go first though).

A proper gerrit integration would be awesome though.

What's lacking for you and where did you end up tool-wise?

Apart from the cli, gitk and git-gui are plenty good in my opinion, they could always be made better. And they are mostly always there with git Only thing I am miasing now is blame.

VS 2022 is finally somewhat usable for Git using the git Changes pane. The whole team uses it this way, and for many of them it's a first for git as well.

I use the TUI gitui Though I also use git directly too, depends on what I'm doing.

I'm loving all of the TUIs cropping up lately. Thanks for sharing!

I have some git blame extention in VSCode, but otherwise no. Something about using gui tool for git makes me feel so disconnected from it, like I'm not entirely sure what's going on, and afraid I'm going to fuck something up

Also, I forget commands all the time. Mostly ones I don't use often, like changing/adding/removing remotes, changing settings, etc.

I use the VS Code built-in git support for making commits, and fall back to the CLI for anything else.

You won't have trouble remembering commands once you use them often enough. And you don't need to know all of them, just the ones your workflow uses. My toolbox is commit, checkout, status, reset, rebase -i, merge, bisect. That's all I need day-to-day.

The number of Git front ends with proprietary licenses is too damn high.

I use various extensions for Visual Studio Code. They add a million features, but these are the ones I find most useful:

I prefer to view the current status of my checkout in the sidebar of my code editor than on the command line.

It's easier to view a diff of a file and decide whether to stage or rollback changes in a GUI. With most GUIs you can even select individual lines of code and revert or stage them.

I like how Commit and Push and Pull are a single "Commit & Sync" button in Visual Studio code. Similarly there's a simple "Sync" button in the status bar.

Speaking of the status bar - it also has a counter for commits that need to be pushed or pulled. And it tells you what branch you're currently on. And whether you have uncommitted changes. Handy.

I find the GUI equivalent of git log --graph is significantly easier to understand when the graph is drawn with nice vector lines instead of ASCII art.

Finally - I don't just use raw git, I also use extensions like pull requests, and I create branches for issue numbers. I have an extension that shows pull requests in Visual Studio Code and also shows issues assigned to me, with a one click "Start Working" button to create a branch named after the issue and change the issue status to In Progress. And when I'm finished working on it, there's a button for that too.

"No. No, man. Shit, no, man. I believe you'd get your ass kicked, sayin' somethin' like that, man." - Office Space

That said, occasionally I'll use the integrated git in vscode. I do recommend a Git cheat sheet to help become more proficient with the CLI interface.

Atlassian Github Git Cheatsheet: Changed to the Github version as the Atlassian one was an auto-downloading PDF.

I actually like the tooling built into VS Code. Added the GitHub Pull Requests and Issues extension for the PRs, pretty happy with it all at the moment. Before that I like a specific older version of SourceTree that didn't forget your credentials.

Im similar, vs code with git graph. Wish i could use something for PR though.

That extension does PRs. Updated my original comment with the link.

My inbox got fediversized, fantastic feeling.

Hey hey hey, I want that too!

As for git, I just use the plugin on VS code. Nothing fancy. I didn't even know there's other options like GUI to be honest.

I generally don't trust most git GUIs - a number of our developers have used SourceTree on OS X before and it's led to nothing but issues. The only one I trust is the one built into IntelliJ IDEA, otherwise I'll use commandline.

Gitkraken is the powerhouse, but i only use it for difficult commands

I use GK for everything and usually only use CLI when there's something a little exotic. I like seeing it update in real time on another screen and I like the diff engine for quickly assessing changes and making sure everything I expected was altered and nothing I didn't. I know there are other tools but GitKraken is the fastest for me.

Also have found it a good tool for teaching other engineers (usually older) how Git works. We tried out Sourcetree but it was super clunky at the time.

If I had to find a tool between pure CLI and pure GUI I'd probably recommend Emacs Magit porcelain. Works quite well.

Gitkraken is great. Git is one of the few things I don't like to CLI (largely because I hate git; hg for life) and Gitkraken is the most usable Linux GUIs I've tried. The big problem is the restriction on private repos they added a few versions back. I gave in and paid but I can see a lot of people not being willing to.

I used to swear by the git CLI. After using GitKraken for a few days, I shelled out the $95 for an annual license. It's really good.

when I absolutely need to... git-gui.

Live by the console, die by the console.

(I should change things up and try to make my life easier -- vim for life) 🙃

Developing in a Windows environment, I generally prefer Git Extensions.
It doesn't distract the eye with unneeded fancy and is very close to a command line git experience but still allows me a better visual sense of the repository and branches.

I don't use a GUI, with the exception of Meld as my primary difftool

At work I wish they were using git. But we got SVN. How I long for the ability to use pull requests. But tortoiseSVN has some nice features (I'm stuck with windows over there) even if it's lacking in overall functionality.

I use a mix of CLI, the Git UI built into VSCode, and Sublime Merge.

Sublime Merge is great for getting an overview, it's very snappy (especially when compared to Electron Git UIs), and I love the merge conflict editor. It's not cheap, but worth every penny.

For daily work, I use the git integration built into my IDE. Occasionally I need the CLI for something complex.

I use GitKraken. It has a beautiful interface. It's free to use non-commercially but I pay $50/yr so that it can connect to my companies Enterprise account. I know I'm weak with git (I get the concepts but I'm a visual person) so the money is worth it to me.

I own sublime merge because it was cheap when I upgraded to ST4, but never use it. It's not bad or anything, but honestly the CLI is more convenient to use (and all the GUIs I've used have a lot of clicking involved). I don't know that you're going to find something better than the CLI, especially given your requirement ow "comfortable to use with only a keyboard".

I don't have a recommendation, but I understand the desire for excellent keyboard support in a GUI. I switched to Linux after 3 decades on Windows and I really miss doing all the screen navigation from the keyboard. In Windows, the only time I used a mouse was inside things like drawing tools and badly written apps with inadequate or non-standard keyboard support.

I mainly program in Visual Studio so I use it's integration for simple commits, diffs, and checkouts. Anything more complicated than that I head for the command line.

I use VSCode for simple commits and merge conflicts. Anything more complicated and I go to CLI since it's usually better documented.

I use GitHub Desktop for 95% of my git needs, terminal for the other 5%

Github desktop is the only way I know how to clone my private repo. I do not understand how to clone my private repos through CLI.

Github desktop will get you into trouble if you ever try to work with a team. Fine for solo development

I use Github Desktop but am looking to start moving toward CLI soon for this reason; though to be honest, I only know it's not good practice and don't know the reason why. What kind of issues can happen in a team environment using it?

The CLI and probably other more advanced guis are going to give you the option to:

  • bisect: very useful for debugging. Like definitely check it out.
  • rebase: excellent for clean commits. I use it all the time to squash commits together
  • diff arbitrary branches and commits. Super useful for debugging.
  • cherry pick: useful to apply a commit from a different branch or remote
  • Apply: I use it to pass around patches for things for testing / debugging.

That's just off the top of my head and also stuff that you can learn on the job. Good to know it exists though. I still use a "gui" (fugitive for vim) for simple tasks, like staging files 🙂

For me, I don't think I could survive without git stash, I use it daily for various reasons (e.g. for validating a small bug fix, git stash & git stash pop lets me attempt to reproduce the issue both with and without a correction). The one downside with the CLI stash command is that it's very easy to forget things in stash though, but I don't think GUIs generally support stashing?

Another one I find myself doing quite often is git checkout BRANCH -- PATH, to pull specific versions of files between branches.

If you have trouble remembering git commands for CLI have a look at the tool tldr:

https://man.archlinux.org/man/tldr.1.en

For example if you need to remember how to use the branch command you could look it up with

tldr git branch

which would give you an overview on the most popular use cases.

And in case you don't already know: You may want to use the history search tool of your shell by hitting CTRL-r and then for example typing branch. You'd get a list of past commands you have used containing branch that you can flip through by repeatedly hitting CTRL-r.

I've been using the git gui extension for a while and resolve conflicts in vs code. I also just use a lot of cli

Would it work for you if you created git aliases for commands you can't remember?

GittyUp! https://murmele.github.io/Gittyup

I previously used GitKraken but was looking for an open source alternative that works in a similar fashion and has a Flatpak.

I use it as well! Not sure if it's a flatpak thing, but for some reason I need to re-enter credentials for my git remotes for each push. What's your experience?

No problems here but I only use SSH keys which are configured on my ~/.ssh directory.

I assume you can use ssh-agent somehow to save your credentials.

I use git fork on Mac, same reason, I don't remember all the commands. Also want to see the history visualization

Seconded. Easily the best UI in my opinion. I usually commit through IntelliJ and use fork for everything else.

  • 45% SourceTree
  • 45% CLI
  • 10% TortoiseGit

The repository I work in is huge, old, and the folder structures are wide and deep. It is normal to modify tens of files in almost as many folders for a single feature change.

SourceTree for managing staged files and committing.

CLI for pull, branch switching, and searching.

TortoiseGit for showing the log or blame of individual files and folders.

Since I work in Linux and primarily code in languages like C and C++ (i.e. compiled langs), I work completely in the terminal, so I don't use any GUI. It's nice and I'm already there for my compiling so I might as well use it for git.

However, re remembering all the commands, there is a nifty website I found a while ago and bookmarked called Git Explorer where you basically choose from dropdowns of what you want to do and it gives you the command(s) for it.

While I do most actions with the git command or the git fugitive plugin from tpope, I will sometimes whip out lazygit for certain things I don’t do that often.

https://github.com/jesseduffield/lazygit

I raise that by a "I wouldn't know how to survive half a day without lazygit". From my experience only maggit is in the same level - I just don't use emacs.

JetBrains have some quite extensive VC tooling built into their IDEs which I use almost exclusively. I used to do everything in the terminal, but I find it so much quicker and simpler to do it directly in the IDE.

With you on this as well. Ever since starting to use JetBrains IDE's I've rarely had to step outside of them for anything but the most complex operations. Even then I'm still likely to use the in built terminal that comes with it.

Git extensions, have been using it for years, and while the UI is not flashy, it gets the job done really really well.

Not really but sometimes if I need a visualization of something complicated that I can't see in my head I'll go to the network tab under insights in github

I use SourceTree regularly, but when shit hits the fan, I always fall back to the terminal.

If you're already comfortable working in the shell, you should check out tig. It's not as fully featured as the other clients named here, but it's an excellent viewer nevertheless.

tig is rad, though it’s more like git log on steroids than a proper UI for git commands (at least the way I use it)

I use Git Tower and I love it. I'm surprised I don't see it mentioned here.

Since I use Emacs I've been really happy with Magit, even tho it's UI has a bit of a learning curve to it. I've been also trying out Gitg since I moved back to GNOME and it's been really solid as well. It lacks a couple really nieche features but otherwise as a fast commit tracking/writing tool it's very good.

I use the default git extension in vscodium. I usually code in vscodium anyway, so I just use it to commit my changes.

I think it is a better experience, you don't forget to add file when commiting changes, it is very easy to just commit couple files (instead of typing their name, just click the plus button), and writing multiline commit message is very easy.

I am one of the few Linux user that prefer not to use commandline when there is a graphical alternative.

I use TortoiseGit.

The log window gives me overview and almost every action I need. Switching, rebasing, creating and deleting branches and tags, pushing, fetching, merging, view logs of files, diffing, blaming, filtering…

The log view is still much better than the VS Git log view. And due to it's visual GUI it's much better than CLI when going beyond just one branch or a low number of my own branches.

I use sublime merge because I really like ST and want to further support the dev. I wish it had more integrations with github (and theoretically github alternatives), but I understand the reasoning not to. Before SM came out I just used the command line exclusively.

I never use Sublime Text, but I love Sublime Merge. I dunno why. Something about the UI just works for my brain, and the merge UI is amazing. I only ever open it with smerge . in a directory, and it's set to floating in my window manager so it pops up, I do my thing, and it goes away.

I use GitKraken, which is pretty great, but for a lot of day to day stuff I just end up using the CLI

I used to use GitKraken at my old job and loved it most of the time, slick UI and generally did what you wanted to do.

I'm using Atlassian SourceTree at my current place since it's what they give us and it's...fine. Not as nice as GitKraken.

I mainly use them because I originally used TFS's TFVC when I started my career and when we transitioned to Git, I started out using a GUI so never really learned to use the CLI.

SourceTree when I was still a software engineer.

I'm a manager now, and I see people insisting on command line who have no idea what they're doing. Then don't! I think it's an awful attitude that real programmers use git command line, and GUIs are for babies. Please call out this attitude whenever you see it. Use tools that work for you. Git has a terrible user experience, let's face it.

I kinda do both? For some reason, I prefer the CLI when I clone a repo, but Sourcetree for committing, pulling, and pushing, and my IDE's built in git tools for merges.