Git vocabulary

284 Git terms, from Novice to Master. Start with the basics or jump to a level.

Updated

Novice

.git directory
The hidden folder that stores a repository's Git data, including objects, references, and configuration.
.gitignore
A file containing patterns for intentionally untracked files that Git should normally ignore.
Added line
A line present in the newer version of a diff but absent from the older version.
Author
The person who wrote the changes in a commit
Branch
A movable name that identifies the latest commit in one line of development.
Change
A difference made to a project file, such as adding, editing, or removing content.
Clean working tree
A working tree with no tracked changes waiting to be staged or committed.
Commit
A saved snapshot of staged changes together with information such as its author, time, and message.
Commit history
The connected sequence of commits that records how a repository changed.
Commit message
A short explanation stored with a commit to describe why the change was made.
Committed file
A file whose contents have been saved in a commit.
Committer
The person who created or last applied a commit to the repository.
Current branch
The branch that receives the next commit in the present working tree.
Default branch
The branch a repository or remote treats as its primary starting branch.
Deleted line
A line present in the older version of a diff but absent from the newer version.
Dirty working tree
A working tree containing tracked changes that are not yet committed.
Distributed version control
A version control model in which each clone normally contains the project files and the complete repository history.
File state
The current relationship between a file in the working tree, staging area, and latest commit.
Git
A distributed version control system that records file changes and lets people work with the same project history.
git add
Adds selected working-tree changes to the staging area.
git clone
Creates a new local repository by copying an existing repository.
git commit
Creates a commit from the changes currently in the staging area.
git config
Reads or changes Git configuration values.
Git Credential Manager
The helper that signs Git in to GitHub through your web browser the first time you push, then remembers you, so no password is typed into the terminal.
git diff
Shows line-by-line differences between selected versions or file states.
git init
Creates an empty Git repository in a folder or reinitializes an existing one.
git log
Displays commits from repository history.
git show
Displays details and changes for a Git object, usually a commit.
git status
Shows the current branch and the state of tracked, untracked, and staged files.
GitBash
GitBash is a terminal that was created for Windows OS so that users could run standard…
GitHub
A website that stores Git repositories online, so you can back up your code and share it.
Global Git configuration
Git settings that normally apply to every repository used by one account on a computer.
Ignore pattern
A rule that matches files or folders Git should treat as ignored.
Index
Git's internal name for the data that represents the staging area.
Local Git configuration
Git settings stored for one repository and used in preference to matching global settings.
Local repository
A Git repository stored on your own computer.
Main branch
A commonly used name for a project's primary branch.
Modified file
A tracked file whose working-tree contents differ from the recorded version.
Repository
A project and the version-control data used to record its history.
Repository root
The top-level folder of a working tree.
Snapshot
The complete recorded state of the project at a particular commit.
Staged file
A file whose current changes have been placed in the staging area for the next commit.
Staging area
The prepared set of changes that will be included in the next commit.
Tracked file
A file Git already knows about and can include in future snapshots.
Untracked file
A file in the working tree that Git has not been told to track.
user.email
The Git configuration value recorded as the author or committer email address.
user.name
The Git configuration value recorded as the human-readable author or committer name.
Version control
A way to record changes to files so earlier versions can be compared or restored.
Working directory
The folder where you run Git commands and work with checked-out project files.
Working tree
The checked-out files and folders that you can currently view and edit.

Apprentice

