VS Code ships with Git support. JetBrains IDEs have had it for longer and arguably do it better. Zed has it. Every editor a working developer might use in 2026 can stage a hunk, write a commit message and push a branch without a plugin.
So the standalone Git client should be dead, and it is not. Tower has been shipping since 2011 and still charges a subscription people pay. Fork sells a one-off licence. Sublime Merge exists. That is not nostalgia, and it is worth working out what the actual reason is, because "some people prefer it" is not an explanation.
The reason is that the editor's Git panel and a dedicated client are answering different questions, and the difference is structural rather than a matter of which one has more features.
#The question the editor panel answers
Open the source control view in VS Code and you get: files you have changed, a box for a commit message, and a branch indicator. That is a good interface for one specific question, which is what am I about to commit right now.
It is the right design. When you are in the middle of writing code, that is the only Git question you have, and answering it without leaving the file you are editing is exactly what you want. Nothing below is an argument against that workflow.
The limitation shows up when the question changes.
When did this behaviour change? What did that merge actually bring in? Did the fix make it into the release branch? Which of these forty commits touched the billing code?
These are not questions about your current change. They are questions about the repository, and a panel sized for a file list cannot show you the answer, because the answer is a shape rather than a list.
#What each editor actually gives you
Being specific is more useful than talking about "editors" in general, because they differ a lot.
VS Code ships a source control panel
that covers staging, committing, branching, pushing and pulling, plus a basic timeline view
per file. Its history view is a list. It has no interactive rebase, no bisect, no conflict
tool beyond the inline accept-current/accept-incoming buttons, and no graph without an
extension. Reordering three commits before pushing, for instance, means dropping into the
integrated terminal for git rebase -i, editing the todo list in a text buffer, and reading
the result back out as more text: five or six discrete steps with no visual feedback until
you are done. In a client with a graph, the same job is dragging three rows and confirming,
because the commits you are reordering are already rendered as objects you can grab.
GitLens is the extension that closes most of that. Its commit graph is genuinely good, blame annotations inline in the editor are excellent, and the search across history is strong. It is the most complete answer to this post's argument. Its limits are structural rather than functional: it lives inside the editor's window, shares the extension host process, and is a tab you switch to rather than a surface you keep open.
JetBrains IDEs have the deepest built-in Git of any editor. Interactive rebase from a dialog, a genuinely good three-way merge tool, partial commits, shelves, and a log view with filters. If you work in an IDE all day, this genuinely does reduce the case for a separate client more than VS Code does. It is still a panel, and it is still inside a process that is already doing a lot.
Zed has staging, committing, branch switching and inline blame, and is adding more. Today it is closer to VS Code's baseline than to GitLens.
The pattern across all four is the same. Everything that concerns the change you are making right now is well covered. Everything that concerns the repository as a whole is either missing, or present as a panel that has to compete for space with your code.
#The graph is the specific gap
VS Code's built-in history view is a linear list of commits. GitLens adds a proper graph, and it is good, but note what has happened: you have installed an extension that renders a graph inside a panel inside an editor. The graph is a tab you switch to.
In a dedicated client the graph is the window. Everything else, the diff, the staging area, the branch list, hangs off it. That difference in framing changes what you do, because a view you have to deliberately open is a view you consult when you already know you need it, and a view that is always there is one you notice things in.
Concretely: you pull, and you see that two feature branches merged while you were away and one of them touched the module you are working in. You were not looking for that. It was just on screen. That does not happen with a tab you open on purpose.
This is the same argument, at a different scale, as the one about which operations belong in a GUI. Some information only exists if you render it, and rendering it in a sidebar is not the same as rendering it as the primary surface.
#Separate surfaces, separate state
There is a practical dimension that gets ignored because it sounds trivial.
When you review a branch, you want the diff, the history and your code open at once. In an editor, opening a diff means replacing something in your editor layout: a tab, a split, a pane. Your editor state, which files you had open and where you were in them, is disrupted by an activity that has nothing to do with editing.
A second window sidesteps that entirely. Diff on one monitor, code on the other, and your editor is exactly as you left it when you go back to work.
Same for release management. When you are checking what is going out, or assembling release notes from a tag range, you want the whole history visible: tags, branches, the lot. Squeezing that into a 400 pixel sidebar next to your code is a compromise that exists for no reason other than that the panel lives in the editor.
#The AI workflow made this sharper
The change over the last two years is that developers now spend a much larger share of their time reading diffs rather than writing code.
If an agent is generating changes, your job is review, and review is continuous. You are looking at a diff every few minutes, deciding what to keep, staging selectively, and committing checkpoints.
That workload does not fit a sidebar. When reviewing diffs is the main activity rather than a step before committing, the diff wants to be a full window with room for context, not a panel competing with your file tree. And when the agent is running in a terminal, having that terminal in the same window as the diff removes the switch that otherwise happens fifty times an afternoon.
#The performance argument, honestly
Your editor already runs a lot. A renderer process, an extension host, one or more language servers, a file watcher, a terminal, and whatever your AI assistant needs. On a large TypeScript project that is several gigabytes before you have opened anything else.
Adding a second Electron application to that mix means another full browser runtime, with its own renderer and its own memory. This is why several well-regarded Git clients feel sluggish on the machines where you most need them, which is large repositories on a laptop that is already working hard.
A native client is a different proposition. Gitoryx is built with Tauri, which means the Rust binary handles the Git operations and the system webview handles rendering, so there is no bundled Chromium. That is one fewer browser engine resident on a machine that is already running one for your editor.
#When the editor is genuinely enough
The case for a dedicated client scales with complexity, and plenty of work is not complex.
A solo project with a linear history and one branch does not need a graph, because there is nothing to see. A small team where every pull request is one commit and gets squashed on merge has no branch structure worth rendering. If you commit two or three times a day and have never wanted to reorder a commit, your editor covers you completely.
The variables that shift it are repository size, number of contributors, history length,
and how much branching your process involves. Any of those going up makes the editor panel
start feeling thin, and usually you notice it as a habit rather than a decision: you find
yourself in a terminal running git log --graph several times a week.
A few concrete triggers, since "it depends" is not useful advice:
- You have opened a browser tab to read a repository's network graph.
- You have run
git log --graph --alland still could not work out what happened. - You have resolved a merge with more than five conflicts in the last month.
- You regularly work across more than three repositories in a day.
- You have wanted to know what was in a release without reading forty commit messages.
One of those is nothing. Three of them, weekly, means you already have the workload a dedicated client is for.
This is the same threshold from the other direction as the one a beginner-friendly client like GitHub Desktop eventually hits: one tool is too simple to grow with you, the other is a good tool being used outside its design goal.
#Where that leaves it
The editor's Git integration is not going away and should not. For the change you are making right now, in the file you are looking at, it is the correct interface and always will be.
What it cannot be is the surface where you understand the project. That job wants its own window, its own layout, and a graph rather than a list. Whether you need that surface depends entirely on whether your repository is complicated enough to have questions the panel cannot answer.
If you have never had one, you do not need a client. If you have three a week and you keep answering them in a terminal, you have already decided, you just have not installed anything yet.
