Hacker News Reader

I know you said GUI, but this single-line git alias that goes in ~/.gitconfig changed my life and I don't look for a git GUI anymore:

    [alias]
 l = log --date-order --date=iso --graph --full-history --all --pretty=format:'%x08%x09%C(red)%h %C(cyan)%ad%x08%x08%x08%x08%x08%x08%x08%x08%x08%x08%x08%x08%x08%x08%x08 %C(bold blue)%aN%C(reset)%C(bold yellow)%d %C(reset)%s'

Next, go to one of your git project directories and type "git l"

If you don't want to learn rebasing and other Git fun, I'm not sure how much this will help you, but for me it's invaluable when it comes to identifying the base of my branch and where I would like to transplant it to.

Along with the basic "git pull --rebase" I also frequently use "git rebase --onto" and "git pull --rebase=merges" or "git rebase --rebase-merges" in my projects in order to manage branches that were created in an order other than what I want them to merge in. This keeps the history nice and linear, so I can avoid having any commits with two or more parent commits.

I don't find there's much else I would want to have a GUI to help with. But without a git graph that I can scroll freely, I feel as if I could not do my day-to-day work with such ease. This makes the most usable git graph with colorized edges and may be all you need. That, along with a nice PS1 setting so you get some branch status information right in your terminal status line without asking for it every time.

If you liked that alias, check out tig, which is a very simple TUI for git. It gives you a browsable graph, and other nice things. It also does "tig blame" with going back to revision before a specific line with a single key shortcut.

How on earth did you create that format string? That alias generates really nice output!

It appears to have come from this guy, here is the original gist: https://gist.github.com/msroot/6206676

Finally ended with such a modification:

  [alias]
  glog = log --date-order --graph --all --date=short --pretty=format:"%x09%C(auto)%h  %C(cyan)%ad  %C(green)%<(12,trunc)%aN    %C(reset)%<(50,trunc)%s    %C(auto)%d"

Finding a decent GUI is definitely the biggest pain point in switching to git for us. It's not just that git GUIs are lacking generally, it's that there's fragmentation - the best ones on one OS don't necessarily work on other OSs. Tortoisehg was so universal that it practically was mercurial, for the purposes of many users. We are scientists and wanting to attract contributions to our code from other scientists and grad students who can code somewhat but are unlikely to have used version control before interacting with our project. Having a universal GUI was excellent for mentoring people and spreading the knowledge around. It's going to be much harder with git (since we are moving to github - I like what sourcehut is doing for devs, but email-based pull requests will mean we get very few contributors who aren't already seasoned devs, so we have decided against it for now).

From my experimenting, I'm liking Sublime Merge as my favourite git GUI so far. It's nagware (i. e. no time limit evaluation period) like sublime text, and costs US$99 to remove the nag and enable the dark theme. It is pretty and functional without being overwhelming in its interface.

Am I the only person who uses gitk and doesn't have any real problems with it?

I used it previously. But it doesn't support a lot of operations, it's mostly good for visualising what's happening while you do your work in the command line.

I've been using SourceTree in Windows. But it's slow and I really hate that they put the staging area and the file tree into the same control.

Heard of Fork [1] and switched in a heart beat. Works like a charm and looks great. Unfortunately only for Windows and Mac. I fall back to the command line on Linux.

[1] https://git-fork.com/

> And picking source and destination commits for a rebase is much easier visually on the commit graph than making note of hashes on the command line.

In git branches are more comparable to hg bookmarks and used so heavily it feels very rare from the command line where you would directly use a hash rather than a branch name.

> Related question: does anyone know of a good git GUI that works on Windows and Linux? (Ideally, but not essentially, free.)

If you are happy with the Tortoise family there is a TortoiseGit [1]. I think the Tortoise "family" still shows its roots in SVN much too often to be a "great" Git GUI, but it should certain feel comfortably familiar. Though like TortoiseSVN, TortoiseGit only supports Windows. It's interesting that TortoiseHg was the only one in the "family" to invest in cross-platform.

GitHub Desktop can be a useful cross-platform GUI sometimes, especially for somewhat less code-focused folks. While it puts GitHub front and center, it's still a general purpose enough tool.

Git has an "okay-ish" cross-platform GUI that is almost always bundled with it called "Git GUI". I don't know a lot of people that recommend the main interface for Git GUI, it's an ugly Tk-based throwback, but it does cover almost all of the basics of TortoiseGit without as much direct shell integration. (It has some bare shell integration into the right-click context menu as an optional checkbox buried in the Windows install at least.) On the other hand, while almost no one uses the main commit-oriented parts of Git GUI, its commit graph viewer `gitk` (which is almost always available in the PATH by that name) is almost an almost indispensable power tool, and I think still the commit graph tool to beat for git. `gitk` is great, and years ago became my muscle memory over `git log` for a lot of situations.

At this point the most common cross-platform "GUI" I use day-to-day with git though is just VS Code. It's built in git support is sufficient for a lot of work, and there are some useful, optional power tool extensions like "Git Lens" that make it even better.

[1] https://tortoisegit.org/

What about https://www.sublimemerge.com/ ?

The gui tools bundled with git for committing and browsing allow doing most things one would require and are cross platform

[1] https://git-scm.com/docs/git-gui [2] https://git-scm.com/docs/gitk

gitk is a bit ugly, though.

How about VSCode? Basic stuff like staging, committing, merging, stashing, pushing, pulling, are all baked in. Even staging parts of a file are straightforward, and resolving conflicts in VS code is more pleasant than any other tool I've used.

There are extensions that cover more advanced cases, too, such as creating/reviewing Github PRs, reviewing the commit graph, etc.

Magit is a good one. But its an emacs package and, well, I wouldn't want to shy over the fact that it may require some effort.

Magit is probably the most productive git client I've ever used. The only caveat is that some operations on certain repos can take a lot of time and CPU power, and lock up Emacs while they're going on.

Most of the people in my office use SmartGit[1]. It seems pretty powerful, it supports worktrees, and I like how it has a window that shows the actual commands that it's running.

[1] https://www.syntevo.com/smartgit/

We use it at work as well. It's a bit ponderous when starting, being written in Java, but has a very good conflict merge window.

I really liked SourceTree around version 1.7, but the new GUI is not so comfortable to me. I'm also looking for an alternative.