Free Tools

3,113 likes 12 talking about this. GitKraken is the intuitive and elegant Git GUI for Windows, Mac & Linux. Unleash GitKraken, the free Git GUI for Windows, Mac & Linux! This intuitive Git GUI simplifies and streamlines Git processes. The GitKraken Git GUI is like no other tool of its kind on the market for many reasons, but this is a big one. No other Git clients offer robust integrations with the most popular issue trackers used by software developers and teams. The GitKraken Git GUI integrates with the following issue trackers: Jira Cloud/Server; GitKraken Boards.

Get a free GitKraken Pro Suite account through the GitHub Student Developer Pack! Your Pro Suite account will include the GitKraken Git GUI with advanced features, GitKraken Boards for task tracking, and GitKraken Timelines for communicating project milestones.

GitKraken Git GUI

The GitKraken Git GUI is a cross-platform client for Windows, Mac, & Linux, simplifying complicated Git commands into drag-and-drop actions. GitKraken offers seamless integrations with GitHub and GitHub Enterprise. Resolve merge conflicts without leaving the app, and use GitHub Actions to create workflow automations.

GitKraken Boards

GitKraken Boards provides a more productive way to track issues from inside the GitKraken Git GUI, a browser, mobile app, or inside of Atom or VS Code! GitKraken Boards syncs in real-time with GitHub Issues and GitHub Milestones. Link cards to GitHub pull requests, check PR/build statuses and auto-update cards from GitKraken Boards. Use GitHub Actions to automate your workflow.

GitKraken Timelines

GitKraken Timelines helps you stay organized by visualizing your upcoming project milestones and deadlines in a linear timeline. Add items that need to be completed for each milestone. Create timelines for each class or project and then view them layered on top of each other. Add images to milestones and as background images.

The typical workday for a developer using Git involves a variety of different tasks. Between generating new SSH keys, cloning Git repositories, viewing commit diffs, creating pull requests, and on and on. But do you ever sit back and think about how much time you’re spending on each of these seemingly smaller tasks? Trust us, it adds up.

The concept for the GitKraken Git GUI was born from this very frustration. Typing a line for each action, praying you don’t run into a conflict, and hoping anyone you collaborate with is as much of a command line expert as you are.

In this article, we will explore how GitKraken can help you spend less time typing, give you the confidence to stop worrying about making mistakes, and ultimately improve your Git productivity.

When is GitKraken faster than the CLI?

Specifically, GitKraken zooms past the command line when comparing the time it takes to accomplish the following tasks in our GUI vs CLI:

• Authentication (setting up an SSH key and adding it to the remote)

The Authentication Process in Git

In order to interact with your remote repos, you need a way for your local machine and the remote machine to communicate. In Git, the most common communication channels are HTTPS and SSH.

The HTTPS URL only requires a username and password for authentication. Whereas SSH requires an SSH key that can be generated using the command line. Using SSH requires one extra step, which is adding the SSH key to the hosting service. Adding the key to the host—GitHub, GitLab, Bitbucket, Azure DevOps, Git server—allows the remote to know which connections are authorized to communicate with your repos.

Setting up your SSH authentication through the command line is a long and tedious process. First, you need to figure out, or remember, which command to utilize. This could entail an Internet search, or maybe you’ll phone a friend or ask a colleague. The latter strategy is sure to end in a Google search anyways, because no one can remember Git commands.

Next, you’ll need to worry about typing everything correctly. Or you can try copying-and-pasting (but boy, I hope for your sake the email is correct).

ssh-keygen -t rsa -b 4096 -C 'your_email @ example.com'

After you’ve discovered your typing skills need improvement and you have the SSH key generated, you are finally ready to add the new key to your host.

Compare this to GitKraken, which makes this grueling process of setting up your SSH keys quick and easy with just a few clicks and no room for error.

Cloning in Git

Now that you’ve set-up your authentication, you can start interacting with the repos on your remote. One common task when working in Git is to clone a remote repository to your local machine. Good thing you have all of your remote URLs memorized….

If using the command line, you first have to obtain your remote URL from the hosting service by logging in.

Next, you’ll have to figure out whether you need an SSH or HTTPS URL and determine the difference.