Abort an operation
Stops an in-progress Git operation and tries to return the repository to its earlier state.
Ahead
A branch is ahead when it contains commits that its comparison branch does not contain.
Annotated tag
A tag stored as its own object with a message, tagger details, and optional signature.
Behind
A branch is behind when its comparison branch contains commits that it does not contain.
Branch name
The human-readable name used to refer to a branch.
Branch tip
The latest commit currently identified by a branch.
Centralized Version Control
A version control model where one central server holds the project's only full history.
Commit amendment
Replacing the latest commit with a new commit containing corrected content or metadata.
Conflict marker
Text Git places in a conflicted file to show the competing versions that must be resolved.
Conflict resolution
The chosen final content that replaces competing changes in a merge or rebase conflict.
Continue an operation
Resumes a paused Git operation after required conflicts or edits have been completed.
Discard changes
Replaces uncommitted edits with a chosen recorded version, permanently removing those edits.
Diverged branches
Branches that each contain commits missing from the other branch.
Executable bit
A tracked permission flag indicating that a file should be treated as executable on supporting systems.
Fast-forward merge
A merge completed by moving the current branch forward because it has no separate new commits.
Feature branch
A branch used to develop one feature separately from the main line of work.
Fetch
The operation that downloads new objects and reference information from a remote.
git branch
Lists, creates, renames, or deletes branches without switching the working tree.
git checkout
Restores selected files or switches branches using Git's older multipurpose command.
git fetch
Downloads objects and references from a remote without changing the current branch.
git merge
Combines changes from another line of development into the current branch.
git mv
Moves or renames a path and stages the resulting changes.
git pull
Fetches from a remote and then integrates the fetched branch into the current branch.
git push
Sends local objects and reference updates to a remote repository.
git remote
Views and manages the saved names and URLs of remote repositories.
git restore
Restores file contents in the working tree or removes changes from the staging area.
git revert
Creates a new commit that reverses changes introduced by an earlier commit.
git rm
Removes a tracked path from the working tree and stages the removal.
git stash
Temporarily stores selected uncommitted changes and returns those files toward a clean state.
git stash apply
Applies a stash entry while keeping the entry in the stash.
git stash drop
Deletes a selected stash entry without applying it.
git stash pop
Applies the latest or selected stash entry and removes it if the application succeeds.
git switch
Changes the current branch or creates and switches to a new branch.
git tag
Lists, creates, verifies, or deletes tags.
Lightweight tag
A tag that stores only a reference to an existing object.
Merge commit
A commit with multiple parents that joins lines of development.
Merge conflict
A situation in which Git cannot safely combine competing changes without a person's decision.
Origin
The default remote name Git usually creates when a repository is cloned.
Push
The operation that sends local commits and reference updates to a remote.
Remote
A saved name and URL for another Git repository.
Remote repository
A repository known through a URL and commonly used to exchange commits with other copies.
Remote URL
The location Git uses to contact a remote repository.
Remote-tracking branch
A local reference that records the last known position of a branch in a remote repository.
Revert commit
A commit whose changes reverse all or part of another commit.
Stash entry
One saved set of uncommitted changes in the stash.
Tag
A named reference commonly used to mark one important point in history.
Topic branch
A short-lived branch used for one focused change, such as a feature or bug fix.
Tracking branch
A local branch configured with an upstream branch for status, pull, and push operations.
Unstage
Removes changes from the staging area while normally leaving the working-tree edits in place.
Upstream branch
The branch a local branch is configured to compare with and normally pull from.
Upstream remote
A remote treated as the source repository from which changes are received.

Journeyman

