I find git hard to understand as I could not find the meaning of the words used for the actions. I have checked the dictionary for the meaning of 'stage' and none of the meanings were related to source control concepts.

What does 'stage' mean in the context of git?

  • 22
    Git does indeed have its own vocabulary. And since every instruction is formulated in the special vocabulary it is hard to get started. To "stage" is to do git add file.ext for a specific file, or git add . to affect all modified and untracked files. Files that have been added in this way are said to be "staged" and they will be included in the next "commit". The commit is a snapshot of your work created e.g. with git commit -m "I wrote something". Commented Dec 15, 2016 at 17:47
  • 21
    Git is hard to understand because there is no conceptual tutorial out there. All go through unnecessary details.
    – Xaqron
    Commented Jun 12, 2017 at 8:31
  • 3
    Did you mean to remove the "terminology" tag from this question? It seems a perfectly valid tag to me. Commented Jan 29, 2018 at 12:08
  • 1
    For some reason, the best way I could understand the importance of staging is from this answer in Quora: qr.ae/TbSK2I
    – Lamar
    Commented Feb 25, 2018 at 8:11
  • 1
    One thing that was not clear to me from other answers was that if you only want to do a partial commit of your local repo, you stage the files you want to commit. Leave the others alone (like local testing config). When you commit, you commit your staged files. For example, in visual studio docs.microsoft.com/en-us/azure/devops/repos/git/…. This is described in the purple box there.
    – mminneman
    Commented Dec 26, 2019 at 17:55

8 Answers 8


To stage a file is simply to prepare it finely for a commit. Git, with its index allows you to commit only certain parts of the changes you've done since the last commit. Say you're working on two features - one is finished, and one still needs some work done. You'd like to make a commit and go home (5 o'clock, finally!) but wouldn't like to commit the parts of the second feature, which is not done yet. You stage the parts you know belong to the first feature, and commit. Now your commit is your project with the first feature done, while the second is still in work-in-progress in your working directory.

  • 7
    Good explanation. Note that git, being distributed, obviously allows you to commit both features, since commits are local (at first). Still, you might want to put split the modifications into one commit per feature, and again staging comes in handy.
    – sleske
    Commented Nov 15, 2011 at 9:08
  • 99
    I don't understand why you need staging for this. I can do this with HG or even SVN by only committing the relevant files. It feels like this feature is primarily designed to aid people who insist on working with the command line where it's harder to check boxes on what you are committing.
    – jiggy
    Commented Sep 19, 2012 at 17:55
  • 100
    @jiggy git allows you to stage part of a file. You can also stage a file, make further modifications, then commit the state it was in at staging. You can't do that in subversion.
    – Izkata
    Commented Apr 30, 2014 at 0:47
  • 5
    @jiggy In SVN, there is something, between the time that you select which files/parts of files to commit and when you finish writing your commit message, that records which files/parts you selected to commit. It might never be explicitly mentioned, it might be implemented in the SVN client rather than an actual part of the repository, it might just be some flags in memory, but that is SVN's stage. I haven't looked at HG, but I suspect it does the same thing. The difference with git is that git acknowledges that it is a thing, records it to disk, and lets the user get to it directly.
    – 8bittree
    Commented Aug 8, 2014 at 20:13
  • 8
    The second arrow "stage files" in the figure might be misleading. "stage hunks" might be more accurate?
    – Ida
    Commented Oct 10, 2014 at 13:44

Since everyone so far has answered it the "formal" way, let me do this with alternatives to enhance learning with the power of metaphors.

So the staging area is like:

  • a cache of files that you want to commit
  • not a series of tubes but actually a dump truck, ready to move the work you load it with, in to the repository
  • a magical place where selected files will be turned into stone with your wizardry and can be magically transported to the repository at your whim
  • the yellow brick road for the files to go happily to the repository (or fall off if you want to revert)
  • the fictional place at the sea port where files are received a pair of cement shoes and then thrown into the repository sea
  • the receptions desk at the library, you put the files there for the librarian to prepare for filing into the library
  • a box where you put things in before shoving it under your bed, where your bed is a repository of boxes you've previously have shoved in
  • the loading bay of files before it goes into the repository warehouse with the power loader
  • the filter of an electric drip coffee maker, if the files are like the coffee powder, then the committed files are the brewed coffee
  • the Scrooge McDuck's office next to the vault, the files are like the coins before they go into the vault of his massive Money Bin
  • the pet store, once you bring a pet home you're committed

It's magical!

  • 1
    Love the analogies; way to go bud ^_^ Commented Feb 22, 2019 at 14:58
  • 1
    Love the final analogy. Commented Apr 9, 2019 at 0:49
  • 1
    This answer was "DESPERATELY" needed among the space of common attempts to explain the metaphysics of the git index = git staging. Frankly, I'd also like to know what Linus was thinking when he decided he wanted an index area. I like it, but I simply want to better appreciate why it's good to have it and how to use it most effectively.
    – Thom Ives
    Commented Dec 2, 2020 at 3:56

Staging is a step before the commit process in git. That is, a commit in git is performed in two steps: staging and actual commit.

As long as a changeset is in the staging area, git allows you to edit it as you like (replace staged files with other versions of staged files, remove changes from staging, etc.).

Broken metaphor time:

Consider a scenario where you call the movers to get your stuff from your old appartment to your new appartment. Before you do that, you will go through your stuff, decide what you take with you and what you throw away, pack it in bags and leave it in the main hallway. The movers simply come, get the (already packed) bags from the hallway and transport them. In this example, everything until the movers get your stuff, is staging: you decide what goes where, how to pack it and so on (e.g. you may decide that half your stuff will be thrown away before the movers even get there - that's part of staging).

From a technical point of view, staging also supports transactional commits, by splitting all operations into what can fail (staging) and what cannot fail (commit):

The commit in git is implemented transactionally, after the staging is sucessfull. Several steps in the staging can fail (for example, you need to commit, but your HDD is 99.9999% full, and git has no space to perform a commit). This will fail in staging (your repository will not be corrupted by a partial commit) and the staging process doesn't affect your commit history (it doesn't corrupt your repository in case of an error).


