Git Internals: How Git Really Works — Blob, Tree, Commit, and DAG Deep Dive

# Create a blob from content
echo "Hello, Git!" | git hash-object --stdin
# Output: 0907f4a3c4740fa3a5c919cb4447fdb1f1a66aec

# Inspect blob content
git cat-file -p 0907f4a
# Output: Hello, Git!

# Check blob type
git cat-file -t 0907f4a
# Output: blob

# Inspect the tree of the latest commit
git cat-file -p HEAD^{tree}
# Output:
# 100644 blob a1b2c3d... README.md
# 100644 blob d4e5f6a... package.json
# 040000 tree b7c8d9e... src

Tree (root)
├── blob: README.md (100644)
├── blob: package.json (100644)
└── tree: src/
    ├── blob: index.ts (100644)
    └── blob: utils.ts (100644)

git cat-file -p HEAD
# Output:
# tree a1b2c3d4e5f6...
# parent 9f8e7d6c5b4a...
# author Kim <kim@example.com> 1711234567 +0900
# committer Kim <kim@example.com> 1711234567 +0900
#
# feat: add user authentication

# Create annotated tag
git tag -a v1.0.0 -m "Release version 1.0.0"

# Inspect tag object
git cat-file -p v1.0.0
# Output:
# object d4e5f6a7b8c9...
# type commit
# tag v1.0.0
# tagger Kim <kim@example.com> 1711234567 +0900
#
# Release version 1.0.0

Tag ──▶ Commit ──▶ Tree ──▶ Blob
           │         │
           ▼         ▼
        Commit     Tree ──▶ Blob
        (parent)

# What Git does internally
content="Hello, Git!"
header="blob ${#content}\0"
echo -en "${header}${content}" | sha1sum
# Result: 0907f4a3c4740fa3a5c919cb4447fdb1f1a66aec

blob 11\0Hello, Git!
└─┬─┘└┬┘└┬┘└────┬────┘
 type size null actual content

# Create a SHA-256 repository (Git 2.29+)
git init --object-format=sha256

# Check current repository hash algorithm
git rev-parse --show-object-format

.git/
├── HEAD              # Reference to currently checked-out branch
├── config            # Repository-specific settings
├── description       # For GitWeb (rarely used)
├── hooks/            # Client/server hook scripts
│   ├── pre-commit.sample
│   ├── commit-msg.sample
│   └── ...
├── info/
│   └── exclude       # Local version of .gitignore
├── objects/          # All Git objects
│   ├── 09/
│   │   └── 07f4a3c4740fa3a5c919cb4447fdb1f1a66aec
│   ├── info/
│   └── pack/         # Pack files
├── refs/             # Branch and tag references
│   ├── heads/        # Local branches
│   │   └── main
│   ├── remotes/      # Remote branches
│   │   └── origin/
│   └── tags/         # Tags
└── index             # Staging area (binary)

# HEAD points to the current branch
cat .git/HEAD
# ref: refs/heads/main

# In detached HEAD state, it points directly to a commit
git checkout a1b2c3d
cat .git/HEAD
# a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0

# A branch is simply a file containing a commit hash
cat .git/refs/heads/main
# d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3

# You can even create branches manually!
echo "d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3" > .git/refs/heads/my-branch

# Hash: 0907f4a3c4740fa3a5c919cb4447fdb1f1a66aec
# Location: .git/objects/09/07f4a3c4740fa3a5c919cb4447fdb1f1a66aec

# Objects are compressed with zlib
python3 -c "
import zlib
with open('.git/objects/09/07f4a3c4740fa3a5c919cb4447fdb1f1a66aec', 'rb') as f:
    print(zlib.decompress(f.read()))
"

# Check staging area contents
git ls-files --stage
# 100644 a1b2c3d4... 0    README.md
# 100644 d4e5f6a7... 0    src/index.ts

# Index is a binary file starting with "DIRC" signature
hexdump -C .git/index | head -3

    A ◀── B ◀── C ◀── D  (main)
                 ▲
                 └── E ◀── F  (feature)

# Visualize the graph
git log --oneline --graph --all

