Source Tree: A Beginner’s Guide to Managing Git RepositoriesSourceTree is a free GUI client for Git and Mercurial, developed by Atlassian, that simplifies version control workflows by providing a visual interface for repository management. This guide walks you through the essentials — from installation and basic concepts to common workflows and troubleshooting — so you can confidently manage Git repositories using SourceTree.
What SourceTree Does and Why Use It
SourceTree translates Git’s command-line operations into a graphical interface, showing branches, commits, diffs, and pull requests in an accessible way. It’s useful for:
- Visualizing branch structure and history
- Staging, committing, and pushing changes without memorizing commands
- Resolving merge conflicts using built-in diff tools
- Integrating with remote hosting services like GitHub, Bitbucket, and GitLab
Pros: easier learning curve for beginners, clear visual history, integration with hosting services.
Cons: less flexible than CLI for advanced scripting, occasional UI-specific quirks.
| Feature | GUI (SourceTree) | Command Line |
|---|---|---|
| Ease of use | High | Medium–Low |
| Visibility of history | High | Medium |
| Scripting/automation | Low | High |
| Resource usage | Medium | Low |
Installing SourceTree
- Download SourceTree from the official Atlassian site (choose macOS or Windows).
- Run the installer and follow prompts.
- On first run, you’ll authenticate with Bitbucket or configure other services manually. You can skip signing in but linking an account simplifies cloning and pull requests.
- Configure your Git settings: username, email, and SSH keys (recommended for secure push/pull).
SSH key setup summary:
- Generate an SSH key pair (e.g., with ssh-keygen).
- Add the public key to your Git host (GitHub/Bitbucket/GitLab account).
- In SourceTree, ensure the SSH client setting matches your key (PuTTY/ OpenSSH) and that Pageant or your OS key agent is running if required.
Core Concepts: Repositories, Branches, Commits
- Repository: the project folder tracked by Git. Can be local and/or linked to a remote.
- Commit: a snapshot of changes with metadata (author, message, timestamp).
- Branch: an independent line of development. Branches make it easy to work on features without affecting main code.
- Remote: a hosted copy of a repo (origin is the default remote name).
SourceTree’s main window shows the commit graph, file status, and a sidebar with remotes and branches — making these concepts concrete.
Cloning and Creating Repositories
Cloning:
- Click “Clone” in SourceTree.
- Enter the repository URL (HTTPS or SSH), choose a local path, and clone.
- After cloning, the repo appears in your bookmarks and the commit history is loaded.
Creating a new repo:
- File → New → Create Local Repository.
- Initialize with a README if desired.
- Add a remote later via Repository Settings → Remotes.
Common Workflows
-
Making Changes and Committing
- Edit files in your editor.
- Back in SourceTree, view changed files in the Working Copy view.
- Stage files by checking them or use “Stage All”.
- Write a clear commit message and click Commit.
-
Branching and Merging
- Create a branch: Branch button → name it (e.g., feature/login).
- Switch branches by double-clicking the branch name or using Checkout.
- Merge: checkout target branch (e.g., main), then Merge → select source branch → Merge.
- Resolve conflicts if prompted (see below).
-
Pulling and Pushing
- Pull to fetch and merge remote changes: Pull button → choose remote/branch.
- Push to upload commits: Push → select branches to push to the remote.
-
Rebasing
- Use rebase for a linear history: right-click a branch → Rebase onto another branch.
- Be careful rebasing shared branches — it rewrites history.
-
Stashing
- Use Stash to save unfinished work: Actions → Stash Changes.
- Apply or pop the stash later to restore your working copy.
Viewing Changes and Diffs
SourceTree provides a diff pane that shows file-level and line-level differences. Use the sidebar to select commits and view:
- Commit message and metadata
- Tree of files changed
- Side-by-side or unified diffs
For large repos, filter diffs or use the search box to find commits by message, author, or hash.
Resolving Merge Conflicts
When Git can’t automatically merge, SourceTree flags conflicts in the file list.
Steps to resolve:
- Open the conflicted file in SourceTree’s external merge tool or built-in diff viewer.
- Manually choose between “yours” (current branch) and “theirs” (incoming) changes, or combine both.
- Mark the file as resolved in SourceTree and commit the merge.
Configure an external merge tool (Beyond Compare, KDiff3, Meld, etc.) in Tools → Options → Diff.
Working with Remotes and Pull Requests
- Add remotes via Repository Settings → Remotes.
- Fetch to update remote refs without merging.
- Create pull requests: SourceTree integrates with Bitbucket and can open PRs on the host web UI. For GitHub/GitLab, SourceTree can open the remote URL in your browser to create the PR.
Tip: Keep branches small and focused; one branch = one feature/fix.
History, Tags, and Cherry-picking
- Tags: create tags for releases via Repository → Tag.
- Cherry-pick commits: right-click a commit → Cherry-pick to apply it to the current branch.
- Reset types: soft (keeps changes staged), mixed (keeps changes unstaged), hard (discards changes). Use Reset carefully.
Advanced Tips
- Use .gitignore to avoid committing build artifacts. SourceTree shows ignored files in a separate list.
- Configure line-ending handling (core.autocrlf) to prevent CRLF/LF issues across OSes.
- Use bookmarks to manage multiple repos in SourceTree.
- For large repos, disable file status refresh or increase cache to improve performance.
Troubleshooting Common Issues
- Authentication errors: confirm credentials, switch to SSH, and check saved passwords in credential manager.
- Missing commits after rebase: you may have rewritten history; check reflog (git reflog) via terminal to recover.
- Large files: Git LFS recommended for files >100 MB.
- Slow performance: update SourceTree, limit background processes, or use CLI for heavy operations.
When to Use CLI vs. SourceTree
- Use SourceTree for visualizing history, routine branching, and simpler workflows.
- Use the command line for automation, complex rebases, scripting, or when SourceTree’s UI is limiting.
Quick Reference — Common Commands in SourceTree Terms
- Clone → Clone remote repo locally.
- Commit → Stage + commit changes.
- Push → Send commits to remote.
- Pull → Fetch + merge remote changes.
- Fetch → Update remote refs only.
- Checkout → Switch branches.
- Branch → Create a new branch.
- Merge → Combine branches.
- Rebase → Reapply commits on top of another base.
Further Learning Resources
- Official Git documentation for in-depth Git behavior.
- Atlassian’s SourceTree support pages for GUI-specific help.
- Tutorials on branching strategies: Git Flow, GitHub Flow.
SourceTree lowers the barrier to entry for Git by visualizing repository state and simplifying common tasks. With the basics above — cloning, committing, branching, merging, and resolving conflicts — you’ll be able to manage repositories effectively and choose when to drop into the CLI for advanced needs.
Leave a Reply