⬆️ Bump2version

bump2version is the world's fastest version bumper written entirely in 100% safe Rust, with no_std support, native Python and Node.js bindings, and a cargo bump subcommand 🗿.

🚀 Installation

Platform	Command
Rust binary	cargo install bump2version --features rust-binary
Cargo subcommand	cargo bump --help
Docker	docker pull wiseaidev/bump2version
Debian/Ubuntu	Download .deb from GitHub Releases
RHEL/Fedora	Download .rpm from GitHub Releases
Windows	Download bump.exe from GitHub Releases
GitHub Action	See action.yml
Python	pip install bump-rs
Node.js	npm install bump2version

Note

Installing via cargo installs both bump and bump2version binaries. The original bump2version binary is retained indefinitely for backward compatibility with existing tutorials, CI/CD pipelines, and automation scripts.

🤔 What does this crate provide?

bump2version automates semantic version management for any project regardless of language. It:

• Parses version strings using a fully configurable regex (default: semver major.minor.patch).
• Bumps any named component (major, minor, patch, or custom cyclic stages like alpha → beta → rc → stable).
• Rewrites version occurrences across multiple files, including multiline CHANGELOG patterns.
• Commits and tags via 100% pure gix (gitoxide); zero subprocess calls.
• Detects version strings across any language's manifest files (Rust, Python, JS, Go, Java, Ruby).
• Watches for file changes and bumps automatically on save (one bump per save, with debounce).
• Bumps workspaces atomically across all Cargo workspace members.

💻 Command-line Interface

# Install
cargo install bump2version --features rust-binary

# Use directly
bump --bump patch          # 0.2.1 → 0.2.2
bump --bump minor          # 0.2.1 → 0.3.0
bump --bump major          # 0.2.1 → 1.0.0
bump --bump patch --dry-run  # preview only

# Use as cargo subcommand
cargo bump --bump patch
cargo bump --bump minor --dry-run

# Docker
docker run --rm -v $(pwd):/workspace wiseaidev/bump2version --bump patch --dry-run

# Multi-language auto-detect
bump --bump patch --detect

Option	Description
--config-file	Config file path (default: .bumpversion.toml)
--current-version	Override current version
--bump	Component: major, minor, patch, or any custom part
--parse	Parse regex override
--serialize	Serialize format override
--dry-run / -n	Simulate without writing files
--new-version	Explicit new version (skips bump calculation)
--commit / --tag	Git commit + lightweight tag

🔭 Features

Feature	Default	Description
std	✅	File I/O, git integration, regex stdlib cache
cli	❌	Standalone bump binary via clap
watch	❌	File-system watcher (bump on file save)
detect	❌	Multi-language manifest auto-detection
python	❌	Python extension module via PyO3/maturin
node	❌	Node.js native add-on via napi-rs

🦀 Rust

The Rust crate is available on crates.io. For a complete API reference visit RUST.md.

Quick Start

[dependencies]
bump2version = "0.2.2"

use bump2version::{config::BumpConfig, version::{BumpPart, parse_version, bump_version, serialize_version}};

fn main() {
    let cfg = BumpConfig::default();
    let v   = parse_version("1.2.3", &cfg).unwrap();
    let v2  = bump_version(&v, &BumpPart::Patch, &cfg).unwrap();
    println!("{}", serialize_version(&v2, &cfg)); // 1.2.4
}

no_std Support

Core modules (config, version, files, error) compile in no_std + alloc:

bump2version = { version = "0.2.2", default-features = false }

Module	no_std+alloc	std
config	✅	✅
version	✅	✅
files	✅	✅
error	✅	✅
git	❌	✅
CLI	❌	✅
Python / Node.js	❌	✅

🐍 Python

pip install bump-rs

from bump_rs import bump_version, apply_file_change, BumpConfig

print(bump_version("1.2.3", "patch"))   # "1.2.4"
print(bump_version("1.2.3", "minor"))   # "1.3.0"

cfg = BumpConfig(parse=r"(?P<major>\d+)\.(?P<minor>\d+)", serialize="{major}.{minor}")
print(bump_version("2.0", "minor", config=cfg))  # "2.1"

For full docs see PYTHON.md.

🟩 Node.js

npm install bump2version

const { bumpVersion, applyFileChange } = require("bump2version");
console.log(bumpVersion("1.2.3", "patch")); // '1.2.4'

For full docs see NODE.md.

⚙️ Configuration File (.bumpversion.toml)

[bumpversion]
current_version = "1.0.0"
commit = true
tag = true

