Git & Version Control

Git Tutorial for Beginners — Learn Git in 20 Minutes

Git tutorial for complete beginners — install Git, create a repository, stage and commit changes, branch and merge, and push to GitHub

Git Branching Strategies — Git Flow, GitHub Flow, Trunk-Based

Git branching strategies compared — Git Flow, GitHub Flow, Trunk-Based Development, and which to choose for your team and release cadence

Git Merge vs Rebase — When to Use Each

Git merge vs rebase explained — merge commits vs linear history, when to merge and when to rebase, and how to avoid common rebase mistakes

Git Workflow — GitHub Flow, Git Flow, and Trunk-Based Compared

Git workflows compared — GitHub Flow for continuous deployment, Git Flow for releases, Trunk-Based for CI/CD, and how to implement each with your team

Git Commands Cheatsheet — The Only Reference You Need

Git commands cheatsheet — every Git command organized by category with examples: commits, branches, remotes, merging, rebasing, stashing, and troubleshooting

Git Reset, Revert, and Checkout — What's the Difference?

Git reset vs revert vs checkout explained — how each command works, when to use them, and how they affect your working directory and commit history

Git Stash — Save and Restore Work in Progress

Git stash tutorial — save uncommitted changes, apply them later, manage multiple stashes, and use advanced stash features like partial stashing

Git Hooks Tutorial — Automate Your Git Workflow

Git hooks explained — pre-commit hooks, commit-msg hooks, pre-push hooks, client-side and server-side hooks with practical examples in Bash and Python

Git Rebase Tutorial — Interactive Rebase Explained

Git rebase tutorial — basic rebase, interactive rebase, squashing commits, rewording messages, reordering, and fixing rebase conflicts

Git Cherry-Pick — Applying Specific Commits

Git cherry-pick tutorial — apply specific commits from one branch to another, cherry-pick multiple commits, resolve conflicts, and best practices

Git Bisect — Find the Commit That Introduced a Bug

Git bisect tutorial — use binary search to find the exact commit that introduced a bug, automate with tests, and speed up debugging

Git Tags — Versioning and Releases

Git tags tutorial — lightweight vs annotated tags, creating, listing, sharing tags, semantic versioning, and release management with Git tags

Git Log — Powerful Commit History Filtering

Git log tutorial — filter, format, and search commit history with git log, view specific authors, dates, file changes, and branches

Git Merge Conflicts — How to Resolve Them

Git merge conflicts explained — understand why conflicts happen, resolve them in VS Code and command line, abort merges, and avoid conflicts with best practices

Git Ignore — The .gitignore File Explained

Gitignore explained — what the .gitignore file does, common patterns, global gitignore, ignoring tracked files, and templates for popular languages

Git Aliases — Speed Up Your Git Workflow

Git aliases tutorial — create custom Git commands, advanced aliases with arguments, productivity-boosting shortcuts, and sharing aliases with your team

Git Internals — How Git Really Works Under the Hood

Git internals explained — the object model, blobs, trees, commits, branches as pointers, the staging area, and how Git stores your data

Interactive Rebase — Squash, Edit, Reword & Reorder Commits

Git interactive rebase tutorial — squash commits, edit messages, reorder history, and clean up your branch before merging

Git Submodules — Managing External Dependencies Across Repos

Git submodules tutorial — add, update, clone, and manage submodules for shared libraries, themes, and cross-project dependencies

Resolving Merge Conflicts — A Step-by-Step Practical Guide

Git merge conflicts tutorial — understand conflict markers, resolve using command line and merge tools, and prevent conflicts with good workflows

Advanced Git Stash — Partial Stashes, Branches, and Recovery

Advanced Git stash tutorial — partial stashing, stash branching, interactive stashing, recovery from dropped stashes, and automation workflows

Git Tagging & Release Management — Semantic Versioning and Automation

Git tagging and release management tutorial — create annotated tags, semantic versioning, sign tags with GPG, automate releases with CI

Git for Beginners: Complete Guide to Version Control