# Example output:
# *   f1a2b3c (HEAD -> main) Merge branch 'feature'
# |\
# | * d4e5f6a (feature) feat: add search
# | * a7b8c9d feat: add filter
# |/
# * 1e2f3a4 initial commit

# First parent only (useful for merge commits)
git log --first-parent --oneline

# Access parent commits
git cat-file -p HEAD^1   # First parent
git cat-file -p HEAD^2   # Second parent (merge commits)
git cat-file -p HEAD~3   # 3 ancestors up

HEAD~1 = HEAD^  = first parent
HEAD~2 = HEAD^^ = first parent's first parent
HEAD^2           = second parent (only on merge commits)

# Creating a branch = creating a file
git branch feature
# This is essentially:
# echo $(git rev-parse HEAD) > .git/refs/heads/feature

# Switching branches = modifying the HEAD file
git checkout feature
# This essentially:
# 1. Writes "ref: refs/heads/feature" to .git/HEAD
# 2. Updates working tree to match the commit's tree
# 3. Updates index to match the tree

.git/refs/heads/
├── main     → d4e5f6a (commit)
├── feature  → a7b8c9d (commit)
└── hotfix   → 1e2f3a4 (commit)

.git/HEAD → ref: refs/heads/main

Normal state:
HEAD → refs/heads/main → commit d4e5f6a

Detached HEAD state:
HEAD → commit a7b8c9d (directly points to a commit)

# Save work from detached HEAD state
git checkout -b recovery-branch

# Lightweight tag: simple reference (just a commit hash in refs/tags/)
git tag v1.0.0-rc1

# Annotated tag: creates a separate tag object
git tag -a v1.0.0 -m "Release 1.0.0"

# See the difference
git cat-file -t v1.0.0-rc1  # commit
git cat-file -t v1.0.0      # tag

Before:
A ◀── B ◀── C (main)
              ◀── D ◀── E (feature)

After (fast-forward):
A ◀── B ◀── C ◀── D ◀── E (main, feature)

# Fast-forward merge
git checkout main
git merge feature
# "Fast-forward" message displayed

# Force a merge commit instead of fast-forward
git merge --no-ff feature

Before:
A ◀── B ◀── C ◀── F (main)
       ◀── D ◀── E (feature)

After (3-way merge):
A ◀── B ◀── C ◀── F ◀── G (main) [merge commit]
       ◀── D ◀── E ──────┘
              (feature)

# Find merge base
git merge-base main feature
# Output: B's SHA-1 hash

# Compare the 3 trees for merge
git diff $(git merge-base main feature) main    # base vs main
git diff $(git merge-base main feature) feature  # base vs feature

    A ◀── B ◀── E (main)
    ▲      ◀── F (feature)
    └── C ◀── D
    (cross-merge history)

# Specify merge strategy
git merge -s recursive feature
git merge -s ort feature        # Git 2.34+ default (Ostensibly Recursive's Twin)

git merge feature1 feature2 feature3

    A ◀── B (main)
    ◀── C (feature1)
    ◀── D (feature2)
    ◀── E (feature3)

    →

    A ◀── B ◀── M (main) [3 parents]
    ◀── C ──────┘
    ◀── D ──────┘
    ◀── E ──────┘

Before:
A ◀── B ◀── C (main)
       ◀── D ◀── E (feature)

After rebase (git checkout feature && git rebase main):
A ◀── B ◀── C (main)
              ◀── D' ◀── E' (feature)

git checkout feature
git rebase main

# Check temporary files during rebase
ls .git/rebase-merge/
# done        # completed commits
# git-rebase-todo  # remaining commits
# head-name   # original branch name
# onto        # rebase target commit

git rebase -i HEAD~3

# Contents of .git/rebase-merge/git-rebase-todo:
pick a1b2c3d feat: add login
pick d4e5f6a feat: add signup
pick 7b8c9d0 fix: typo in login

# Commands:
# pick   = use commit
# reword = change message
# edit   = modify commit then continue
# squash = merge with previous (combine messages)
# fixup  = merge with previous (discard message)
# drop   = remove commit

git cherry-pick d4e5f6a

Before:
A ◀── B ◀── C (main)
       ◀── D ◀── E (feature)