After spending 10-15 minutes trying to obtain, and then finally locate, your remote URL, you can now use the command git clone <clone URL>.

Comparing the experience in GitKraken: we provide you with a clear list of all repos on your remote from the clone menu.

From the clone menu, you will select a directory where you wish to clone your repo. Then, simply name the clone (or keep the default name) and click the Clone the repo! button. Your repository is then cloned and ready for you to start work on your local machine. Easy as that!

The beauty of setting up the integration in GitKraken is that the clone will automatically happen over SSH if you’ve taken the time to setup your SSH authorization. (If you don’t have SSH setup, the clone will default to HTTPS).

Visualizing Your Commit Graph

All commits are just one long straight line, right? They don’t have to be!

The process of visualizing your commit history in the CLI entails:

Gitkraken Gitignore

Git log --all --decorate --oneline --graph

And then you get this…

GitKraken provides a much different, and more visually-appealing, experience.

As soon as you open a repository in GitKraken, you’re greeted with our beautiful, technicolor commit graph. Our application’s UI is one of our users’ favorite features.

Directly from the graph, you can easily view your different remote branches. You can also click on any commit to obtain details like the commit message, author name, date, and any additional context available.

No need to remember or type any commands into the CLI!

Communicating with Remote URLs

How are you communicating with your remote? It’s crucial that you know what communication method (HTTPS or SSH) you’re using to perform actions, like pushing or cloning, on your remote. You also have to be extremely diligent about where your changes are being applied. Keeping track of this in the CLI can be cumbersome.

Let’s say, for instance, that you forget your communication method while communicating with a remote in GitKraken. You can quickly resolve the issue by right-clicking on the remote from the left panel and clicking Edit. From here, you can view or edit the remote URL.

Additionally, under the Remote section on the left panel, you can see any other remotes you have added to the project. This is valuable for many reasons.

Let’s say one of your colleagues is having an issue with the code they’re working on. You can easily add their forked remote and start looking at the changes they’re working on to provide guidance.

GitKraken was designed with team collaboration in mind, a task notoriously difficult in the CLI.

Diff View

In GitKraken, you can compare file changes with our Diff Tool, giving you the ability to quickly see what was added or removed from a file.

GitKraken comes with a built-in Diff Tool, easily allowing you to view changes made to a file. The tool also allows you to choose individual lines or hunks of a file to stage.

GitKraken’s Diff Tool comes with the following features:

• Word diffing
• Syntax highlighting
• File mini-map
• Arrows to move between change sets

You can access this view by clicking on any commit from the graph, including your WIP, and then selecting a file from that commit. You will then be brought into Diff View where you will be shown the different hunk changes for that specific file.

In addition to Hunk View, you have Inline View and Split View. You can easily toggle between Hunk, Inline, and Split views.

Accessing Diff View in GitKraken vs the CLI

Selecting two commits from the central graph in GitKraken will render the diff between those two commits.

Alternatively, selecting the head commits from two branches will allow you to see the diff between those branches.

Now, let’s give it a shot in the command line. At first glance you might say to yourself… “Well, I just take commit1 and compare to commit2.” Seems easy, right?

First things first: let’s find the commits we wish to compare. That process looks something like: git log --graph --all to show all branches and commits (unless you have the SHA’s for the commits memorized). Or you can cheat and use GitKraken to copy one of the commit ids like I did below. 🤓

From here, you would then run git diff commit1 and commit2.

Now remember: this is me telling you the commands you need; serving them up on a silver platter. What you don’t know is that my friend Google helped. So it’s either a quick click-click, OR the grueling process of type->google->type->google->type->google->google->type. 😅I will opt-in for click-click.

Pushing

Pushing is when you take local changes and make them available on the remote.

Ok, Ok…to be fair, pushing is pretty easy, whether you’re using a tool like the GitKraken Git GUI, or the CLI. You just make your changes and push.

However, it’s important to draw a distinction here. When operating from the command line, you will always have to remember the commands to perform an action. Even if you’re like the creepy villain from the Green Lantern, you only have so much brain power to give in one day. With GitKraken, pushing your local changes to your remote is just one click away.