Ancestor
An earlier commit reachable by repeatedly following parent links.
Bisect bad revision
A revision marked as containing the problem being investigated.
Bisect good revision
A revision marked as not containing the problem being investigated.
Caret revision syntax
Revision syntax that selects a parent or excludes commits from a set.
Client-side hook
A hook that runs in a contributor's local repository.
Commit graph
The connected structure formed by commits and their parent relationships.
Commit hash
A hexadecimal identifier used to refer to a particular commit object.
Commit-msg hook
A client-side hook that can inspect or reject a proposed commit message.
Common ancestor
A commit reachable from each of two or more commits by following parent links.
Context line
An unchanged line included around a change to show where the change belongs.
Descendant commit
A later commit that can reach another commit by following its parent links.
Detached HEAD
A state in which HEAD points directly to a commit instead of to a branch.
Diff hunk
A grouped section of nearby changed lines in a diff.
Drop a commit
Removes a selected commit while rewriting history during an interactive rebase.
Fixup
Combines a commit with an earlier commit while normally discarding the fixup commit's message.
Force push
A push that permits a remote branch to lose commits not present in the proposed update.
Force with lease
A guarded force push that fails if the remote reference no longer has the expected value.
git am
Applies mailbox-formatted patches and creates commits from them.
git apply
Applies changes from a patch to files without creating a commit.
git bisect
Uses binary search through history to help find the commit that introduced a problem.
git blame
Shows which commit and author last changed each line of a file.
git cherry-pick
Applies the changes introduced by selected commits as new commits on the current branch.
git clean
Removes selected untracked files or folders from the working tree.
git format-patch
Creates email-ready patch files from commits.
Git hook
A program Git runs when a particular repository event occurs.
git rebase
Replays commits onto a new base and replaces them with newly created commits.
git reflog
Shows recent updates to local references, including earlier positions of HEAD and branches.
git reset
Moves a branch or adjusts the index and working tree to match a selected commit, depending on its mode.
Hard reset
A reset that moves the current branch and replaces tracked index and working-tree content.
HEAD
The reference that identifies the currently checked-out branch or commit.
Hunk header
The line that identifies the old and new line ranges covered by a diff hunk.
Interactive rebase
A rebase that lets you reorder, combine, edit, rename, or remove selected commits.
Merge base
A best common ancestor used as the starting point for a merge.
Mixed reset
A reset that moves the current branch and resets the index while leaving working-tree files unchanged.
Object ID
The hash-based identifier Git uses to name an object.
Ours
The version associated with the current side of a merge, though its exact meaning can vary by operation.
Parent commit
A commit named by a later commit as its immediate history.
Patch
A text representation of changes that can be reviewed, shared, or applied.
Pre-commit hook
A client-side hook that runs before Git creates a commit.
Pre-push hook
A client-side hook that runs before objects and reference updates are sent to a remote.
Rebase todo list
The ordered instructions Git follows during an interactive rebase.
Ref
Git's short term for a reference such as a branch, tag, or remote-tracking branch.
Reference
A stored name that points to an object ID, usually a commit.
Reflog entry
A local record of one update made to a reference.
Relative reference
A reference expression that selects another commit relative to a known reference.
Revision
A commit or other object selected by a revision expression.
Revision range
An expression that selects commits by describing relationships between revisions.
Reword
Changes a commit message while keeping the commit's file changes.
Root commit
A commit with no parent, normally representing the beginning of a repository's history.
Server-side hook
A hook that runs in a repository receiving network operations.
SHA
An informal name for a Git object ID, based on the hash algorithms Git has historically used.
Signature verification
The process of checking that a Git signature is valid and associated with a trusted identity.
Signed commit
A commit containing a cryptographic signature that can be checked against its contents.
Signed tag
An annotated tag containing a cryptographic signature.
Soft reset
A reset that moves the current branch while leaving the index and working tree unchanged.
Squash
Combines a commit with the preceding commit during an interactive rebase.
Symbolic reference
A reference that points to another reference rather than directly to an object ID.
Theirs
The version associated with the other side of a merge, though its exact meaning can vary by operation.
Three-way merge
A merge that compares two branch tips with their common ancestor.
Tilde revision syntax
Revision syntax that follows a commit's first-parent chain a chosen number of times.

Freelancer

