1
2
3
4
5
6
7
8
9
10
main    ──●────────●────────●────────  (production releases)
          │        │        │
release   │   ┌────●────●───┘           (release preparation)
          │   │    │    │
develop  ●────●────●────●────●─────     (integration branch)
          │   │         │
feature   │   └──●─────┘                (feature development)
          │
hotfix    └──────●───●──                (emergency fixes)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# macOS (Homebrew)
brew install git-flow-avh

# Ubuntu/Debian
sudo apt-get install git-flow

# CentOS/RHEL/Fedora
sudo yum install gitflow
sudo dnf install git-flow

# Windows (Chocolatey)
choco install gitflow-avh

# Windows (Scoop)
scoop install git-flow

# Arch Linux
sudo pacman -S gitflow-avh

1
2
3
4
5
# AVH edition
git clone --recursive https://github.com/petervanderdoes/gitflow-avh.git
cd gitflow-avh
sudo make install

1
2
3
4
git flow version
git flow help
which git-flow

1
2
3
4
5
6
7
8
9
# Interactive initialization
git flow init

# Use defaults (non-interactive)
git flow init -d

# Force re-init (overwrite existing GitFlow config)
git flow init -f

1
2
3
git flow config
git config --get-regexp gitflow

1
2
3
4
git push -u origin main
git push -u origin develop
git branch -a   # verify

1
2
3
4
5
6
7
git flow feature start <feature-name>
git flow feature start <feature-name> <base>   # From a specific commit

# Examples
git flow feature start user-authentication
git flow feature start JIRA-123-checkout

1
2
3
4
5
6
7
8
9
10
11
12
git checkout feature/<feature-name>

git add .
git commit -m "feat: add registration endpoint"
git push origin feature/<feature-name>

# Make the feature visible to others
git flow feature publish <feature-name>

# Track a published feature locally
git flow feature pull origin <feature-name>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Merge to develop and delete branch
git flow feature finish <feature-name>

# Keep the branch after merging
git flow feature finish -k <feature-name>

# Rebase on develop instead of merge
git flow feature finish -r <feature-name>

# Force-finish (even with unmerged changes)
git flow feature finish -F <feature-name>

# Squash all feature commits into one
git flow feature finish -S <feature-name>      # AVH

1
2
3
4
5
6
git flow feature list
git flow feature list -v                       # Verbose
git flow feature track <feature-name>
git flow feature delete <feature-name>         # AVH
git flow feature checkout <feature-name>

1
2
3
4
5
6
7
git flow release start <version>
git flow release start <version> <base>

# Examples
git flow release start 1.2.0
git flow release start 2.0.0-rc1

1
2
3
4
5
6
7
8
9
git checkout release/<version>

# Bump version
echo "1.2.0" > VERSION
git commit -am "chore: bump version to 1.2.0"

# Update changelog, docs, last-minute bug fixes...
git flow release publish <version>             # Share with team

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Default: merge to main, tag, merge back to develop, delete branch
git flow release finish <version>

# Tag with a specific message
git flow release finish -m "Release 1.2.0" <version>

# Keep release branch after finishing
git flow release finish -k <version>

# Sign the tag (GPG/SSH)
git flow release finish -s <version>
git flow release finish -u <key-id> <version>  # Sign with specific key

# Push everything at once (AVH)
git flow release finish -p <version>

1
2
3
4
git flow release list
git flow release track <version>
git flow release delete <version>              # AVH

1
2
3
4
5
6
7
git flow hotfix start <hotfix-name>
git flow hotfix start <hotfix-name> <base-tag>

# Examples
git flow hotfix start 1.2.1
git flow hotfix start security-patch v1.2.0

1
2
3
4
5
6
7
git checkout hotfix/<hotfix-name>

git add .
git commit -m "fix: patch critical security vulnerability"

git flow hotfix publish <hotfix-name>          # Share if collaborating

1
2
3
4
5
6
7
8
git flow hotfix finish <hotfix-name>

# This merges to main, tags it, then merges back to develop, deletes branch.

git flow hotfix finish -m "Hotfix 1.2.1" <hotfix-name>
git flow hotfix finish -s <hotfix-name>        # Signed tag
git flow hotfix finish -p <hotfix-name>        # Auto-push (AVH)