Learn Git from scratch: what version control is, how Git tracks changes, and how to make your first commits, branches, and merges with practical examples.

What is Git? A Beginner's Guide to Distributed Version Control

Learn what Git is, how distributed version control works, and why Git has become the standard for software development teams worldwide.

How to Install and Configure Git: Complete Setup Guide

Learn how to install Git on Windows, macOS, and Linux, configure your name and email, set up SSH keys, and customize your Git environment.

Git Init: Creating Your First Repository

Learn git init, the first command every Git user needs. Create repositories, understand the .git folder, and make your first tracked commit.

Git Add and Commit: Staging and Saving Changes

Learn the Git staging area workflow: git add to stage changes, git commit to save them, and best practices for writing good commit messages.

Git Status and Log: Tracking Your Project History

Learn git status to see what's changed and git log to explore your project's complete history with formatting, filtering, and search options.

Git Diff: Comparing Changes Across Commits and Branches

Learn git diff to compare working directory changes, staged changes, and differences between commits and branches for code review.

Gitignore: Excluding Files from Version Control

Learn how .gitignore works: patterns for ignoring build artifacts, dependencies, secrets, and IDE files with practical examples for common project types.

Undoing Changes in Git: Reset, Revert, and Checkout

Learn how to undo changes in Git: git reset for local commits, git revert for shared history, and git checkout for discarding working directory changes.

Git Aliases: Speed Up Your Git Workflow

Learn to create Git aliases for common commands, configure shortcuts for complex operations, and boost your daily Git productivity.

Git Branching: Create, Merge, and Delete Branches

Learn Git branching: how branches work, creating and switching branches, merging changes, and keeping your repository organized.

Git Merge Strategies: Fast-Forward, Recursive, and Octopus Merges

Learn Git merge strategies: fast-forward merges for linear history, recursive merges for divergent branches, and when to use squash and octopus merges.

Resolving Merge Conflicts in Git: Complete Guide

Learn how to resolve Git merge conflicts: understanding conflict markers, using merge tools, aborting merges, and preventing conflicts with good workflow.

Git Rebase: Rewriting History for Cleaner Commits

Learn git rebase: how to rebase branches, when to rebase vs merge, interactive rebase for squashing commits, and the golden rule of rebasing.

Git Merge vs Rebase: Which One to Use and When

Learn the key differences between git merge and git rebase: when each is appropriate, the trade-offs, and how to choose the right strategy for your team.

Interactive Rebase: Squash, Edit, and Reorder Commits

Learn interactive rebase: squashing multiple commits into one, editing commit messages, reordering commits, and splitting commits for clean history.

Git Cherry-Pick: Selectively Applying Commits Between Branches

Learn git cherry-pick: how to apply specific commits from one branch to another for hotfixes, selective feature porting, and recovering lost changes.

Git Stash: Saving and Restoring Work in Progress

Learn git stash: saving uncommitted changes, applying stashes later, managing multiple stashes, and advanced stash operations like partial stashing.

Git Tags: Marking Releases and Important Commits

Learn Git tags: creating lightweight and annotated tags, tagging releases, pushing tags to remotes, and using tags for version management.

Git Worktrees: Working on Multiple Branches Simultaneously

Learn git worktrees: how to check out multiple branches in separate directories, work on parallel features, and avoid constant branch switching.

Git Remotes: Connecting Local Repos to GitHub and GitLab

Learn Git remotes: adding remote repositories, pushing and pulling, upstream tracking, and managing multiple remotes for collaboration.

Git Clone: Copying Remote Repositories Locally

Learn git clone: cloning HTTPS and SSH URLs, shallow clones, single-branch clones, and cloning specific tags or branches.

Git Push and Pull: Syncing Local and Remote Changes

Learn git push and git pull: pushing commits to remotes, pulling latest changes, handling divergent histories, and force pushing with caution.

Git Fetch: Downloading Changes Without Merging

Learn git fetch: how it differs from git pull, inspecting fetched branches, reviewing changes before merging, and keeping your local repo in sync.

GitHub Pull Requests: Complete Collaboration Guide