The beauty of performing a push in GitKraken, as is true for most all Git actions, is that you’re able to successfully complete a task while preserving mental energy. Simply click the Push button and voila. On to the next one.

File History and Blame

So, you want to know the history of a file in your project; you want to know eeeeverything it’s been through to get to where it is now. This is often referred to as accessing a file’s history and blame.

Sure, the effort needed to accomplish these tasks in the CLI is seemingly low, but evaluating the end result is where you’re going to spend your time.

To access a file’s history in the CLI, you will type the command git log --follow {file-name}. And you get…

And, to access blame: git blame {file-name} to get…

Not the clearest history log, is it?

GitKraken, by comparison, offers a quick and convenient option to view a file’s history and blame in a clear and legible way. Let’s just say…Git log is history, and GitKraken is making history. 💥

To access the File Blame or File History options, select a file from the right commit panel to view the file’s Diff. The options to view Blame and History will appear in the Diff View.

In this view, you can toggle to see the Diff, which shows the exact lines of code that were changed from a past version of a file to the current version, giving you the ability to revert back to previous versions if newer changes aren’t working out.

Alternatively, click to see the Blame, which shows exactly who made what code change when.

Finally, you have the ability to view the file’s full history, which shows all code changes made to a file listed in chronological order, and you can see all of the file’s collaborators listed with their gravatars on the left side.

Let’s just take a moment to reflect on how much more context GitKraken provides for file history than what’s accessible via the command line. Slow clap anyone?

Pull Requests & Merge Tools

While the former items included a comparison of performing actions in the CLI vs GitKraken’s Git GUI, there are several features—all designed to make developers more productive —included in GitKraken that are simply lost in translation when working in the command line. Let’s look into a few of these, including pull requests and merge tools.

Pull Requests

While not necessarily a fundamental component of Git, pull requests are standard when collaborating with team members or contributing to an open source project.

What is a pull request? A pull request occurs when someone makes local code changes and submits those changes to a remote project maintainer for review before the changes are implemented, or merged. You are requesting that someone reviews and approves your changes before they become final.

Creating a pull request is an easy drag-and-drop action in GitKraken, allowing you to create pull requests for multiple remotes. Take a local or remote branch and simply drop it onto the target branch. You will then see the option to create a pull request. The same is true for any additional remotes you wish to create PR’s for. Try doing that in the CLI.

Merge Conflict Editor

The GitKraken merge tool is one of GitKraken’s most valuable features for maximizing your workflow productivity with Git. Because Git does not have a built-in merge tool, the CLI requires users to either set one up through the .gitconfig, or by manually handling conflict chunks in a text editor. Ain’t nobody got time for that!

With GitKraken, it’s built in with a paid version, saving you the time and hassle of finding an external tool and setting it up in the CLI.

Quite frankly, GitKraken’s merge conflict editor could easily end the GUI vs CLI argument on its own.

Interactive Rebase in GitKraken

Even for the best of us, there comes a time when you may need to rewrite your commit history. GitKraken allows you to do this in minutes with our interactive rebase feature.

With GitKraken, simply drag your desired branch to the target branch where you wish to initiate the interactive rebase. You can also perform an interactive rebase on a set of commits on the same branch. From the Interactive Rebase modal you can squash, reword, drop, or reorder the commits. Now get back to work!

Life’s Too Short for the CLI

We’ve said it before, and we’ll say it again. Life’s too short to be using the command line for your daily Git actions. We totally understand the importance of learning the CLI, and maybe even kind of understand if you like performing certain Git actions the hard way. But developers can no longer dismiss the benefits of using a Git GUI like GitKraken.

Facts are facts. You will have a faster, more optimized workflow with a GUI. Every. Time.

How does GitKraken speed up your workflow?
Show us how GitKraken maximizes your workflow and we will give you $10 off GitKraken Pro. Share a video (or gif) showing a comparison of you performing a task in the GitKraken Git GUI vs the command line and share on Twitter, Facebook, or YouTube. Please make sure to tag GitKraken in your post.

Gitkraken Gitignore

Stay on the cutting edge of software development by getting innovative tips, trends and stories delivered to your inbox every month!