# Inside Git

If you clicked this blog, AI is not gonna replace you. You want to wander in depth. Want to know when you run `git add` or `git commit` ? Let’s peek behind the curtain and explore the secret world inside .git directory.

## What is .git, Anyway?

When you execute `git init` in your project initially, Git creates a hidden `.git` directory inside the working directory.

Git is like a super-smart filing cabinet that remembers every version of every file you have ever committed. And the `.git` folder is where that filing cabinet lives.

Now `.git` is, like Git’s brain, almost all the git’s shenanigans happens here. Git operates as a content-addressable filesystem with a version control interface built on top of it.

## Inside .git

After initializing a new repository, Git creates several key components:

* **HEAD : A reference to the current branch, like a bookmark.**
    
* **objects/ : The directory, which is the actual database where Git stores all the files upon commits.**
    
* **refs/ : Stores pointers to commits e.g. branches, tags etc.**
    
* **config : Configuration directory containing Git settings specific to your project.**
    
* **index : The staging area, where tracked files are stored. More of this is discussed later.**
    
* **hooks/ : Scripts that run automatically on Git events.**
    

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768661621308/406a319e-1f95-4d65-a8f6-c5861834f3d2.png align="left")

## Three Musketeers: Blob, Tree and Commit

Git uses three types of objects to track your project.

1. **Blob** : A blob stores the content of your files. Not filenames, not directory structures; just pure content. Think of blobs as actual “stuff”.
    
2. **Tree** : Trees organize blobs by storing filenames and directory structures. A tree is like a directory that points to blobs (files) and other trees (sub-directories).
    
3. **Commit** : A commit object references a tree and includes metadata like author, timestamp and parent commits. It is the snapshot of your entire project at a specific point in time.
    

## What Really happens during `git add` and `git commit` ?

Let me dissect what happens to these commands you use everyday.

### Running `git add`

1. Git calculates a SHA-1 hash of your file’s content
    
2. The file is compressed and stored as a blob in the `objects` directory
    
3. Index (Staging area) is updated with a reference to this blob
    

Git stores each object in a sub-directory named with the first two characters of its hash, with the remaining 38 characters as the filename.

### Running `git commit`

1. Creates a tree object from the staging area
    
2. It creates a commit object pointing to that tree
    
3. The commit includes your message, author info and timestamp
    
4. Current branch pointer moves to this new commit
    

Essentially, `git add` stores blobs for changed files and updates the index, while `git commit` creates tree and commit objects.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1768661693668/5acfe995-d5f3-436c-b44b-b1926efbdad0.png align="left")

## The Secret Sauce: SHA-1 Hashes

Git uses SHA-1 hashes as unique identifiers for all objects. Every file, every commit gets a 40-character fingerprint like `b69cf9v9f8d9xcv9fdd9v8bf99vfuhrixo76f908`.

Why this matters?

Integrity. Even one-bit change changes the hash completely.

Identical files gets the same hash, enforcing deduplication.

git can quickly check if the content exists by looking up its hash.

## Summary of it

In Git, everything is content-addressed, where files are stored by their content’s hash.

Each commit is a snapshot, not only diffs.

Branches just point to commits, making them lightweight and fast.

Git is basically a Directed Acyclic Graph (DAG), commits link to their parent commits.

## Conclusion

Git is a content-addressable filesystem where blobs store file contents, trees store directory structures, and commits tie everything together with metadata. SHA-1 hashes ensure integrity, and the `.git` directory is where all this magic lives.