.gitattributes
A file containing Git attribute rules for paths in a repository.
Ancestry path
A revision selection limited to commits that connect chosen descendants to chosen ancestors.
Atomic ref update
A reference change that either completes as one protected operation or does not take effect.
Attribute pattern
The path-matching portion of a Git attributes rule.
Bare repository
A repository with no working tree, commonly used as a shared remote.
Clean filter
A content filter applied when data moves from the working tree toward the object database.
Cone mode
A sparse-checkout mode optimized for selecting whole directory trees.
Copy detection
Git's comparison process for identifying a new path whose content came from an existing path.
Diff driver
A configured rule that changes how Git compares or displays selected files.
Directed acyclic graph
A graph whose links have direction and cannot form a path back to the same starting point.
End-of-line normalization
Storing chosen text files with consistent line endings while allowing configured working-tree endings.
Exclude pathspec
A pathspec that removes matching paths after positive pathspecs have selected candidates.
Fetch refspec
A refspec that controls which remote references are fetched and where they are stored locally.
First-parent history
A view of history that follows only the first parent of each merge commit.
git archive
Creates an archive of files from a selected tree without including repository history.
Git attributes
Per-path settings that control behavior such as text handling, diffs, merges, and export.
Git bundle
A single file that carries Git objects and references for transfer without a live remote connection.
git for-each-ref
Formats and displays references selected from one or more reference namespaces.
git merge-base
Finds best common ancestors between commits.
Git notes
Extra information attached to objects without changing the objects themselves.
git rerere
Records conflict resolutions and can reuse them when the same conflict appears again.
git rev-list
Lists commit objects reachable under selected revision and traversal rules.
git rev-parse
Interprets revision and option syntax and can return object IDs or repository information.
git update-ref
Safely creates, updates, or deletes references while checking expected values when requested.
Histogram diff
A diff algorithm that extends patience-style matching by considering low-occurrence lines.
Linked worktree
An additional worktree connected to the same repository data as another worktree.
Magic pathspec
A pathspec using special controls for matching behavior such as case sensitivity or exclusions.
Mailmap
A file or configuration that maps alternate author identities to preferred names and email addresses.
Main worktree
The original worktree created with a normal repository, rather than one added later.
Merge driver
A configured program or built-in behavior used to merge selected file types.
Minimal diff
A diff mode that spends extra time trying to produce the smallest possible change set.
--mirror clone
A bare clone that maps all references from the source and configures matching mirror updates.
Missing object
An object referenced by repository data but not currently available in the local object database.
Myers diff
Git's default general-purpose algorithm for finding a short edit sequence between file versions.
Namespace
A reference prefix that lets one repository expose separated groups of references.
Negative refspec
A fetch refspec beginning with an exclusion that removes matching references from a broader selection.
Notes ref
A reference whose commits store notes attached to other Git objects.
Partial clone
A clone that can omit selected reachable objects and request them later when needed.
Pathspec
A Git expression that selects paths for a command.
Patience diff
A diff algorithm that anchors on unique lines to make some changes easier to read.
Promisor remote
A remote that promises it can supply objects intentionally omitted from a partial clone.
Push refspec
A refspec that controls which local references update which references on a remote.
Recorded resolution
A conflict resolution saved by rerere for possible reuse.
Refspec
A pattern describing which source references map to which destination references during fetch or push.
Rename detection
Git's comparison process for pairing a deleted path with a sufficiently similar added path.
Replace ref
A reference that tells Git to read one object as a replacement for another object.
Repository mirror
A repository copy configured to reproduce all selected references from another repository.
Revision walk
The process of traversing commits from starting revisions while applying ordering and limiting rules.
Shallow clone
A clone created with only a limited portion of reachable commit history.
Shallow repository
A repository whose history intentionally stops at recorded shallow boundary commits.
Smudge filter
A content filter applied when data moves from the object database into the working tree.
Sparse checkout
A working-tree arrangement that populates only selected paths from the current commit.
Submodule
A repository recorded inside another repository through a path and a specific commit.
Submodule commit
The specific commit of a submodule recorded by its superproject.
Superproject
A repository that records one or more submodules.
Text attribute
An attribute that tells Git whether a path should receive text and line-ending processing.
Topological order
A commit order that avoids showing a parent before any displayed descendant.
Word diff
A diff display that highlights changed words instead of only changed lines.
Working-tree encoding
An attribute describing the character encoding a file should use in the working tree.
Worktree
A checked-out set of repository files associated with its own HEAD and index.

Master