To stage a file is to prepare it for a commit. Because git exposes this action to the users control it allows you to create partial commits, or to modify a file, stage it, modify it again, and only commit or revert to the original modification.

Staging allows you finer control over exactly how you want to approach version control.


To add to the other excellent answers, here's where the name for "stage" comes from:

I checked the dictionary for the meaning of stage and none of the meanings was related to source control concepts.

In English, "to stage" can mean

organize and participate in (a public event): UDF supporters staged a demonstration in Sofia

(from http://oxforddictionaries.com/definition/stage )

The name "staging" for the git feature derives from this meaning: When staging, you are preparing and organizing a commit. Of course a commit is not quite the same as a performance, but it is an important event in a VCS :-).

  • 4
    I'd have thought it more closely matched the use in staging post
    – Useless
    Commented Apr 30, 2014 at 16:21
  • 2
    Ditto. Also, "a point, period, or step in a process or development."
    – Darien
    Commented Aug 8, 2014 at 23:05
  • Also 'staging server' is a pretty common term used to describe a server that's between development and production.
    – Eternal21
    Commented May 2, 2017 at 19:15

The "stage" is a technically required intermediate step in the process of checking in a file, namely collecting the changes to be added to the repository. Git's authors chose to make this step visible and persistent where other VCS make it a transient part of the commit process. So it's just an option that git gives you because it can so why not?

The way I see it, the main thing the git "stage" gives you that other VCS don't is that you can use it to checkpoint a file. It's effectively an unnamed, uncommented local commit that gives you an intermediate step between being done with all your work and committing it to the repository permanently and having nothing saved in your local repo at all.

For example, let's say you have a feature partially finished. It's in a stable state, passes all the tests, and could go into production, but you have more work to do on it. You could stage all your changes and then continue to work on the feature.

Later, you'll have the option to just commit what you staged (and push that commit to the remote repository) or to add your new changes to your staging area and then commit that all at once, or to undo just your new changes and revert your working directory to the state it was in when you staged your changes.

It's completely possible to practically skip the staging area altogether and just use the -a option to git commit if you don't find the staging area a helpful concept. Lots of people skip staging and GUI tools usually allow for this, too.

  • "other VCS don't" -- what makes you think so? Shelving at Perforce appears to be doing what you describe, and even with few additional bells and whistles
    – gnat
    Commented Apr 29, 2014 at 20:39
  • 1
    @gnat yes, of course many other VCS give you something like staging. By "other VCS" I mean other VCS that don't have something like git's stage, since that is what the OP was referring to.
    – Old Pro
    Commented Apr 29, 2014 at 21:18
  • 2
    I found this answer to be immensely better than all the above, since it's the only one that clarifies why Staging exists at all (being technically required), an explanation of its origin (Git's authors chose to make this step visible and persistent), adding what I personally find to be a good definition for it (an intermediate, unnamed, uncommented local commit). However, I think it could be improved by quoting a source for the statement about the origin of Staging, and elaborate some more on why it's technically required. @OldPro
    – alelom
    Commented Aug 13, 2019 at 15:58
  • Were git being designed from scratch, this could have just been part of a generalized "branch" concept, local and unseen by others in this case. Likewise "stash" could have just been implemented (and understood!) as a specific instance of the generalized concept of "branch." You could then have any number of levels of "staging" you prefer.
    – Ron Burk
    Commented Apr 29, 2020 at 17:49

With most other version control systems, there’s 2 places to store data: your working copy (the folders/files that you’re currently using) and the datastore (where the version control decides how to pack and store your changes). In Git there’s a third option: the staging area (or index). It’s basically a loading dock where you get to determine what changes get shipped away.

source: http://gitready.com/beginner/2009/01/18/the-staging-area.html

  • 1
    this doesn't seem to add anything substantial over prior 6 answers
    – gnat
    Commented Jul 11, 2014 at 4:13
  • It mentions Index. And references to a very thorough article. Upvoting. BTW, some answers above are merely jokes.
    – Gangnus
    Commented Jan 19, 2018 at 21:46

My understanding is, suppose i am developing login feature and required 5 consecutive steps to complete. So here staging will help you to work on steps like
done with step 1 stage it.
done with step 2 , now step 1 and step 2 both are correct stage it.
mess up with step 3 no problem checkout latest staged step that is step 2
same way once you done with all 5 steps that means feature is complete now perform commit.

  • this doesn't seem to add anything substantial over points made and explained in prior 9 answers
    – gnat
    Commented Aug 25, 2016 at 12:30
  • yes you are right, i just tried to make explanation simple and sweet
    – palash140
    Commented Aug 25, 2016 at 15:37
  • And what i feel like to use this concept practically i tried to explain that
    – palash140
    Commented Aug 25, 2016 at 15:39
  • consider taking a look at discussion here: Are second TL;DR answers acceptable? (FWIW compared to prior answers this one doesn't look simple nor sweet to me)
    – gnat
    Commented Aug 25, 2016 at 15:41
  • thank you sir, i have a question to ask. I have come across many answers and most of them are too complex yes those are correct but difficult to digest at once, I do believe if you can't explain anything in simple way then you have not learned it properly or don't know how to use it. So is it bad now to put summary or simple way to answer ??
    – palash140
    Commented Aug 25, 2016 at 15:56

Not the answer you're looking for? Browse other questions tagged or ask your own question.