
Tig: text-mode interface for Git - skeuomorf
http://jonas.nitro.dk/tig/
======
wtbob
Pretty neat. Another terminal/GUI interface is Magit, the emacs mode for git.

Stuff like this is nice because it does let one directly manipulate objects
within a git repository easily with a few keystrokes, rather than having to
type 'git exchange-frobnozz --quark-handler=positronium' constantly (or having
a million aliases, each of which is useful right up until it needs to be
modified slightly).

The disadvantage, of course, is that one really should still know how to use
git competently at the command line for the 15% of tasks such wrappers aren't
good at.

~~~
skeuomorf
I recently switched from vim to emacs (mostly cause I want to mess around with
LISPs and emacs LISP support is good e.g. CIDER) and I've had my eye on Magit
from the get go, haven't had the time to mess around with it yet but
definitely looking forward to do that.

>The disadvantage, of course, is that one really should still know how to use
git competently at the command line for the 15% of tasks such wrappers aren't
good at.

I definitely agree with this. I always learn the core technology before
learning any convenience layer/wrapper/abstraction e.g. {(git, Magit), (CSS,
-Insert Grid Framework-)}.

~~~
cmiles74
IMHO, Magit is easy to pick up and well worth the modest time investment. I
have found the new release to be pretty speedy and making the commit directly
from within Emacs is very handy.

------
moonshinefe
I use this tool quite a bit. It's pretty nice, especially when SSHing into
remote systems that don't have any UI available, but you need to do work with
git repositories.

It's the best text-based tool I've seen for quickly visualizing git histories
and diffs for each commit.

~~~
weitzj
I like it a bit more colourfull and have more space for the commit notes than
for the author's name:

    
    
      ~/.tigrc
    
    
      set git-colors = no
      set show-changes = yes
      set commit-order = topo
      set refresh-mode = auto
      set main-view = \
        date:default \
        author:abbreviated \
        id:yes,color \
        commit-title:graph=yes,refs=yes

~~~
nilkn
Very cool, I've been using tig all this time and never even bothered to
realize it was customizable.

------
nyir
The one thing tig is really good for imo is the interactive log view with
branch information etc.; it also loads asynchronously, so e.g. the Emacs
repository will still take quite a while to load for all commits, but it's
usable in the meantime.

~~~
andrewla
Agree strongly. I find all the functionality unrelated to log exploration to
be extraneous at best, and dangerous at worst, when a simple key press can
actually make unexpected changes.

I'm perfectly comfortable on the command line for all the tasks except log
exploration, where I find the interactive elements to be indispensable to
prevent constant copying and pasting between log/diff/blame/show.

------
nhaehnle
One of the nice things about tig is its configurability. I have this in my
~/.tigrc, which helps a lot with my workflow:

    
    
        bind main R !git rebase -i %(commit)
        bind main M !git merge --ff-only %(commit)

~~~
theOnliest
I added that R binding a couple of months ago, and it is magical. I hated
having to git log, copy the sha, and then 'git rebase -i [paste]' every time.
I've mostly switched over to magit, but this is one thing I still use tig for.

~~~
matthiasv
For me, rebasing usually concerns roughly the last N commits, which is why I
don't bother running `git rebase -i HEAD~N` and ignore and commits I don't
want to modify.

------
jackbravo
Atlassian had a great blog post about tig that convinced me to start using it:

\- [https://blogs.atlassian.com/2013/05/git-
tig/](https://blogs.atlassian.com/2013/05/git-tig/)

------
stonewhite
Maybe it is a problem of me, but can't really get to use a visual front-end or
framework (like gitflow) for git.

It almost always feels (inferior|complicated|bloated) compared to vanilla
command line usage.

~~~
0x0
A visual tree view of how commits relate to various branches are always
useful, doubly so when you can browse the diffs for the commits "point-and-
click" (or arrow-keys, in this case)

------
hardwaresofton
It would be nice to have pictures of the thing on the homepage... or anywhere
linked. I had to find the atlassian link to even know what it looked like.

[EDIT] - I missed the folder called screenshots on the front page that has
screenshots in it.

Also Magit, if you use emacs.

~~~
splitbrain
See
[http://jonas.nitro.dk/tig/screenshots/](http://jonas.nitro.dk/tig/screenshots/)

------
fougerejo
I use tig daily, it's so much faster to select the files/chunks/lines to add
to the staging area than with the command line.

~~~
sevensor
Staging view is quite useful and I spend a lot of time there too. Also, maybe
because I haven't tried enough of the alternatives, I think tig does the best
job of visualizing the commit graph.

------
leephillips
If you use vim, fugitive is a pleasant and powerful wrapper for git.

~~~
tomswartz07
To further expand on your comment, Tim Pope's Fugitive plugin is an almost
exact replica of OP's tig program.

Fugitive allows you to perform almost all of these actions while still in Vim;
I'd say it's almost a must-have for anyone who uses Vim and Git.

------
ausjke
Use this often, it's great and neat.

------
jonsterling
I rely heavily on tig. highly recommended

