Inside Git: How It Works and the Role of the .git Folder

Inside Git: How It Works and the Role of the .git Folder


When you start using Git, most of the time you only run commands like git add, git commit, or git push. Everything feels a bit magical. You type a command, and Git somehow remembers your changes forever.

But have you ever wondered what is actually happening behind the scenes?

In this blog, we’ll look inside Git, understand how it works internally, and learn why the .git folder is the most important part of any Git repository.


What Happens When You Run git init?

When you run the command:

git init


Git creates a hidden folder called .git inside your project directory.

This .git folder is the heart of Git.  

Without it, your project is just a normal folder.  

With it, your project becomes a Git repository.

Everything Git knows about your project is stored inside this folder.


Why the .git Folder Is So Important

The .git folder contains:

- Your complete project history

- All commits you have ever made

- Branch information

- Configuration settings

- References to different versions of your code


If you delete the .git folder, Git will forget everything about your project history.

That’s why you should never manually edit or delete files inside the .git folder unless you really know what you’re doing.


Understanding How Git Tracks Changes

Git does not track files the way many beginners think.

Git does NOT:

- Track changes line by line

- Automatically save every file


Instead, Git works in **three main stages**.


The Three States of a File in Git

Every file in Git lives in one of these three states:

1. Working Directory  

2. Staging Area  

3. Repository (Committed)


1. Working Directory

This is your normal project folder where you write and edit code.

When you change a file, Git knows that the file has been modified, but it does not save the change automatically.

At this stage, the file is only changed on your system.


2. Staging Area

When you run:

git add filename


You move the file to the staging area.

The staging area is like a preview area.  


You are telling Git:

“Yes, I want to save these specific changes.”

This allows you to control exactly what goes into the next commit.


3. Repository (Commit)

When you run:

git commit -m "message"


Git takes everything from the staging area and permanently saves it in the repository.

This saved version is called a commit. Once committed, your changes become part of Git history.


What Is Actually Stored Inside the .git Folder?

Let’s break down some important parts of the .git folder (conceptually).


Objects

Git stores everything as objects.


There are mainly three types:

- Blob objects (file content)

- Tree objects (folder structure)

- Commit objects (snapshots with metadata)


Git does not store differences; it stores snapshots of your project.


HEAD

HEAD is a pointer.


It tells Git:

- Which branch you are currently on

- Which commit you are working with


When you switch branches, HEAD simply points to a different commit.


Branches

Branches are not full copies of your project. They are just lightweight pointers to commits. This is why Git branches are fast and efficient.


How Git Is Different from Other Version Control Systems

Traditional systems store file differences.  

Git stores full snapshots.


Because of this:

- Git is very fast

- Branching is easy

- Merging is powerful

- History is reliable


This design is one of the biggest reasons Git is so popular.


Comments

Post a Comment

Popular posts from this blog

Git for Beginners: Basics and Essential Commands

Git Basics and Essential Commands If you are just starting your journey in programming or software development, you have probably heard about Git. At first, Git can feel confusing and even a little scary. I felt the same way when I started. But once you understand the basics, Git becomes one of the most useful tools in your developer life. In this blog, I will explain what Git is, why you should learn it, and the most important Git commands every beginner should know. What is Git? Git is a version control system.  In simple words, Git helps you save and manage different versions of your code.  Git keeps everything organized for you. With Git, you can: - Track changes in your code - Go back to older versions if something breaks - Work on new features without affecting the main code Why Git is Important for Beginners :  - It keeps your code safe - It helps you understand how real projects are managed - It allows multiple people to work on the same project - Almost every com...
Read more

Why Version Control Exists: The Pendrive Problem

Why Version Control Exists (Pendrive Problem) Before Git, before GitHub, and before version control systems even existed, developers had a very common problem. If you have ever used a pendrive to carry project files, you already know this problem very well. This blog explains why version control exists, using a simple and real-life example known as “The Pendrive Problem”. Life Before Version Control Imagine this situation: You are working on a project. You save it on your laptop.  Then you copy the project to a pendrive so you can work on it somewhere else. After a few days, your folder looks like this: project   project_final   project_final2   project_final_latest   project_final_latest_real   At this point, even you don’t know which one is the correct version.  This was normal before version control systems existed. The Pendrive Problem Explained Now let’s say you are working with a friend on the same project.  You give...
Read more