Convert Figma logo to code with AI

gitbutlerapp logogitbutler

The GitButler version control client, backed by Git, powered by Tauri/Rust/Svelte

12,394
487
12,394
273

Top Related Projects

50,268

simple terminal UI for git commands

18,189

Blazing 💥 fast terminal-ui for git written in rust 🦀

36,623

GitHub’s official command line tool

6,523

It's Magit! A Git Porcelain inside Emacs.

40,493

A cross-platform, customizable science fiction terminal emulator with advanced monitoring & touchscreen support.

manage your git repositories in one place

Quick Overview

GitButler is an innovative Git client designed to enhance the version control workflow for developers. It offers a unique approach to managing branches and commits, aiming to streamline the development process and improve collaboration among team members.

Pros

  • Intuitive user interface that simplifies complex Git operations
  • Advanced branch management features for better organization of work
  • Seamless integration with popular Git hosting platforms
  • Real-time collaboration tools for improved team productivity

Cons

  • Learning curve for users accustomed to traditional Git clients
  • Limited customization options compared to some established Git tools
  • Potential performance issues with very large repositories
  • Relatively new project, which may lead to occasional stability concerns

Getting Started

To get started with GitButler:

  1. Visit the official GitButler website: https://gitbutler.com
  2. Download the appropriate version for your operating system (Windows, macOS, or Linux)
  3. Install the application following the on-screen instructions
  4. Launch GitButler and sign in with your preferred Git hosting account (GitHub, GitLab, or Bitbucket)
  5. Clone or open an existing repository to begin using GitButler's features

Note: As GitButler is primarily a GUI application and not a code library, there are no code examples or quick start code snippets to provide.

Competitor Comparisons

50,268

simple terminal UI for git commands

Pros of Lazygit

  • Terminal-based interface, lightweight and fast
  • Extensive keyboard shortcuts for efficient Git operations
  • Cross-platform compatibility (Linux, macOS, Windows)

Cons of Lazygit

  • Steeper learning curve for users unfamiliar with terminal interfaces
  • Limited visual representation compared to GUI-based tools
  • Requires manual installation and configuration

Code Comparison

Lazygit (Go):

func (gui *Gui) handleCommitConfirm(g *gocui.Gui, v *gocui.View) error {
    message := gui.trimmedContent(v)
    if message == "" {
        return gui.createErrorPanel(gui.Tr.NoCommitMessageErr)
    }
    return gui.handleCommitSubmit(message)
}

GitButler (Rust):

pub fn commit(&self, message: &str) -> Result<(), GitError> {
    let signature = self.signature()?;
    let tree_id = self.repo.index()?.write_tree()?;
    let tree = self.repo.find_tree(tree_id)?;
    self.repo.commit(Some("HEAD"), &signature, &signature, message, &tree, &[])?;
    Ok(())
}

GitButler is a desktop application for Git workflow management, while Lazygit is a terminal-based Git interface. GitButler offers a more visual approach with branch management features, while Lazygit provides a lightweight, keyboard-driven experience for Git operations directly in the terminal.

18,189

Blazing 💥 fast terminal-ui for git written in rust 🦀

Pros of GitUI

  • Lightweight and fast terminal-based interface
  • Cross-platform support (Linux, macOS, Windows)
  • Customizable key bindings and color schemes

Cons of GitUI

  • Limited to command-line interface, may not be suitable for users who prefer GUI
  • Fewer advanced features compared to GitButler
  • Steeper learning curve for Git beginners

Code Comparison

GitUI (Rust):

fn main() -> Result<()> {
    let mut app = App::default();
    let events = Events::new(Duration::from_millis(TICK_RATE));
    loop {
        app.draw()?;
        // ... (event handling)
    }
}

GitButler (TypeScript):

const app = new App();
app.on('ready', () => {
  createWindow();
});
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});