Learn GitHub pull requests: creating PRs, code review workflows, requesting reviewers, resolving feedback, and merging with best practices.

Git Forking Workflow: Contributing to Open Source Projects

Learn the Git forking workflow: forking repositories, keeping forks synced, submitting pull requests, and best practices for open source contributions.

Git Code Review Best Practices: PRs, Comments, and Approvals

Learn effective code review with Git: writing reviewable PRs, giving constructive feedback, using review tools, and establishing team review culture.

Git Hooks: Automating Tasks with Pre-Commit and Post-Receive Hooks

Learn Git hooks: client-side hooks for linting and testing before commits, server-side hooks for deployment, and managing hooks with tools like Husky.

Git Internals: How Git Works Under the Hood

Learn Git internals: objects (blobs, trees, commits), the .git directory structure, how branching really works, and the SHA-1 hash system.

Git Bisect: Finding the Commit That Introduced a Bug

Learn git bisect: binary search through commit history to find the exact commit that introduced a bug, with automated and manual bisecting.

Git Filter-Branch: Rewriting History at Scale

Learn git filter-branch: removing sensitive data, changing authors, splitting repositories, and rewriting large portions of Git history.

Git Submodules: Managing External Dependencies in Repos

Learn Git submodules: including one repository inside another, updating submodules, working with nested repos, and alternatives like subtrees.

Git Log Advanced: Formatting, Filtering, and Searching History

Learn advanced git log: custom formats, filtering by author/date/file, searching commit messages and diffs, and building custom history views.

Git Clean and Reset: Restoring Your Working Directory

Learn git clean for removing untracked files and git reset for unstaging, uncommitting, and discarding changes safely.

Git Reflog: Recovering Lost Commits and Branches

Learn git reflog: Git's safety net that tracks all HEAD movements, recovering deleted branches, undoing rebases, and restoring lost commits.

Advanced Git Merge: Strategies, Options, and Conflict Prevention

Learn advanced merge techniques: ours/theirs strategies, squash merging, merge options, and strategies for reducing merge conflicts in team projects.

Signing Git Commits with GPG: Verification and Best Practices

Learn how to sign Git commits and tags with GPG keys: generating keys, configuring Git, verifying signatures, and why signed commits build trust.

Git Workflow Strategies: Git Flow, GitHub Flow, and Trunk-Based Development

Learn Git workflow strategies: Git Flow for releases, GitHub Flow for continuous delivery, trunk-based development, and choosing the right model for your team.

Git Flow: Managing Releases with Develop, Feature, and Hotfix Branches

Learn the Git Flow branching model: develop and main branches, feature branches, release branches, hotfix branches, and when to use this workflow.

GitHub Flow: Simple Branching for Continuous Deployment

Learn GitHub Flow: a lightweight branching model with feature branches, pull requests, and continuous deployment -- perfect for teams shipping frequently.

Trunk-Based Development: Branching for CI/CD and DevOps

Learn trunk-based development: short-lived feature branches, frequent merges to main, feature flags, and how this workflow enables continuous integration.

Git Monorepo Strategy: Managing Large Codebases

Learn monorepo strategies with Git: managing large codebases, partial clones, sparse checkouts, and tools like Bazel and Nx for monorepo builds.

Common Git Problems and How to Fix Them

Learn solutions to common Git problems: detached HEAD, merge conflicts, accidental commits, wrong branches, and recovering from Git mistakes.

Fix Detached HEAD in Git: Create a Branch or Recover Commits

Learn what detached HEAD means in Git, how you got there, and how to either create a branch from it or recover lost commits safely.

How to Undo a Git Commit: Soft, Mixed, and Hard Reset

Learn how to undo Git commits: git reset --soft to keep changes, --mixed to unstage, --hard to discard, and git revert for shared branches.

How to Recover a Deleted Git Branch

Learn how to recover deleted Git branches using git reflog, finding the lost commit hash, and restoring the branch from any reference.

Fix Git Permission Denied (Public Key) Error

