Bump: Semantic Versioning Made Simple

• 6 min read

Managing versions in software projects is one of those tasks that seems simple until you realize how error-prone it can be. Manually incrementing semantic versions, creating Git tags, and pushing them to remotes involves multiple steps where mistakes can happen. That's why I built bump - a command-line tool that makes semantic versioning as simple as running a single command.

The Problem with Manual Versioning

Consider a typical release workflow:

# Current version: v1.2.3
# Manual process for a patch release:
git tag v1.2.4
git push origin v1.2.4

# For a minor release:
git tag v1.3.0
git push origin v1.3.0

This manual approach has several problems:

  1. Mental math required: What's the next version number?
  2. No safety checks: Are you on the right branch? Any uncommitted changes?
  3. Easy to forget steps: Did you push the tag?
  4. Typo-prone: Manual version strings are error-prone

Enter Bump: Versioning Made Effortless

Bump automates the entire semantic versioning workflow with built-in safety checks:

# Bump patch version (1.2.3 -> 1.2.4)
bump

# Bump minor version (1.2.3 -> 1.3.0)
bump minor

# Bump major version (1.2.3 -> 2.0.0)
bump major

# Made a mistake? Undo the last tag
bump undo

That's it. No mental math, no typos, no forgotten steps.

Smart Safety Checks

Before creating any tags, bump performs several validation checks:

  • Branch validation: Ensures you're on the default branch (main/master)
  • Clean working directory: Checks for uncommitted changes
  • Remote connectivity: Verifies the repository has a remote (unless --local is used)
  • Tag fetching: Gets the latest tags from remote to ensure accuracy

These checks prevent common mistakes like:

  • Tagging from a feature branch
  • Creating releases with uncommitted changes
  • Version conflicts due to stale local tags

Installation and Setup

Getting started is straightforward:

🍺 Homebrew
brew tap flaticols/apps
brew install flaticols/apps/bump
Go Gopher Go
go install github.com/flaticols/bump@latest

No configuration files, no setup - it works out of the box with any Git repository that uses semantic versioning tags.

Real-World Usage Patterns

Standard Release Workflow

# Feature development complete, ready for release
git checkout main
git pull origin main

# Create and push a minor version
bump minor
# Output: ✓ Bumped version from v1.2.3 to v1.3.0

Quick Patch Releases

# Fix deployed, need immediate patch release
bump  # Defaults to patch increment
# Output: ✓ Bumped version from v1.3.0 to v1.3.1

Breaking Changes

# Major refactor ready
bump major
# Output: ✓ Bumped version from v1.3.1 to v2.0.0

CI/CD Integration

For automated releases, use brave mode to skip confirmations:

# In your CI pipeline
bump minor --brave --verbose

Advanced Features

Repository Flexibility

# Work with a specific repository
bump --repo /path/to/other/project

# Work with local-only repositories
bump --local

Customization Options

# Detailed output for debugging
bump --verbose

# Clean output for scripting
bump --no-color

Undo Capability

Made a mistake? The undo feature has you covered:

bump undo
# Removes the latest semantic version tag

Why I Built Bump

After years of manually managing versions across multiple projects, I was tired of the friction. Existing tools were either too complex or didn't provide the safety checks I wanted. I needed something that:

  • Just works: No configuration, no learning curve
  • Stays safe: Validates context before making changes
  • Feels natural: Commands that match how I think about versioning
  • Integrates easily: Works with existing Git workflows

Bump delivers on all these requirements while being fast and lightweight.

When to Use Bump

Bump is perfect for:

  • Library maintainers releasing new versions
  • Application developers managing release cycles
  • CI/CD pipelines automating version increments
  • Teams wanting consistent versioning practices
  • Solo developers reducing release friction

Best Practices

  1. Always work from main: Let bump enforce branch requirements
  2. Commit first: Ensure all changes are committed before versioning
  3. Use semantic meaning: Choose major/minor/patch based on change impact
  4. Automate in CI: Use --brave mode for automated releases
# Good workflow
git checkout main
git pull origin main
git add . && git commit -m "feat: new feature"
bump minor

Try It Out

# Test it out
cd your-git-repo
bump --help

Visit the project website or check out the source on GitHub. If you're managing versions manually, give bump a try - it might just save you from your next versioning mistake.