GitUI is a terminal-based Git interface written in Rust, focusing on speed and efficiency. It provides a lightweight alternative to GUI-based Git clients. GitButler, on the other hand, is a more feature-rich Git client with a graphical interface, offering advanced functionalities like branch management and conflict resolution. While GitUI excels in performance and simplicity, GitButler provides a more user-friendly experience with additional features for complex Git workflows.

36,623

GitHub’s official command line tool

Pros of cli

  • Officially maintained by GitHub, ensuring high reliability and integration
  • Extensive documentation and community support
  • Broader feature set covering most GitHub operations

Cons of cli

  • Steeper learning curve due to more complex command structure
  • Focused solely on GitHub, limiting use with other Git platforms
  • Larger installation size and resource footprint

Code Comparison

cli:

gh repo create my-project --public --clone
gh issue create --title "Bug report" --body "Description"
gh pr create --title "New feature" --body "Details"

GitButler:

gb branch create feature-branch
gb commit -m "Add new feature"
gb push

Key Differences

GitButler focuses on streamlining Git workflows with a simpler interface, while cli provides comprehensive GitHub functionality. GitButler aims to enhance local Git operations, whereas cli is designed for full GitHub integration.

GitButler offers a visual interface for managing branches and commits, which may be more intuitive for some users. cli, on the other hand, provides a powerful command-line tool for interacting with all aspects of GitHub repositories.

While both tools aim to improve developer productivity, they target different aspects of the Git and GitHub ecosystem. GitButler emphasizes local Git management, while cli excels in GitHub-specific tasks and automation.

6,523

It's Magit! A Git Porcelain inside Emacs.

Pros of Magit

  • Deeply integrated with Emacs, providing a powerful and customizable Git interface
  • Extensive documentation and large, active community support
  • Supports advanced Git operations and workflows directly from Emacs

Cons of Magit

  • Steep learning curve for users not familiar with Emacs
  • Limited visual representation of Git history compared to GUI tools
  • Requires Emacs, which may not be suitable for all developers or environments

Code Comparison

Magit (Emacs Lisp):

(magit-status)
(magit-stage-file "file.txt")
(magit-commit-create)

GitButler (JavaScript/TypeScript):

// No direct code comparison available as GitButler is a GUI application
// and doesn't expose a public API for programmatic interaction

Additional Notes

GitButler is a visual Git client focused on branch management and workflow optimization, while Magit is a text-based interface integrated into Emacs. GitButler offers a more intuitive experience for users who prefer graphical interfaces, while Magit provides deep integration and powerful features for Emacs users comfortable with text-based environments.

40,493

A cross-platform, customizable science fiction terminal emulator with advanced monitoring & touchscreen support.

Pros of eDEX-UI

  • Visually stunning and immersive sci-fi inspired interface
  • Includes system monitoring features and file browser
  • Cross-platform support (Windows, macOS, Linux)

Cons of eDEX-UI

  • Primarily focused on aesthetics rather than Git-specific functionality
  • May consume more system resources due to its graphical nature
  • Less suited for professional Git workflow management

Code Comparison

eDEX-UI (JavaScript):

class Clock extends Component {
  constructor(props) {
    super(props);
    this.state = {
      date: new Date()
    };
  }
}

GitButler (Rust):

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Commit {
    pub id: String,
    pub summary: String,
    pub message: String,
    pub author: String,
}

Summary

GitButler is a Git client focused on improving workflow and branch management, while eDEX-UI is a futuristic terminal emulator with system monitoring capabilities. GitButler is more practical for Git-specific tasks, whereas eDEX-UI offers a unique, visually appealing interface for general terminal use and system monitoring. The code snippets highlight their different focuses: eDEX-UI uses JavaScript for UI components, while GitButler employs Rust for efficient data structures related to Git operations.

manage your git repositories in one place

Pros of gitbatch

  • Command-line interface for managing multiple Git repositories simultaneously
  • Lightweight and fast, with minimal dependencies
  • Supports custom commands and hooks for advanced workflows