Learn how to fix Git SSH permission errors: generating SSH keys, adding them to GitHub/GitLab, testing connections, and troubleshooting common SSH issues.

GitHub Actions: Automating CI/CD with Git Workflows

Learn GitHub Actions for CI/CD: creating workflows triggered by Git events, running tests on push, deploying on merge, and automating releases.

GitLab CI/CD: Automate Testing and Deployment with .gitlab-ci.yml

Learn GitLab CI/CD: writing .gitlab-ci.yml pipelines, Git-triggered builds, Docker integration, multi-stage pipelines, and deployment automation.

Best Git GUI Tools: GitHub Desktop, Sourcetree, GitKraken, and VS Code

Compare the best Git GUI tools: GitHub Desktop for beginners, Sourcetree for power users, GitKraken for teams, and VS Code's built-in Git integration.

Using Git in VS Code: Source Control, Diff Editor, and Extensions

Learn using Git in VS Code: the source control panel, inline diff editing, Git Lens extension, staging UI, and resolving merge conflicts visually.

Git Hooks with Husky and lint-staged: Automate Code Quality

Learn automating Git hooks with Husky and lint-staged: running linters on staged files, preventing bad commits, and enforcing code quality standards.

How to Learn Git: A Complete Roadmap from Beginner to Advanced

A step-by-step roadmap to learn Git: essential commands, branching strategies, collaboration workflows, and resources to master version control.

Top Git Interview Questions and Answers for 2026

Prepare for Git interview questions: branching strategies, merge vs rebase, conflict resolution, Git internals, and common scenario-based questions with answers.

Git Best Practices: Commit Messages, Branching, and Workflow Tips

Learn Git best practices: writing good commit messages, naming branches consistently, managing remotes, and team workflows for production projects.

Git Names, Refs, and Refspec -- Understanding Git Reference Internals

Learn how Git uses refs, names, and refspec patterns to reference commits, branches, and tags for fetch and push mapping across remote repositories with ease.

Git Check-Ref-Format -- Validate Branch and Tag Name Conventions

Learn to validate branch and tag names against Git naming rules using git check-ref-format to prevent malformed reference errors in automation scripts in.

Git Check-Attr -- Inspect Gitattributes Attribute Assignment for Files

Learn to use git check-attr to query which gitattributes rules apply to specific files for debugging diff drivers and merge strategy assignments in projects.

Git Check-Ignore -- Debug Why Files Are Ignored by Gitignore Rules

Learn to use git check-ignore to determine why files are ignored by gitignore patterns, debug exclusion rules, and troubleshoot ignored paths in repos.

Git Check-Mailmap -- Map Multiple Author Identities to Canonical Names

Learn to consolidate author identities from multiple email addresses into consistent canonical names using Git mailmap files and check-mailmap for accurate.

Git Column -- Format Git Output into Aligned Columns for Readability

Learn to use git column for formatting command output into aligned multi-column displays to improve readability of branch lists, tags, and file listings.

Git Count-Objects -- Measure Repository Object Storage and Size

Learn to inspect repository object counts, disk usage, and pack file statistics using git count-objects for monitoring storage growth trends over time.

Three-Way Merge -- How Git Combines Divergent Branch Histories

Learn how Git three-way merge algorithm combines changes from two branches using their common ancestor commit to resolve conflicts without data loss in.

Fast-Forward Merge -- Linear History Integration Without Merge Commits

Learn how Git fast-forward merging applies commits linearly when branches have not diverged, keeping history clean without extra merge commit entries for.

Octopus Merge -- Merging Multiple Branches Simultaneously in Git

Learn to use Git octopus merge strategy for joining more than two branches at once, integrating multiple feature branches in a single merge operation for.

Recursive Merge Strategy -- Git's Default Three-Way Merge Algorithm

Learn how Git recursive merge strategy handles branch merging with rename detection, criss-cross history, and automatic conflict resolution patterns for.

Ours Merge Strategy -- Resolve Conflicts by Keeping Your Branch Changes

Learn to use Git ours merge strategy to automatically resolve conflicts by keeping the current branch version while recording the merge relationship for.

