Hey everyone!
In this blog, I will explain how Git works internally in a very simple way. We will understand what the .git folder is, what Git objects are, and how Git tracks changes when we use commands like git add and git commit. This blog is meant to help beginners understand Git conceptually instead of memorizing commands.

What is the .git Folder?

When we initialize a project using the git init command, Git creates a hidden folder called .git inside our project directory.

The .git folder is the heart of Git.
It stores all the information related to:

• commits

• branches

• file changes

• project history

Without the .git folder, Git cannot track anything.
That is why if we delete the .git folder, the project is no longer a Git repository.

Structure of the .git Folder

Inside the .git folder, Git stores:

• configuration files

• references to branches

• objects that store file data and commits

Among these, the objects folder is the most important because Git stores everything as objects.

Git Objects: Blob, Tree, and Commit

Git internally stores data in the form of objects. There are mainly three important Git objects:

1. Blob (Binary Large Object)

A blob stores the content of a file.
It does not store the file name, only the data inside the file.

If two files have the same content, Git stores only one blob for both, which helps save space.

2. Tree

A tree represents a directory structure.
It stores:

• file names

• folder names

• references to blobs and other trees

In simple words:

• Blob → file content

• Tree → folder structure

3. Commit

A commit object stores:

• reference to a tree

• commit message

• author details

• reference to the previous commit

Each commit represents a snapshot of the project at a specific point in time.

How Git Tracks Changes

Git does not track files like normal systems.
Instead, Git tracks snapshots of the project.

When a file changes:

• Git creates a new blob for the updated content

• The tree is updated

• A new commit points to this new tree

This is how Git keeps the complete history of changes.

What Happens Internally During git add

When we run:

→ git add <filename>

Internally:

• Git takes the file content

• Creates a blob object

• Stores it inside the .git/objects directory

• Adds the reference to the staging area

At this stage, the changes are not committed, only prepared.

What Happens Internally During git commit

When we run:

→ git commit -m "message"

Internally:

• Git creates a tree object from the staged files

• Git creates a commit object

• The commit points to the tree

• Git updates the current branch (HEAD) to this commit

Now the changes are permanently saved in Git history.

How Git Uses Hashes

Git uses hashes (HA-1) to identify objects.
Each blob, tree, and commit has a unique hash.

If even a small change happens in a file, the hash changes completely.

Finally

We know how Git works internally which helps us build a strong mental model of Git. We now know what Git does behind the scenes when we add or commit files.