Cons of gitbatch

  • Limited graphical user interface compared to GitButler
  • Lacks advanced branching and version control features
  • May require more technical knowledge to use effectively

Code comparison

GitButler:

import { Branch } from './branch';

export class Repository {
  branches: Branch[];
  // ...
}

gitbatch:

type Repository struct {
    Name     string
    Path     string
    Branches []string
    // ...
}

GitButler is a desktop application focused on streamlining Git workflows with a user-friendly interface and advanced branching features. It aims to simplify complex version control tasks and improve collaboration.

gitbatch, on the other hand, is a command-line tool designed for managing multiple Git repositories efficiently. It provides a lightweight solution for developers who prefer terminal-based workflows and need to perform batch operations across multiple projects.

While GitButler offers a more comprehensive and visually appealing approach to Git management, gitbatch excels in its simplicity and speed for handling multiple repositories simultaneously. The choice between the two depends on individual preferences and specific project requirements.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

GitButler

Git branch management tool, built from the ground up for modern workflows
gitbutler.com »

Download for macOS (Apple Silicon | Intel) · Linux (AppImage | deb) · Windows (msi)

(Unstable Nightly releases can be found here)


gitbutler_client

CI BADGE TWEET DISCORD INSTA YOUTUBE

Alt

GitButler is a git client that lets you work on multiple branches at the same time. It allows you to quickly organize file changes into separate branches while still having them applied to your working directory. You can then push branches individually to your remote, or directly create pull requests.

In a nutshell, it's a more flexible version of git add -p and git rebase -i, allowing you to efficiently multitask across branches.

How Does It Work?

GitButler keeps track of uncommitted changes in a layer on top of Git. Changes to files or parts of files can be grouped into what we call virtual branches. Whenever you are happy with the contents of a virtual branch, you can push it to a remote. GitButler makes sure that the state of other virtual branches is kept separate.

How Do GB's Virtual Branches Differ From Git Branches?

The branches that we know and love in Git are separate universes, and switching between them is a full context switch. GitButler allows you to work with multiple branches in parallel in the same working directory. This effectively means having the content of multiple branches available at the same time.

GitButler is aware of changes before they are committed. This allows it to keep a record of which virtual branch each individual diff belongs to. Effectively, this means that you can separate out individual branches with their content at any time to push them to a remote or to unapply them from your working directory.

And finally, while in Git it is preferable that you create your desired branch ahead of time, using GitButler you can move changes between virtual branches at any point during development.

Why GitButler?

We love Git. Our own @schacon has even published the Pro Git book. At the same time, Git's user interface hasn't been fundamentally changed for 15 years. While it was written for Linux kernel devs sending patches to each other over mailing lists, most developers today have different workflows and needs.

Instead of trying to fit the semantics of the Git CLI into a graphical interface, we are starting with the developer workflow and mapping it back to Git.

Tech

GitButler is a Tauri-based application. Its UI is written in Svelte using TypeScript and its backend is written in Rust.

Main Features

  • Virtual Branches
    • Organize work on multiple branches simultaneously, rather than constantly switching branches
    • Automatically create new branches when needed
  • Easy Commit Management
    • Undo, Amend and Squash commits by dragging and dropping
  • Undo Timeline
    • Logs all operations and changes and allows you to easily undo or revert any operation
  • GitHub Integration
    • Authenticate to GitHub to open Pull Requests, list branches and statuses and more
  • Easy SSH Key Management
    • GitButler can generate an SSH key to upload to GitHub automatically
  • AI Tooling
    • Automatically write commit messages based on your work in progress
    • Automatically create descriptive branch names
  • Commit Signing
    • Easy commit signing with GPG or SSH

Example Uses

Fixing a Bug While Working on a Feature

Say that while developing a feature, you encounter a bug that you wish to fix. It's often desirable that you ship the fix as a separate contribution (Pull request).