Subtree Merge Strategy -- Merge External Projects Into Subdirectories

Learn to use Git subtree merge strategy for merging an external project into a subdirectory of your repository while preserving full commit history for.

Merge ORT -- Git's Next-Generation Merge Engine for Faster Merges

Learn about Git ORT merge strategy that replaces the recursive backend with improved performance, better conflict messages, and reduced memory usage for.

Merge Recursive Backend -- Git's Classic Merge Algorithm Internals

Learn how Git recursive merge backend processes merges with virtual ancestor computation, rename detection, and advanced conflict handling logic internally.

Git Merge-Base -- Find the Common Ancestor Between Two Branches

Learn to use git merge-base for finding the best common ancestor commit between two branches used for three-way merges and patch application logic for.

Git Daemon -- Host a Git Repository Over Anonymous TCP Protocol

Learn to set up git daemon for serving repositories over Git protocol with anonymous read access, export controls, and connection management options for team.

Git HTTP Backend -- Smart HTTP Transport for Git Repositories

Learn to configure git-http-backend with Apache or Nginx for smart HTTP transport enabling authenticated push and fetch operations over secure HTTPS protocol.

Git Archive Servers -- Configure Archive Server for Snapshot Downloads

Learn to set up Git archive servers enabling clients to download compressed snapshots of repository trees without cloning the full commit history without.

Git Bundle Transfer -- Move Commits Between Repositories Without Network

Learn to use git bundle for packaging commits into binary files for offline transfer between repositories without requiring network connectivity or direct.

Git Clone Depth -- Shallow Clone with Specific History Truncation

Learn to use git clone with depth parameter for shallow clones that download only recent commit history, reducing clone time for large repos and CI pipelines.

Git Fetch Depth -- Unshallow and Deepen Shallow Repository History

Learn to use git fetch with depth options for deepening shallow clones, unshallowing repositories, and controlling exactly how much history to retrieve.

Git Blame Ignore Revs -- Skip Formatting Commits in Blame Annotations

Learn to use git blame with ignore-revs-file to skip reformatting and refactoring commits so blame annotations show only meaningful functional changes.

Git Log Follow -- Track File History Across Renames and Moves

Learn to use git log with follow option to track file history across renames and directory moves for accurate file ancestry tracking over time through.

Git Pickaxe -- Search Commit History for Code Changes by Content

Learn to use Git pickaxe search with git log -S and -G options to find commits that introduced or removed specific strings or code patterns in codebases.

Git Bisect Run -- Automate Bug Hunting with Test Scripts

Learn to automate bug hunting using git bisect run with test scripts for finding the first bad commit without manually testing each bisect step for regression.

Git Bisect Skip -- Handle Untestable Commits During Bisect Sessions

Learn to use git bisect skip to exclude untestable commits during bisect sessions due to build failures or unrelated breakage issues in history when builds.

Git Bisect Log -- Record and Replay Bisect Debugging Sessions

Learn to use git bisect log for recording bisect session history, replaying debugging workflows, and sharing regression findings with team members for audit.

Git Replay -- Reapply Commits Onto a New Base Without Branch Context

Learn to use git replay for applying a series of commits onto a different base commit without switching branches or maintaining rebase session state for safe.

Git Rerere -- Reuse Recorded Conflict Resolution Automatically

Learn to enable git rerere to record and replay conflict resolutions during rebases and merges, saving time on repeated merge conflict resolution scenarios.

Git Cherry -- Find Unmerged Commits Between Branches

Learn to use git cherry to identify commits that exist in one branch but not another, helping track missing changes during upstream synchronization between.

Git Name-Rev -- Convert Commit Hashes to Human-Readable References

Learn to use git name-rev to translate commit hashes into symbolic names like branch and tag references for more readable human-friendly Git output for script.

Git Commit-Tree -- Create Commits from Raw Tree Objects via Plumbing

Learn to use git commit-tree for creating commit objects from raw tree hashes, enabling low-level repository manipulation and scripted commit creation.

Git Write-Tree -- Record Current Index State as a Tree Object