Alternate object database
Another object directory a repository is configured to search for objects it does not store itself.
Background maintenance
Scheduled or incremental repository tasks that improve performance without a full manual cleanup.
Blob object
A Git object that stores file content without the file's name or path.
Cache tree
Index extension data that caches tree object information for directories whose entries have not changed.
Capability advertisement
The protocol exchange that tells the other side which optional Git features are supported.
Commit object
A Git object that identifies a root tree, parent commits, author data, committer data, and a message.
Commit-graph file
A derived file that stores commit relationships and generation data to speed history queries.
Content-addressable storage
Storage ID used by git that is based on what is in the file.
Cruft pack
A packfile that stores unreachable objects together with information about when they became eligible for expiry.
Dangling object
An unreachable object that is not used by another unreachable object.
Delta chain
A sequence of delta-compressed objects that must be combined to reconstruct an object.
Delta compression
Storing one object's differences from another object to reduce packfile size.
Dumb protocol
A basic transfer method that serves repository files without Git-aware negotiation on the server.
Fetch negotiation
The part of a fetch where client and server identify common history and decide what objects are needed.
File system monitor
A service that tells Git which working-tree paths may have changed since an earlier check.
Garbage collection
Repository maintenance that consolidates storage and eventually removes expired unreachable data.
Generation number
A commit-graph value that helps Git avoid walking into history that cannot contain a desired commit.
git cat-file
Displays object types, sizes, or contents directly from the object database.
git commit-tree
Creates a commit object from a tree, message, parent information, and identity environment.
git fsck
Checks object connectivity and validity and reports unreachable or damaged objects.
git gc
Runs repository housekeeping such as packing objects, cleaning auxiliary data, and pruning eligible objects.
git hash-object
Calculates an object ID for content and can optionally write the resulting blob object.
Git object model
The system in which blobs, trees, commits, and annotated tags form Git's stored history.
Git protocol
The rules Git clients and servers use to advertise references and transfer repository data.
git prune
Deletes unreachable loose objects that are older than the selected expiration time.
git write-tree
Creates a tree object from the current index and prints its object ID.
Index entry
The index record for one tracked path, including its object ID, mode, stage, and cached file information.
Index stage
A number identifying the normal entry or one side of an unresolved merge in the index.
Loose object
An individual Git object stored in its own compressed file.
Merge strategy
The high-level algorithm Git uses to combine commit histories.
Multi-pack-index
An index that locates objects across multiple packfiles without combining those packs.
Object corruption
Damage or inconsistency that prevents a stored Git object from matching or decoding under its object ID.
Object database
The repository storage that holds Git objects addressed by their object IDs.
Object header
The object type and content length included when Git calculates an object's ID.
Object negotiation
The exchange used to determine which objects one repository must send to another.
Object pruning
Permanently deleting eligible unreachable objects from the object database.
Octopus merge
A merge that combines more than two other branch tips in one merge commit.
Ort strategy
Git's default strategy for typical two-head merges, designed for correctness and performance.
Pack index
A companion file that helps Git quickly locate objects inside a packfile.
Packed object
A Git object stored inside a packfile, possibly as a delta from another object.
Packed refs
A file that stores many references together instead of as separate loose reference files.
Packet line
A length-prefixed message unit used by Git's wire protocols.
Packfile
A file that stores many compressed Git objects together.
Protocol version 2
A Git wire-protocol version that requests capabilities and commands in a more structured, extensible exchange.
Quarantine environment
Temporary object storage used to inspect received objects before accepting them into a repository.
Reachability bitmap
A compact record of object reachability used to accelerate traversals and object negotiation.
Reachable object
An object that can be found by following links from a selected reference or other starting point.
Recursive merge
The former default two-head merge strategy that can combine multiple merge bases recursively.
Reference transaction
A group of reference updates prepared and committed together under Git's reference rules.
Reflog expiration
The process of removing reflog entries after configured retention periods.
Repository integrity
The condition in which repository objects and references are valid, connected as expected, and uncorrupted.
Shallow boundary
A recorded commit treated as having no parents because earlier history is absent from a shallow repository.
Sideband
A protocol channel that multiplexes pack data, progress messages, and errors over one connection.
Smart protocol
A Git transfer protocol in which Git-aware endpoints negotiate and generate the required object data.
Sparse index
An index that can represent excluded directory trees with single entries instead of listing every file.
Split index
An index mode that stores shared entries separately so routine index updates can stay smaller.
Subtree merge
A merge approach that adjusts one project's tree to fit beneath a directory in another project.
Tag object
A Git object used by an annotated tag to name another object and store tagger information and a message.
Thin pack
A packfile allowed to depend on base objects expected to exist outside that pack.
Tree object
A Git object that records names, modes, and object IDs for files and subdirectories.
Unmerged index entry
One of the staged base, ours, or theirs records retained for a path with an unresolved conflict.
Unreachable object
An object that exists locally but cannot be reached from the references being considered.
Untracked cache
Index extension data that avoids repeatedly scanning unchanged directories for untracked files.

More subjects in Cloud & DevOps