Git Notes
HubBenefits of Git and GitHub - Why They MatterGit vs GitHubVersion Control SystemWhat Is GitWhat Is GitHubConfigure Git - User Identity and SettingsCreate GitHub Account - Sign Up GuideFirst Git Repository - Getting StartedInstall Git on Linux - Complete Setup GuideInstall Git on macOS - Installation GuideInstall Git on Windows - Step-by-Step GuideGit Add - Stage ChangesGit Clone - Copy Remote Repositories LocallyGit Commit - Save ChangesGit Diff - Compare Changes in Your RepositoryGit Ignore - Exclude Files from Version ControlGit Init - Initialize RepositoryGit Log - View Commit HistoryGit Status - Check Repository StateGit Fetch - Download Remote Changes Without MergingGit Pull - Fetch and Merge Remote ChangesGit Push - Upload Local Commits to Remote RepositoryGit Remote - Manage Remote Repository ConnectionsLocal Repository - Understanding Your Git Working EnvironmentRemote Repository - Collaborate Through Shared RepositoriesSync Local and Remote - Keep Repositories in HarmonyAmend Commit - Fix Last CommitDelete Branch - Clean Up BranchesGit Reset - Move HEAD and Undo CommitsGit Restore - Discard ChangesGit Revert - Safely Undo ChangesRecover Lost Commits - Reflog GuideFork RepositoryGitHub PagesGitHub Profile SetupGitHub RepositoriesGitHub Stars and WatchersRepository SettingsCode ReviewsGit CloneGit FetchGit PullGit PushGitHub IssuesLabels and MilestonesOpen Source ContributionsGitHub Project BoardsPull Requests - Propose and Review Code ChangesTeam Collaboration with Git and GitHubAutomated Testing with GitHub ActionsCI/CD with GitHub ActionsDeployment Automation with GitHub ActionsIntroduction to GitHub ActionsGitHub Actions RunnersGitHub Actions WorkflowsEnterprise Git Workflows - Scale Git for Large OrganizationsFeature Branch Workflow - Isolate Development WorkGitFlow Workflow - Structured Release ManagementMonorepo Workflow - Manage Multiple Projects in One RepositoryTrunk-Based Development - Ship Code Fast and SafelyDeployment WorkflowsGitHub Pages DeploymentNetlify Deployment from GitHubRender Deployment from GitHubVercel Deployment from GitHubBranch Protection Rules - Secure Your Git BranchesPersonal Access Tokens - Authenticate with GitHubRepository Security Best PracticesSecret Scanning - Detect Leaked Credentials in CodeSigned Commits - Verify Commit Authenticity with GPGSSH Keys - Secure Git Authentication Without PasswordsGit Bisect - Find Bugs with Binary SearchGit Cherry-Pick - Apply Specific Commits to Any BranchGit Hooks - Automate Workflows with Git EventsGit Internals - Understanding How Git Works Under the HoodGit Stash - Temporarily Save Uncommitted ChangesGit Submodules - Manage External Dependencies as Git ReposGit Tag - Mark Important Points in HistoryGit Worktrees - Work on Multiple Branches SimultaneouslyCollaborative Web App ProjectComplete Team Workflow ProjectGitHub Actions Project - Build a CI/CD PipelineOpen Source Project Contribution - Guided ExercisePortfolio Project with Git - Showcase Your SkillsGit Command CheatsheetGit Interview Questions - Comprehensive Preparation GuideGitHub Interview QuestionsScenario-Based Git Interview QuestionsGit Troubleshooting GuideGit Best Practices - Professional Development HabitsCommon Git Errors and Fixes - Quick SolutionsGit Command Reference - Complete Command GuideLearning Resources - Continue Your Git & GitHub EducationBranch Strategies - Choosing the Right Git Branching ModelCreate Branch in Git - Start New Development LinesFast-Forward Merge in Git - Clean Linear HistoryGit BranchGit CheckoutGit MergeGit RebaseMerge Branches in Git - Combine Development WorkMerge Conflicts - Resolve Git Conflicts Like a ProSwitch Branch in Git - Navigate Between Branches
Deep dive into Git internals including objects (blobs, trees, commits), the SHA-1 hash system, packfiles, refs, and how Git stores data as a content-addressable filesystem.
Understanding Git internals helps you debug issues, recover lost data, and use Git more effectively. At its core, Git is a content-addressable filesystem with a version control system built on top.
Git Object Model
Git stores everything as objects in .git/objects/. There are four types:
┌─────────────────────────────────────────────────────────────┐
│ Git Object Types │
├─────────────────────────────────────────────────────────────┤
│ │
│ BLOB ─── Raw file content (no filename, no metadata) │
│ TREE ─── Directory listing (filenames → blob/tree refs) │
│ COMMIT ─ Snapshot pointer + metadata (author, message) │
│ TAG ──── Named pointer to a commit (annotated tags) │
│ │
└─────────────────────────────────────────────────────────────┘
How Objects Relate
| commit | a1b2c3d |
| ├── tree | f4e5d6c (root directory) |
| │ ├── blob: 1a2b3c4 | README.md |
| │ ├── blob: 5e6f7g8 | index.js |
| │ └── tree: 9h0i1j2 | src/ |
| │ ├── blob: 3k4l5m6 | src/app.js |
| │ └── blob: 7n8o9p0 | src/utils.js |
| ├── parent | previous-commit-hash |
| ├── author | Jane Doe <jane@example.com> |
| ├── committer | Jane Doe <jane@example.com> |
| └── message | "Add utility functions" |
Exploring Git Objects
View Object Type
bash example
git cat-file -t HEADOutput
commit
View Object Content
bash example
git cat-file -p HEADOutput
tree f4e5d6c7b8a9012345678901234567890abcdef parent a1b2c3d4e5f6789012345678901234567890abcd author Jane Doe <jane@example.com> 1705312200 -0500 committer Jane Doe <jane@example.com> 1705312200 -0500 Add utility functions
View a Tree Object
bash example
git cat-file -p f4e5d6cOutput
100644 blob 1a2b3c4d5e6f7890123456789012345678901234 README.md 100644 blob 5e6f7g8h9i0j1234567890123456789012345678 index.js 040000 tree 9h0i1j2k3l4m5678901234567890123456789012 src
View a Blob Object
bash example
git cat-file -p 1a2b3c4Output
# My Project This is a sample project.
SHA-1 Hashing
Every object is identified by a SHA-1 hash of its content:
bash example
# Calculate hash without storing
echo "Hello World" | git hash-object --stdinOutput
557db03de997c86a4a028e1ebd3a1ceb225be238
bash example
# Store an object in the database
echo "Hello World" | git hash-object -w --stdinThe same content always produces the same hash — this is content-addressable storage.
The .git Directory Structure
bash example
ls -la .git/Output
.git/ ├── HEAD # Points to current branch ├── config # Repository configuration ├── description # Used by GitWeb ├── hooks/ # Hook scripts ├── index # Staging area (binary) ├── info/ # Additional info (exclude patterns) ├── objects/ # All objects (blobs, trees, commits, tags) │ ├── 1a/ # First 2 chars of SHA │ │ └── 2b3c4d... # Remaining chars │ ├── info/ │ └── pack/ # Packed objects for efficiency ├── refs/ # Branch and tag pointers │ ├── heads/ # Local branches │ │ └── main # Contains SHA of latest commit │ ├── remotes/ # Remote tracking branches │ │ └── origin/ │ └── tags/ # Tag references └── logs/ # Reflog data
How Commits Chain Together
bash example
git cat-file -p HEADOutput
tree abc123... parent def456... ← Points to previous commit author ... committer ... Latest commit message
bash example
git cat-file -p def456Output
tree ghi789... parent jkl012... ← Points to even earlier commit author ... committer ... Previous commit message
This chain of parent references forms the commit history.
Refs (References)
Refs are human-readable names that point to commit SHAs:
bash example
# What does HEAD point to?
cat .git/HEADOutput
ref: refs/heads/main
bash example
# What commit does main point to?
cat .git/refs/heads/mainOutput
a1b2c3d4e5f6789012345678901234567890abcdef
bash example
# Branches are just files containing a commit SHA
ls .git/refs/heads/Output
develop feature-auth main
Packfiles
Git periodically packs loose objects into packfiles for efficiency:
bash example
# Trigger packing manually
git gc
# View packed objects
git verify-pack -v .git/objects/pack/pack-*.idx | head -20Output
a1b2c3d4... commit 234 158 12 b2c3d4e5... tree 98 89 170 c3d4e5f6... blob 2048 1024 259 d4e5f6g7... blob 156 128 1283 1 c3d4e5f6... (delta)
Packfiles use delta compression — storing differences between similar objects.
Low-Level (Plumbing) Commands
bash example
# Create a blob object
echo "file content" | git hash-object -w --stdin
# Create a tree object
git mktree < tree-entries.txt
# Create a commit object
git commit-tree <tree-sha> -p <parent-sha> -m "message"
# Update a reference
git update-ref refs/heads/main <commit-sha>Building a Commit Manually
bash example
# 1. Create a blob
BLOB=$(echo "Hello Git Internals" | git hash-object -w --stdin)
echo "Blob SHA: $BLOB"
# 2. Add blob to a tree
TREE=$(printf "100644 blob $BLOB\thello.txt" | git mktree)
echo "Tree SHA: $TREE"
# 3. Create a commit pointing to the tree
COMMIT=$(git commit-tree $TREE -m "Manual commit")
echo "Commit SHA: $COMMIT"
# 4. Update main to point to new commit
git update-ref refs/heads/main $COMMITThe Index (Staging Area)
The index is a binary file (.git/index) that represents the next commit:
bash example
# View index contents
git ls-files --stageOutput
100644 1a2b3c4d5e6f7890123456789012345678901234 0 README.md 100644 5e6f7g8h9i0j1234567890123456789012345678 0 index.js 100644 3k4l5m6n7o8p9012345678901234567890123456 0 src/app.js
The number after the SHA (0) is the stage slot — non-zero during merge conflicts.
Interview Questions
- What are the four types of Git objects?
Blob (file content), Tree (directory listing mapping names to blobs/trees), Commit (pointer to tree + parent + metadata), and Tag (named pointer to a commit with annotation).
- How does Git store file content?
Git hashes file content with SHA-1 and stores it as a blob object. The filename is stored separately in a tree object. Identical content produces the same blob regardless of filename.
- What is the difference between plumbing and porcelain commands?
Porcelain commands are user-friendly (commit, push, pull). Plumbing commands are low-level building blocks (hash-object, cat-file, update-ref). Porcelain is built on top of plumbing.
- How are branches implemented internally?
A branch is simply a file in .git/refs/heads/ containing the SHA-1 hash of the latest commit. Creating a branch just creates a 41-byte file.
- What is delta compression in packfiles?
When Git packs objects, it stores similar objects as deltas (differences) rather than full copies. This dramatically reduces storage by referencing a base object and storing only the changes.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Git Internals - Understanding How Git Works Under the Hood.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Git & GitHub topic.
Search Terms
git-github, git & github, git, github, advanced, internals, git internals - understanding how git works under the hood
Related Git & GitHub Topics
Continue learning this concept
Advanced GitGit Bisect - Find Bugs with Binary SearchLearn how to use git bisect to efficiently find the commit that introduced a bug using binary search. Master automated bisect with scripts and practical debugging workflows.Advanced GitGit Cherry-Pick - Apply Specific Commits to Any BranchLearn how to use git cherry-pick to apply individual commits from one branch to another. Master cherry-pick options, conflict resolution, and best practices.Advanced GitGit Hooks - Automate Workflows with Git EventsLearn to use Git hooks for automating code quality checks, commit message validation, pre-push testing, and deployment triggers. Covers client-side and server-side hooks.Advanced GitGit Stash - Temporarily Save Uncommitted ChangesMaster git stash to save work-in-progress changes without committing. Learn stash operations, named stashes, partial stashing, and workflow patterns.Advanced GitGit Submodules - Manage External Dependencies as Git ReposLearn how to use Git submodules to include external repositories within your project. Cover adding, updating, cloning with submodules, and alternatives.Advanced GitGit Tag - Mark Important Points in HistoryLearn how to create, list, and manage Git tags for releases and milestones. Understand lightweight vs annotated tags, semantic versioning, and tag workflows.