Most developers learn Git by memorizing commands like git add, git commit, and git push. However, Git is much more than a command-line tool — it is a powerful content tracking system that stores snapshots of your project efficiently and securely. To truly understand Git, we must explore what happens internally, especially inside the hidden .git folder. Instead of memorizing commands, building a mental model of how Git works makes everything clearer and more logical.

How Git Works Internally

4

Git works by storing snapshots of your project, not just the differences between files. Every time you commit, Git saves the current state of your project. It does this efficiently by storing only new or changed content while reusing existing data whenever possible. Internally, Git manages three main areas: the working directory (where you edit files), the staging area (where changes are prepared), and the repository (inside the .git folder). When you modify a file, it changes in your working directory. When you run git add, Git moves that change into the staging area. When you run git commit, Git permanently stores a snapshot inside the .git folder.

Git also uses a special hashing algorithm called SHA-1 to generate a unique fingerprint for every piece of data it stores. If even one character changes in a file, the hash changes completely. This ensures data integrity and makes Git extremely reliable.

Understanding the .git Folder

When you run git init, Git creates a hidden folder named .git. This folder is the heart of your repository. It contains everything Git needs to track your project history. If you delete the .git folder, you lose all version history because that folder stores all commits, branches, and metadata.

Inside the .git folder, Git maintains several important components. The objects directory stores all Git objects such as file contents and commits. The refs directory keeps track of branch references. The HEAD file points to the current branch you are working on. The index file represents the staging area, and the config file stores repository-specific settings. In simple terms, the .git folder acts like a private database that manages your project’s entire history.

Git Objects: Blob, Tree, and Commit

Git stores data in the form of objects, and there are three main types: Blob, Tree, and Commit. A blob (Binary Large Object) stores the actual content of a file. It does not store the file name — only the content. If you modify a file, Git creates a new blob with a new hash. A tree object represents the directory structure and connects file names to their corresponding blobs. It acts like a folder that organizes files. A commit object links everything together. It stores a reference to a tree, author information, commit message, timestamp, and a reference to the previous commit. This structure creates a chain of commits that forms your project history. The relationship can be understood as: Commit points to Tree, and Tree points to Blobs.

What Happens During git add and git commit

When you run git add, Git reads the file from your working directory and creates a blob object from its content. It then generates a SHA-1 hash and stores the blob inside the .git/objects folder. The staging area (index) is updated to track this prepared snapshot. At this stage, changes are ready but not permanently recorded in history.

When you run git commit, Git creates a tree object representing the current directory structure from the staged files. It then creates a commit object that points to this tree and links it to the previous commit. Finally, Git updates the HEAD pointer to reference the new commit. This process creates a new snapshot in your project history.

How Git Tracks Changes Using Hashes

Git tracks changes by generating unique hashes based on file content. Each blob, tree, and commit has its own SHA-1 hash. Because the hash is generated from the content itself, any change in content produces a completely different hash. This makes Git a content-addressable system. It ensures that data cannot be altered without detection, and it prevents corruption or duplication. Every version of your project is uniquely identified and securely stored.

In today’s world of software development, writing code is only one part of the process. Managing that code efficiently is equally important. Imagine building a project for weeks and suddenly losing your progress, or working in a team where everyone edits the same file without coordination. This is where Git becomes essential. Git is a powerful tool that helps developers track changes, manage different versions of their projects, and collaborate smoothly.

In this article, we will explore what Git is, why it is used, its basic concepts and terminologies, essential commands every beginner should know, and a simple developer workflow. We will also look at diagrams to better understand how Git works internally. By the end, you will have a solid foundation in Git and feel confident starting your own projects using it.

What is Git?

Git is a distributed version control system designed to track changes in source code. Let’s try to understad this definition. A version control system is a application or simply u can say a tool that track the changes made to files over time so that you can see specific versions later. The word distributed means that every developer working on a project has their own complete copy of the repository, including its history.

Think of Git like a time machine for your project. Every time you make meaningful progress, you can save a snapshot. If something breaks later, you can go back to a previous version easily. Instead of creating folders like project_final, project_final_v2, and project_last_final, Git manages everything systematically with a clear history.

Why Git is Used

Software development is not a one day or one time activity. Projects evolve continuously. Features are added,and that create some bugs which are fixed, and improvements are done on a regularly basis.So it becomes hard to manage thier last version so without a version control system it is a utter chaos for magnage version of your project

Consider a real-life example. Suppose you are building a portfolio website. Everything is working perfectly. then you decide to redesign the navigation bar after making some changes, the entire layout breaks.(which is Called Code fat gaya in industry) Without Git, you might struggle to remember what you changed. With Git, you can simply revert to the last working version within seconds.

Git is also extremely useful in team project . Imagine three developers working on the same project. Without version control, they might overwrite each other's work accidentally no body knows who change their code while Git ensures that everyone’s changes are tracked and merged properly.

In short, Git is used to:

• Track changes in code

• Maintain a history of project development

• Allow safe experimentation

• Support team collaboration

• Restore previous working versions when needed

Git Basics and Core Terminologies

To use Git effectively, you need to understand some key terms.

A repository, also called a repo, is a folder that Git tracks. You can think server(GITHUB) as your house and a room is a rep which is watched by a camare who track every moment in the room .Repo contains your project files along with a hidden .git folder that stores commit history and configuration details. You can think of a repository as a project with memory.

A commit is a snapshot of your project at a particular point in time. Every commit includes a unique identifier, the author’s information, date and time, and a message describing the changes. For example, a commit message might say “New feature add kr diya ” or “XYZ feature remove kr diya.” Commits help you document your progress step by step.

A branch allows you to create a separate line of development. Suppose your main project is stable, but you want to experiment with a new feature like dark mode. Instead of modifying the main version directly, you create a branch. If the experiment fails, your main project remains unaffected.

The term HEAD refers to a pointer that indicates your current position in the commit history. In simple words, it tells Git which commit you are currently working on.

How Git Works Internally

Git operates using three main areas: the working directory, the staging area, and the repository.

4

The working directory is where you write and modify your files. When you make changes, they exist only in this area initially.

The staging area is like a preparation zone. Before saving changes permanently, you select which files should be included in the next commit.

The repository is where Git permanently stores your committed snapshots.

You can imagine it like preparing an assignment. Writing answers happens in the working directory. Reviewing and selecting final content happens in the staging area. Submitting the assignment is similar to making a commit.

Common Git Commands

To begin using Git, you need to know some essential commands.

The command git init initializes a new Git repository in your project folder. This is usually the first command you run when starting a project.

The command git status shows the current state of your project. It tells you which files are modified, staged, or untracked.

The command git add moves files from the working directory to the staging area. You can add specific files or use git add . to stage all changes.

The command git commit -m "message" saves your staged changes permanently in the repository with a descriptive message.

Finally, git log displays the commit history, allowing you to view all past changes in chronological order.

A Simple Developer Workflow

A beginner-friendly Git workflow looks like this:

First, create your project folder and run git init. Then create or modify files as needed. After making changes, use git status to see what has changed. Next, use git add . to stage the changes. Finally, use git commit -m "Your message" to save a snapshot.

This cycle—modify, stage, commit—is repeated throughout the project’s life.

Over time, your commit history forms a chain.

4

Each commit builds upon the previous one, creating a timeline of your project’s evolution.

Conclusion

Git is not just another tool ,it is a blessing for developer.It is a fundamental skill that allows you to manage changes easily , collaborate with others, and maintain a reliable history of your work.