1
2
3
git flow hotfix list
git flow hotfix delete <hotfix-name>           # AVH

1
2
3
4
5
6
7
git flow bugfix start <name>
git flow bugfix start <name> <base>
git flow bugfix publish <name>
git flow bugfix finish <name>
git flow bugfix list
git flow bugfix delete <name>

1
2
3
4
5
6
7
8
9
10
11
git flow support start <version> <base-tag>

# Example: maintain the 1.x line from tag v1.2.0
git flow support start 1.x v1.2.0

# Maintain
git checkout support/1.x
git commit -am "Backport security fix to 1.x"
git tag v1.2.1
git push origin support/1.x --tags

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# GitFlow
git flow feature start user-auth
# ... work ...
git flow feature finish user-auth

# Manual equivalent
git checkout develop && git pull origin develop
git checkout -b feature/user-auth
# ... work ...
git checkout develop && git pull origin develop
git merge --no-ff feature/user-auth
git branch -d feature/user-auth
git push origin develop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# GitFlow
git flow release start 1.2.0
# ... prep ...
git flow release finish 1.2.0

# Manual equivalent
git checkout develop && git pull origin develop
git checkout -b release/1.2.0
# ... prep ...
git checkout main && git pull origin main
git merge --no-ff release/1.2.0
git tag -a v1.2.0 -m "Release 1.2.0"
git checkout develop && git merge --no-ff release/1.2.0
git branch -d release/1.2.0
git push origin main develop --tags

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# GitFlow
git flow hotfix start 1.2.1
# ... fix ...
git flow hotfix finish 1.2.1

# Manual equivalent
git checkout main && git pull origin main
git checkout -b hotfix/1.2.1
# ... fix ...
git checkout main && git merge --no-ff hotfix/1.2.1
git tag -a v1.2.1 -m "Hotfix 1.2.1"
git checkout develop && git merge --no-ff hotfix/1.2.1
git branch -d hotfix/1.2.1
git push origin main develop --tags

1
2
3
git flow feature finish --showcommands user-auth
git flow release finish --showcommands 1.2.0

1
2
3
4
5
6
7
8
9
10
feature/user-authentication
feature/payment-integration
feature/JIRA-123-checkout
release/1.2.0
release/2024.01
hotfix/1.2.1
hotfix/cve-2024-1234
bugfix/login-redirect
support/1.x

1
2
3
4
5
6
7
8
9
10
11
feat:     a new feature
fix:      a bug fix
docs:     documentation only
style:    formatting (no code change)
refactor: code change that is neither feature nor fix
perf:     performance improvement
test:     adding or fixing tests
chore:    tooling, build, deps
ci:       CI configuration
revert:   reverts a previous commit

1
2
3
4
5
6
7
8
9
10
11
12
MAJOR.MINOR.PATCH

1.0.0          initial release
1.1.0          new features (minor)
1.1.1          bug fixes (patch)
2.0.0          breaking changes (major)

1.2.0-alpha.1  pre-release
1.2.0-beta.2
1.2.0-rc.1
1.2.0+build.42 build metadata

1
2
3
4
5
6
7
8
9
10
11
12
git flow feature start user-dashboard
# work...
git add . && git commit -m "feat: dashboard layout"
git commit -am "feat: dashboard API integration"
git commit -am "test: dashboard component tests"

git checkout develop && git pull origin develop
git checkout feature/user-dashboard && git merge develop

git flow feature finish user-dashboard
git push origin develop

1
2
3
4
5
6
7
8
9
git flow release start 1.3.0
echo "1.3.0" > VERSION
git commit -am "chore: bump version to 1.3.0"
git commit -am "docs: update CHANGELOG for v1.3.0"
git commit -am "fix: edge case in user validation"

git flow release finish -s 1.3.0
git push origin main develop --tags

1
2
3
4
5
6
git flow hotfix start 1.3.1
git commit -am "fix: critical payment processing bug"
git flow hotfix finish -s 1.3.1
git push origin main develop --tags
# Deploy immediately.

1
2
3
4
5
6
7
8
9
git flow feature start complex-feature
while developing; do
    git commit -am "progress"
    git checkout develop && git pull
    git checkout feature/complex-feature && git merge develop
    git push origin feature/complex-feature