Learn to use git write-tree for creating tree objects from the current staging area index, a fundamental plumbing command for Git internals operations.

Git Read-Tree -- Load Tree Objects Into the Staging Area Index

Learn to use git read-tree for reading tree objects into the staging area index, enabling low-level merge operations and custom index manipulation workflows.

Git Mktree -- Build a Tree Object from Raw Text Input Line Data

Learn to use git mktree for creating tree objects from ls-tree formatted text input, enabling programmatic tree construction in Git scripts and automation.

Git Mktag -- Create a Tag Object from Raw Tag Data Input

Learn to use git mktag for creating annotated tag objects from raw input data, enabling automated tag creation and verification in scripting workflows.

Git Difftool Helper -- Custom Diff Tool Integration and Configuration

Learn to configure git difftool helper scripts for custom external diff tools supporting side-by-side comparisons and advanced diff visualization features.

Git Var -- Display Git Variables and Configuration Placeholders

Learn to use git var for displaying Git configuration variables like user identity, editor, and pager settings with expanded placeholder values for debugging.

Git Credential Cache -- Store Credentials Temporarily in Memory

Learn to configure git credential cache helper for storing authentication credentials in memory with timeout to avoid repeated password prompts during sessions.

Git Credential Store -- Persist Credentials to Disk for Automation

Learn to use git credential store helper for saving credentials to plain-text disk storage for automated scripts and CI pipeline authentication flows.

Git Credential Manager -- Cross-Platform Authentication for Remote Hosts

Learn to use Git Credential Manager for seamless authentication across GitHub, GitLab, Bitbucket, and Azure with OAuth and device flow support for teams.

Git Credential Helper Selector -- Choose Auth Strategy Per Remote

Learn to configure credential helper selectors in Git for using different authentication strategies depending on remote host or repository URL patterns.

GitHub CLI Advanced -- Automate Pull Requests, Issues, and Actions

Learn advanced GitHub CLI usage for automating pull request creation, issue management, release workflows, and Actions monitoring from terminal for teams.

Git Annex -- Manage Large Files with Git Without Storing in Repository

Learn to use git-annex for managing large files outside Git object store while maintaining version control through symlinks and external storage backends.

Git Fat -- Large File Storage for Git Without External Dependencies

Learn to use git-fat for managing binary files in Git repositories with external object storage and transparent checkout and push workflows for teams.

Git LFS Migrate -- Convert Repository History to Use Git LFS

Learn to use git lfs migrate for converting existing repository history to Git LFS, moving large files from Git objects to external LFS storage backends.

Git Filter-Repo Migrate -- Rewrite Repository History for Clean Migration

Learn to use git filter-repo for bulk history rewriting including removing sensitive data, splitting repositories, and migrating large codebases safely.

Git Reflog Expire -- Manage Reflog Entry Retention and Cleanup Policy

Learn to configure git reflog expiration policies that control how long reference history entries are retained and when stale entries are pruned automatically.

Git Send-Email -- Submit Patches to Open Source Projects via Email

Learn to use git send-email for submitting formatted patches to email-based open source projects following maintainer patch contribution guidelines for.

Git Imap-Send -- Push Commits to IMAP Folders for Patch Review

Learn to use git imap-send for uploading patch series to IMAP folders for email-based code review workflows in open source development projects for patch.

Git Format-Patch -- Prepare Commit Series for Email Submission

Learn to use git format-patch for generating mbox-compatible patch files from commits and preparing them for email-based review submission workflows for open.

Git Range-Diff -- Compare Two Patch Series Side by Side

Learn to use git range-diff for comparing two commit ranges side by side to review rebase results, versioned patches, and cherry-pick accuracy for QA.

Git Describe -- Generate Human-Readable Names for Any Commit

Learn to use git describe for producing readable version identifiers from annotated tags, enabling build systems to embed version strings automatically.

Git Worktree Add and Lock -- Manage Parallel Development Environments

Learn to use git worktree add with locking for multiple parallel development environments, preventing accidental pruning of active development worktrees.