Using Git you can stash your changes and switch to another branch, where you can commit, and push your fix.

With GitButler you simply assign your fix to a separate virtual branch, which you can individually push (or directly create a PR). An additional benefit is that you can retain the fix in your working directory while waiting for CI and/or code review.

Trying Someone Else's Branch Together With My Work in Progress

Say you want to test a branch from someone else for the purpose of code review.

Using Git trying out someone else's branch is a full context switch away from your own work. With GitButler you can apply and unapply (add / remove) any remote branch directly into your working directory.

Documentation

You can find our end user documentation at: https://docs.gitbutler.com

Bugs and Feature Requests

If you have a bug or feature request, feel free to open an issue, or join our Discord server.

AI Commit Message Generation

Commit message generation is an opt-in feature. You can enable it while adding your repository for the first time or later in the project settings.

Currently, GitButler uses OpenAI's API for diff summarization, which means that if enabled, code diffs would be sent to OpenAI's servers.

Our goal is to make this feature more modular such that in the future you can modify the prompt as well as plug a different LLM endpoints (including local ones).

Contributing

So you want to help out? Please check out the CONTRIBUTING.md document.

If you want to skip right to getting the code to actually compile, take a look at the DEVELOPMENT.md file.

Want to show your support? Add a GitButler badge to your project's README:

[![GitButler](https://img.shields.io/badge/GitButler-%23B9F4F2?logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMzkiIGhlaWdodD0iMjgiIHZpZXdCb3g9IjAgMCAzOSAyOCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTI1LjIxNDUgMTIuMTk5N0wyLjg3MTA3IDEuMzg5MTJDMS41NDI5NSAwLjc0NjUzMiAwIDEuNzE0MDYgMCAzLjE4OTQ3VjI0LjgxMDVDMCAyNi4yODU5IDEuNTQyOTUgMjcuMjUzNSAyLjg3MTA3IDI2LjYxMDlMMjUuMjE0NSAxNS44MDAzQzI2LjcxOTcgMTUuMDcyMSAyNi43MTk3IDEyLjkyNzkgMjUuMjE0NSAxMi4xOTk3WiIgZmlsbD0iYmxhY2siLz4KPHBhdGggZD0iTTEzLjc4NTUgMTIuMTk5N0wzNi4xMjg5IDEuMzg5MTJDMzcuNDU3MSAwLjc0NjUzMiAzOSAxLjcxNDA2IDM5IDMuMTg5NDdWMjQuODEwNUMzOSAyNi4yODU5IDM3LjQ1NzEgMjcuMjUzNSAzNi4xMjg5IDI2LjYxMDlMMTMuNzg1NSAxNS44MDAzQzEyLjI4MDMgMTUuMDcyMSAxMi4yODAzIDEyLjkyNzkgMTMuNzg1NSAxMi4xOTk3WiIgZmlsbD0idXJsKCNwYWludDBfcmFkaWFsXzMxMF8xMjkpIi8%2BCjxkZWZzPgo8cmFkaWFsR3JhZGllbnQgaWQ9InBhaW50MF9yYWRpYWxfMzEwXzEyOSIgY3g9IjAiIGN5PSIwIiByPSIxIiBncmFkaWVudFVuaXRzPSJ1c2VyU3BhY2VPblVzZSIgZ3JhZGllbnRUcmFuc2Zvcm09InRyYW5zbGF0ZSgxNi41NzAxIDE0KSBzY2FsZSgxOS44NjQxIDE5LjgzODMpIj4KPHN0b3Agb2Zmc2V0PSIwLjMwMTA1NiIgc3RvcC1vcGFjaXR5PSIwIi8%2BCjxzdG9wIG9mZnNldD0iMSIvPgo8L3JhZGlhbEdyYWRpZW50Pgo8L2RlZnM%2BCjwvc3ZnPgo%3D)](https://gitbutler.com/)

BADGE