done
git flow feature finish complex-feature

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# One-time setup
git config --global user.signingkey <GPG-KEY-ID>          # or SSH key (Git 2.34+)
git config --global commit.gpgsign true
git config --global tag.gpgsign true
git config --global gpg.format ssh                        # if using SSH signing
git config --global user.signingkey ~/.ssh/id_ed25519.pub

# Per-finish signed tag
git flow release finish -s 1.2.0
git flow hotfix finish -s 1.2.1

# Verify
git tag -v v1.2.0
git log --show-signature

1
2
3
4
5
6
7
8
9
10
11
# Example: GitHub Actions trigger map
on:
  push:
    branches:
      - main
      - develop
      - 'release/**'
      - 'hotfix/**'
    tags:
      - 'v*'

1
2
3
# Error: Not a gitflow-enabled repo yet
git flow init -d

1
2
3
4
git flow feature checkout <feature-name>   # Switch to existing
git branch -D feature/<feature-name>       # Or delete and recreate
git flow feature delete <feature-name>     # AVH

1
2
3
4
5
6
# git flow finish stops at the conflict — resolve, then continue.
git status
# edit conflicted files
git add <resolved-files>
git flow feature finish <feature-name>     # re-run; GitFlow resumes

1
2
3
4
5
# Error: No tracking information
git flow feature publish <feature-name>
# or
git push -u origin feature/<feature-name>

1
2
3
4
git branch -m feature/fix hotfix/fix
git checkout main
# Recreate via the correct command, then delete the misnamed one

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Abort an in-progress finish
git merge --abort
git rebase --abort

# Recreate a deleted branch
git branch feature/<name> <sha>
git flow feature list

# Reset GitFlow config
git config --unset gitflow.branch.main
git config --unset gitflow.branch.develop
git flow init -f

# Clean up merged branches
git remote prune origin
git branch --merged | grep -vE '^\*|main$|develop$' | xargs -n 1 git branch -d

1
2
3
4
5
6
7
8
9
10
git flow config
git config --get-regexp gitflow
git branch -a
git log --oneline --graph --all
git remote -v
git remote show origin

# Print the underlying git commands a GitFlow command would run
git flow feature finish --showcommands <name>

1
2
3
main + short-lived feature branches.
PR → review → merge → deploy from main.

1
2
3
main → pre-production → production
Feature branches merge to main, then promote through environments.

1
2
3
main + feature/release/hotfix, NO develop branch.
Releases are tags on main; hotfixes branch from a release tag.

1
2
3
4
Everyone commits to main (or short-lived branches that live hours, not days).
Feature flags hide unfinished work.
Pairs naturally with CD.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
[gitflow "branch"]
    master = main
    develop = develop

[gitflow "prefix"]
    feature = feature/
    bugfix = bugfix/
    release = release/
    hotfix = hotfix/
    support = support/
    versiontag = v

[gitflow "path"]
    hooks = .git/hooks

1
2
3
4
5
6
7
8
9
10
11
12
13
# Add to ~/.bashrc or ~/.zshrc
alias gf='git flow'
alias gff='git flow feature'
alias gffs='git flow feature start'
alias gfff='git flow feature finish'
alias gfr='git flow release'
alias gfrs='git flow release start'
alias gfrf='git flow release finish'
alias gfh='git flow hotfix'
alias gfhs='git flow hotfix start'
alias gfhf='git flow hotfix finish'
alias gfb='git flow bugfix'

1
2
3
4
5
6
7
8
filter-flow-feature-start-name
pre-flow-feature-start
post-flow-feature-finish
pre-flow-release-start
post-flow-release-finish
pre-flow-hotfix-finish
post-flow-hotfix-finish

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Features
git flow feature start <name>
git flow feature publish <name>
git flow feature finish <name>

# Releases
git flow release start <version>
git flow release finish -s <version>

# Hotfixes
git flow hotfix start <name>
git flow hotfix finish -s <name>

# Bugfixes (AVH)
git flow bugfix start <name>
git flow bugfix finish <name>

1
2
3
4
5
6
7
git status
git branch -a
git log --oneline --graph --all -20

git checkout develop && git pull origin develop
git checkout main    && git pull origin main