git checkout main && git cherry-pick E:
A ◀── B ◀── C ◀── E' (main) [only E's changes copied]
       ◀── D ◀── E (feature)

git revert d4e5f6a

Before:
A ◀── B ◀── C (main)

git revert B:
A ◀── B ◀── C ◀── B' (main) [new commit undoing B's changes]

# When reverting a merge commit, specify which parent to use as reference
git revert -m 1 MERGE_COMMIT_HASH
# -m 1: revert based on first parent (main)
# -m 2: revert based on second parent (feature)

# View reflog
git reflog
# d4e5f6a HEAD@{0}: commit: feat: add auth
# a1b2c3d HEAD@{1}: checkout: moving from feature to main
# 7b8c9d0 HEAD@{2}: commit: feat: add search
# 1e2f3a4 HEAD@{3}: rebase finished
# ...

# Reflog for a specific branch
git reflog show feature

# Mistake!
git reset --hard HEAD~3

# Find previous state in reflog
git reflog
# a1b2c3d HEAD@{1}: previous state

# Recover
git reset --hard a1b2c3d

# Pre-rebase state is in the reflog
git reflog
# ... HEAD@{5}: rebase (start): checkout main

# Recover to pre-rebase state
git reset --hard HEAD@{5}

# Delete branch
git branch -D feature

# Find the branch's last commit in reflog
git reflog | grep feature

# Recreate branch
git branch feature a1b2c3d

# Default expiry periods
# Reachable entries: 90 days
# Unreachable entries: 30 days

# Configure expiry
git config gc.reflogExpire "180 days"
git config gc.reflogExpireUnreachable "60 days"

# Manual expiry
git reflog expire --expire=now --all

# Count loose objects
find .git/objects -type f | grep -v 'pack\|info' | wc -l

# View pack files
ls .git/objects/pack/
# pack-a1b2c3d4e5f6.idx   (index)
# pack-a1b2c3d4e5f6.pack  (data)

# Inspect pack file contents
git verify-pack -v .git/objects/pack/pack-*.idx
# SHA-1 type size size-in-pack offset depth base-SHA-1
# a1b2c3d blob 10240 3521 12 0
# d4e5f6a blob 10245 45   1200 1 a1b2c3d  # delta!

# Run garbage collection
git gc

# What it does:
# 1. Compresses loose objects into pack files
# 2. Removes unreachable objects
# 3. Cleans up reflog
# 4. Compresses refs into packed-refs

# More aggressive GC
git gc --aggressive --prune=now

# View GC statistics
git count-objects -v
# count: 0        (loose objects)
# size: 0         (loose objects size, KB)
# in-pack: 1234   (packed objects)
# packs: 1        (number of pack files)
# size-pack: 5678 (pack file size, KB)
# prune-packable: 0
# garbage: 0

# Find the largest files in the repository
git rev-list --objects --all | \
  git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | \
  sed -n 's/^blob //p' | sort -rnk2 | head -10

# Remove large files with BFG Repo-Cleaner
bfg --strip-blobs-bigger-than 100M

# git filter-repo (recommended)
git filter-repo --strip-blobs-bigger-than 100M

git add, git commit, git push, git pull
git branch, git checkout, git merge, git rebase
git log, git diff, git status
git stash, git tag, git remote

# Object manipulation
git hash-object    # Compute and store object hash
git cat-file       # Inspect object content/type/size
git write-tree     # Create tree object from index
git commit-tree    # Create commit object from tree
git update-ref     # Update references

# Index manipulation
git update-index   # Add files to index
git ls-files       # List index contents
git read-tree      # Read tree into index

# Transfer
git pack-objects   # Create pack files
git unpack-objects # Unpack pack files
git send-pack      # Send objects
git receive-pack   # Receive objects

# 1. Create blob
echo "Hello World" | git hash-object -w --stdin
# a1b2c3d...

# 2. Add to index
git update-index --add --cacheinfo 100644 a1b2c3d hello.txt

# 3. Create tree
git write-tree
# d4e5f6a...

# 4. Create commit
echo "first commit" | git commit-tree d4e5f6a
# 7b8c9d0...

# 5. Point branch to this commit
git update-ref refs/heads/main 7b8c9d0