About This Project

git-flow-next is a modern reimplementation of the popular git-flow branching model. Developed in Go, it prioritizes reliability, extensibility, and an improved developer experience.

Our Motivation

This project is proudly maintained by the team behind Tower, one of the most popular Git clients for Mac and Windows. Having integrated git-flow into Tower over many years, we’ve gained deep insights into its strengths and areas for improvement.

As developers of version control tools, we’re passionate about creating better developer experiences. While the original git-flow has served the community well, we saw an opportunity to build a more modern implementation that:

Is written in Go for better maintainability and performance.
Provides a more robust and reliable experience.
Offers better error handling and conflict resolution.
Supports modern Git workflows and practices.
Maintains compatibility with existing git-flow setups.

Our goal is to contribute back to the developer community with tools that make version control workflows more efficient and enjoyable.

Core Features

git-flow-next builds upon the solid foundation of the git-flow model with a focus on modern development needs. Here’s a deeper look at the key features that set it apart:

1. A Modern Reimplementation in Go

At its core, git-flow-next is a ground-up reimplementation in Go. This choice offers significant advantages in terms of reliability and long-term maintainability. Go’s concurrency model and strong typing contribute to a more stable and predictable tool, while its efficient compilation and execution lead to improved performance.

This modern foundation ensures that git-flow-next can adapt and evolve with the ever-changing landscape of Git and software development.

2. Improved Conflict Resolution: Navigating Merges with Confidence

Merge conflicts are an inevitable part of collaborative development. git-flow-next aims to mitigate the pain points associated with them by providing better handling of merge conflicts and edge cases.

While the underlying Git merge process remains the same, git-flow-next offers more intelligent strategies and clearer guidance during the resolution process.

This focus on robustness helps teams navigate complex merges with greater confidence and reduced friction.

3. Flexible Configuration: Tailor Your Workflow

Recognizing that development teams have diverse needs, git-flow-next offers flexible configuration options.

This includes the ability to customize branch naming conventions to align with your team’s preferences and existing infrastructure. Furthermore, it provides control over merge strategies, allowing you to fine-tune how branches are integrated based on your project’s specific requirements.

This adaptability ensures that git-flow-next can seamlessly integrate into a wide range of development workflows.

4. Compatibility: Embrace the Future Without Abandoning the Past

Adopting new tools shouldn’t require a complete overhaul of existing infrastructure. git-flow-next is designed to be fully compatible with existing git-flow repositories.

This means you can seamlessly transition to git-flow-next without needing to re-initialize your repositories or disrupt your team’s established workflows. This backward compatibility ensures a smooth adoption process and allows teams to leverage the benefits of git-flow-next incrementally.

5. Enhanced Error Handling: Clarity and Guidance When You Need It Most

git-flow-next prioritizes a smooth developer experience by providing clear and informative error messages. When issues arise, the tool offers actionable guidance and potential solutions for recovery.

6. Performance Optimized

Built with performance in mind, git-flow-next delivers fast and efficient operations. The choice of Go as the underlying language contributes significantly to its speed and resource efficiency.

Whether you’re initializing a repository, merging branches, or releasing a new version, git-flow-next is designed to provide a responsive and efficient experience, minimizing wait times and maximizing developer productivity.