neogit VS lazygit

Neogit

I would use this feature of lazy.nvim in a plugin that I rarely need. Something neogit for example. I can spend hours coding without using it. In that particular case I think is nice to have the option to load it when I actually call it.

This looks very much like the Noevim plugin I began using about a month ago: neogit[0].

The keybindings were a bit rough, and it took me about an hour of use before I was really comfortable with the overall workflow. Once I was, though, I’ve found it to be much faster than my previous workflow (suspending neovim and using git directly in the shell).

0: https://github.com/NeogitOrg/neogit

Edit: FYI: I made a feature request and got the answer, that it it possible to visually select the files and discard them like this together.

This is what I use for general git interaction and it‘s pretty neat: neogit. Also integrates diffview

For neovim users, there's a work-in-progress clone, neogit: https://github.com/timUntersberger/neogit/

Some of my colleagues use emacs/magit, and after seeing how absolutely lovely the workflow is, I've put in a lot of work over the last few months expanding it. You can check out my fork here: https://github.com/ckolkey/neogit/

One thing I particularly like to tease my emacs' colleagues about is that my magit is faster than theirs thanks to neovim's async capabilities.

You could use neogit (https://github.com/TimUntersberger/neogit) for basic commands however I have found it's easier / more versatile to just use lazygit in either another tmux tmux window or within neovim itself.

The only thing I truly miss from Emacs is [Magit](https://magit.vc/) since I still consider it the best git wrapper available. It is just too good. Unfortunately [Neogit](https://github.com/TimUntersberger/neogit) is not quite there yet although I hope it makes it at some point. I didn't like [Fugitive]https://github.com/tpope/vim-fugitive), but I ended up finding a good enough workaround by using [Lazygit](https://github.com/jesseduffield/lazygit) through [Toggleterm](https://github.com/akinsho/toggleterm.nvim).

While design is an important part to some degree, there is something more that I've become observing and, therefore, liking lately: the reasonable default configs of the apps, which mean that the majority of the users will never need to mess with configs at all. Here is a great post by Arne about this trend which lists such tools like Fish (mentioned above), Helix, Lazygit, Zellij, k9s, etc. And that a very user-friendly approach: install and use right away! I believe that Ghostty would be a good addition to the list. For example:

lazygit

There're multiple solutions like this and I've used some of them over the past years.

- There's obviously the fantastic Magit (https://github.com/magit/magit) which is an Emacs Plugin but you can configure your Emacs start up just with Magic and nothing else so that Emacs is only used as a TUI Git client. I did this for a while.

- There's GitUI written in Rust (https://github.com/extrawurst/gitui) I did use this for a long time but recently switched over to LazyGit for the better Vim bindings and having more features

- LazyGit (https://github.com/jesseduffield/lazygit) is what I'm using right now and I'm mostly happy

I actually wrote my own in C some years ago called Gitsi (https://github.com/terhechte/gitsi).

One thing that I added that (as far as I know) none of the others have and I sorely miss is VIM number based movements. So you can say 4j and jump 4 selections down. This makes it much faster (for me) to jump to the one file I'd like to commit. I ultimately stopped developing Gitsi because I didn't have the time to implement all the features others had readily available.

I do prefer TUI based Git clients to full blown GUI apps because of the keyboard movement. So I can quickly enter do something and exit, while staying in the terminal

If you like lazydocker also check out lazygit by the same author: https://github.com/jesseduffield/lazygit

Below is an example of the lg output using the lazygit repo:

For the TUI inclined, lazygit [1] and magit (emacs) [2] both have quick and intuitive ways of handling this. They're also both wonderful companions to the git cli for day to day version control.

[1]: https://github.com/jesseduffield/lazygit

[2]: https://magit.vc/

I came to suggest (once again) lazygit.

https://github.com/jesseduffield/lazygit

Love the ability to pull a hunk out of a commit, create a new commit, then throw it over to another branch, with the press of a few keys.

That's why someone (aka jesseduffield on Github) invented Lazy Git.

Lazygit (https://github.com/jesseduffield/lazygit)

I know there are probably many GUI git tools and editor integrations which make using git fast and easy but I've been mostly using the CLI. Lazygit makes doing things like cherry picking really easy and once you learn the shortcuts it's pretty fast to use.