[bumpversion:file:Cargo.toml]
search = name = "my-crate"
    version = "{current_version}"
replace = name = "my-crate"
    version = "{new_version}"

[bumpversion:file:CHANGELOG.md]
search = """
## {current_version}
    Release notes line 1"""
replace = """
## {new_version}
    Release notes line 1"""

Pre-release Cycling

[bumpversion]
current_version = "1.0.0-alpha.1"
parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)-(?P<stage>[a-z]+)\.(?P<devnum>\d+)
serialize =
    {major}.{minor}.{patch}-{stage}.{devnum}
    {major}.{minor}.{patch}

[bumpversion:part:stage]
optional_value = stable
first_value = alpha
values =
    alpha
    beta
    rc
    stable

Cargo Workspace Bumping

# Atomically bump all workspace member crates
bump --bump patch

The workspace module discovers all [workspace] members and bumps every Cargo.toml in one pass.

🔭 GitHub Action

The action is published as bump-rs on the GitHub Marketplace.

- name: bump-rs
  uses: wiseaidev/bump2version@v0.2.2
  with:
    release_type: patch # 'major', 'minor', or 'patch' - omit to auto-detect from git tags
    commit: "true"
    tag: "true"
    dry-run: "false"
    working-directory: "."
    config-file: ".bumpversion.toml"

Output	Description
new_version	The new version string after bumping
old_version	The previous version string before bumping
release_type	The component that was bumped (major/minor/patch)

🔒 Safety

This crate enforces #![forbid(unsafe_code)] at the crate root (except the Node.js FFI layer which requires unsafe for napi-rs interop). Every byte of the implementation: config parsing, regex matching, version bumping, git object creation, is written in safe Rust.

📊 Benchmarks

CLI vs CLI: bump vs bump-my-version (hyperfine)

Measured with hyperfine --runs 5 --warmup 2 -N on x86-64 Linux (target-cpu=native release build):

Scenario	Tool	Mean	Min	Max
patch bump	bump (Rust)	5.6 ms	2.6 ms	10.5 ms
minor bump	bump (Rust)	3.9 ms	2.8 ms	6.2 ms
major bump	bump (Rust)	2.5 ms	1.9 ms	3.2 ms
any bump	bump-my-version (Python)	482.3 ms	473.8 ms	488.0 ms

CLI speedup: ~90-200× faster depending on scenario (major bump is fastest: ~193×).

At the library function level (pure parse+bump+serialize, no process startup):

Benchmark	Rust (bump2version)	Python (bump-my-version)	Speedup
parse + bump + serialize	~13 µs	~79 µs	~6×
Config parse (minimal)	~12 µs	~4 800 µs	~400×
File replace, 10K lines	~14 ms	-	-
Full pipeline (CLI cold start)	2.4 ms	482 ms	~200×

Run the comparison yourself:

# Rust
hyperfine --runs 10 -N "bump --config-file .bumpversion.toml --bump patch --dry-run"

# Python (if installed)
hyperfine --runs 10 "bump-my-version bump patch --dry-run"

# Full comparative suite
chmod +x benchmarks/hyperfine/run_comparison.sh
./benchmarks/hyperfine/run_comparison.sh

Internal Benchmarks (cargo bench)

Run with cargo bench. Results on x86-64 Linux after optimization (LTO=fat, opt-level=3, target-cpu=native):

Benchmark	Time
config_parse/minimal	~12 µs
config_parse/full_with_parts	~18 µs
version_parse/1.0.0	~430 ns
version_bump/patch	~13 µs
version_bump/minor	~14 µs
version_bump/major	~6 µs
prerelease_bump/stage	~15 µs
file_replace/100 lines	~240 µs
file_replace/1 000 lines	~1.3 ms
file_replace/10 000 lines	~14 ms
file_replace/100 000 lines	~140 ms
worst_case/10 000 lines	~14 ms
multiline_replace/100x	~85 µs

📚 Further Reading

• CLI.md: Full CLI command dictionary
• RUST.md: Rust API guide
• PYTHON.md: Python bindings guide
• NODE.md: Node.js bindings guide
• DOCKER.md: Docker usage guide
• WASM.md: WebAssembly + Yew guide
• PACKAGING.md: Debian/RPM packaging
• examples/yew-app: Browser-side version bumper (Yew + WASM)
• Semantic Versioning 2.0.0
• bump-my-version: the Python tool this crate is feature-parity with
• gitoxide (gix): the pure-Rust git implementation

📄 License

Licensed under the MIT License.