Live streamJoin us for "State of code review 2024" on July 18thRegister today
Background gradient

Today, many modern software development teams are spread across different time zones, cultures, and technical expertise. As a result, creating, maintaining, and tracking changes to your codebase becomes a crucial part of any development process.

GitHub, of course, revolutionized repository management for many software teams.

Phabricator was spun out from the development team at Meta (Facebook). It introduced many teams to new ways to plan, track, and manage software development.

Graphite offers much of the same functionality as Phabricator, with the added benefit of direct integration with GitHub. No VCS switching required.

Which option is best for your team?

For the purposes of this review, we’ll consider three options:

  1. Graphite

  2. Vanilla GitHub

  3. Phabricator

Let’s look at GitHub’s functionality versus improvements introduced by Phabricator. And how using Graphite with GitHub can offer the benefits of both options.

First let’s take a look at how to set up Phabricator.

The good news: Phabricator is self-hosted.

The bad news: Phabricator is self-hosted.

Phabricator is a LAMP (Linux, Apache, MySQL, PHP) application that needs to be installed on a machine running Linux or some similar operating system. This means you’ll need some basic system admin skills, and also need to install a web server like Apache, a functional MySQL database, and a PHP installation.

Unfortunately, that’s just the start. The system itself is also quite complex.

As one HackerNews user put it, “There are a lot of moving parts, and the initial setup requires 60 different unique databases. It has a handful of background daemon-like processes that occasionally get wedged.”

Since Phabricator is no longer being actively maintained, you’ll have to fork your own copy of the repo and set it up yourself. There’s no official support.

GitHub and Graphite, on the other hand, are managed services, with reduced overhead and complexity.

Nevertheless, once they’re set up, both GitHub and Phabricator’s Diffusion have similar repository management functionality. Aside from the main difference—GitHub is cloud-hosted—both tools offer the main features you’d expect:

  • Version control system support

  • Branching and merging functionality

  • Access and permissions settings

  • Continuous integration and continuous deployment (CI/CD) integration

Graphite integrates directly on top of GitHub, and does not affect the repository hosting or setup aspects of GitHub.

Here, we start to see the differences emerge between these options.

GitHub (and, by extension, Graphite) uses the Git version control system (VCS) at its core.

Phabricator, on the other hand, can sit atop any of the three most popular version control systems: Git, Mercurial, or SVN (Subversion).

If you have a strong preference for something other than Git, Phabricator is a viable alternative to GitHub.

If you’re happy with using Git in either case, then the differences between using Graphite, vanilla GitHub, and Phabricator become more about their differences in supported workflows.

In GitHub, you can create an issue to communicate bugs, new feature requests, and security threats with your code collaborators. The tool also allows you to clone or fork a repository, work on it without affecting the original codebase, and create a pull request (PR) that notifies the codebase maintainers of proposed code changes. If the maintainers review the PR and accept the changes, GitHub ensures that the new changes get merged with the original codebase.

Traditionally, you might create a single feature branch that contains all of the code changes necessary to push a new feature.

Once you submit a pull request for the branch, it goes through code review and is ultimately merged back into main branch. While this process is happening, further development that depends on these code changes is delayed.

In other words, the GitHub workflow handles pull requests, commits, and merges serially. One at a time.

This creates problems for many teams:

This is one of the main things that Phabricator attempted to solve. Phabricator tackled this by introducing a different workflow known as stacking (AKA stacked pull requests, stacked diffs, or stacked changes).

Stacking is a workflow designed to unblock developers.

As Gergely Orosz explains:

“Stacking refers to breaking down a pull request (PR) for a feature into several, smaller PRs which all depend on each other – hence the term ‘stacked’. It might sound counterintuitive, but this workflow is incredibly efficient by making it easier to review and modify PRs – or ‘diffs’ as we called them at Uber.”

Instead of following the traditional pull request model, you can think of stacking like creating a separate branch for each pull request (Phabricator refers to a pull request as a “differential revision”). And instead of creating pull requests containing multiple commits, you can instead stack multiple, smaller PRs. This means fewer commits per pull request and easier code review.

Technically, you could follow this same workflow using vanilla GitHub, but it presents a few challenges that can make it difficult and messy:

  1. GitHub doesn’t offer a way to “stack” the PRs. They’re not linked in any kind of logical way that would allow you to easily track how and when they contain dependent commits (or the order in which they need to be merged).

  2. Upstream changes have to be handled manually. If you identify a bug or issue with a previous PR, you have to manually apply those code changes to any downstream PRs with git rebase.

In other words: technically, it’s doable. Realistically, it’s not a fun workflow.

Cue: Graphite.

Graphite is built to facilitate the stacking workflow for GitHub users. This means that both the web app and CLI offer features to stack PRs, manage a series of PRs, and perform automatic rebasing upon any changes.

So, if you want the benefits of the Phabricator workflow and stacked PRs, you can simply use Graphite on top of GitHub to get the best of both solutions.

The benefit here is that you can ship faster, and code reviews become significantly easier without sacrificing the creature comforts of GitHub and making the leap to Phabricator.

GitHub, Phabricator, and Graphite all offer their own code review tools.

In the case of GitHub, code review follows a familiar workflow. Once a pull request is created, reviewers can be assigned. The pull request will enter the queue. After the code review takes place, there may be multiple rounds of feedback and comments. Ultimately, the pull request is finalized and then merged into main.

The Phabricator review workflow is quite similar to the GitHub PR workflow. An author changes the code and requests a review from specific reviewers. Reviewers then get notified, inspect changes, and either accept them or propose further changes. Once all the reviewer conditions are satisfied, the code gets merged upstream to the central codebase.

One key difference is that Phabricator and Graphite make code reviews non-blocking for developers.

The stacked PR workflow also makes code reviews smaller and faster.

There’s generally just one commit per pull request. More reasonably sized PRs mean that code reviewers can more easily and reliably identify issues with commits and easily understand the changes being introduced before approving and merging.

Graphite provides a similar experience to Phabricator, while also introducing some quality-of-life improvements over both vanilla GitHub reviews and Phabricator reviews.

The pull request inbox offers review workflow organization changes that make it simpler to manage and keep track of reviews in progress. Review messages, comments, and feedback appear in a simple interface, organized by necessary action.

This simple interface makes it easy to leave and respond to lots of review comments and quickly see what actions need to be taken. You can create comment threads directly in the context of the pull request. Plus, you can attach files or add memes, macros, and emojis.

Overall, this makes the user experience better for both leaving and resolving code review feedback efficiently.

Both GitHub and Phabcricator offer their own features for issue and bug tracking, task and project management, and other collaboration tools.

GitHub Issues lets you organize project tracking in board, roadmap, and table views. It also offers features to:

  • Break issues into child tasks.

  • Track relationships between issues and tasks.

  • Use customizable fields to organize tasks in alignment with your workflow.

  • Create conversations around each task or issue.

Phabricator’s task management tool is called Maniphest. It’s built around Kanban workboards.

Similar to GitHub’s issue tracking, you can assign parent and child relationships as well as save custom views and searches.

The interface is simple. Perhaps a bit dated at this point, but it gets the job done.

If you’re looking for a radically different workflow for handling bugs, issues, or projects, you can customize further with Phabricactor. Since it’s open source, you’re free to roll your own system to align with your team’s preferred processes. Of course, that costs time and money.

Phabricator is free to install on your local machine. But in terms of lifetime maintenance costs, this may cost you more than both GitHub and Graphite's enterprise plans.

Qt Group did some napkin math on the lifetime cost to deploy and maintain open-source software. They came out at about $135,000.

Now, of course, your cost to operate Phabricator may vary.

But, there’s no doubt that there will be reasonable costs associated with setting up the self-hosted environment and infrastructure. Then you’ll need engineer time to maintain, debug, and ship one-off patches.

On top of that, because this isn’t an actively maintained project, there’s no official support and a waning base of community support available on the web.

How does that compare to the subscription models offered by GitHub and Graphite?

GitHub offers a forever free account along with team and enterprise tiers that are priced on a per-user basis. The free plan offers 2,000 CI/CD minutes along with 500 MB of storage every month for your private repositories. There are no CI/CD or storage limits for your public repositories.

The GitHub team plan at $4 per user a month offers 3,000 CI/CD minutes and 2 GB of storage every month for your private repositories. This plan comes with automated code request review workflows and enables multiple reviewers for a PR. The enterprise plan at $21 per user per month offers 5,000 CI/CD minutes per month and 2 GB of storage for your private repositories. This plan comes with premium support, annual SOC2 reports, and SAML SSO.

Graphite also offers a forever free plan that can be used for up to 3 searchable GitHub repositories and 3 months of searchable PR history. The Graphite team plan offers 30 searchable GitHub repositories and 24 months of searchable PR history. This team plan also comes with detailed insights that identify bottlenecks and an option to merge queue that automatically rebase to eliminate merge conflicts.

GitHub is the leading repository management tool by far, with over 100 million developers using the platform. However, many open-source enthusiasts and the engineering team at Meta still swear by Phabricator’s code review workflows.

So which one’s right for your team?

Are you looking for the easiest possible solution?

Vanilla GitHub checks most of the boxes in terms of traditional functionality.

Do you want a fully customizable experience and have lots of time or money to throw at deploying and maintaining an open-source solution?

Phabricator offers some major upgrades to the overall developer experience and workflow. This is a reasonable solution for hardcore shops, but probably not feasible for most casual users.

Do you want the best of both worlds?

Graphite offers the innovations and modern workflows offered by Phabricator—but without having to actually manage your own repo hosting system.

Graphite improves upon GitHub to help unblock your team, ship codes faster, and improve code reviews. But you don’t have to spend eons tinkering with your own setup to make it work.

Teams choose to use Graphite + GitHub because:

  • Developer productivity improves by using the stacked PR workflow.

  • Code quality improves because you incentivize developers to create small and specific PRs that are easy to review for bugs, contextual errors, and low-quality code.

  • Cost advantages accrue because you don’t have to spend on hardware, security, or upgrades for an open-source project like Phabricator.

This is why some of the world’s top-performing engineering teams choose to add Graphite to GitHub and unlock the benefits of stacking with the simplicity of familiar code management.

Want to see how it works?

Sign up with your GitHub account and sign up for a free Graphite plan.

Give your PR workflow
an upgrade today

Stack easier | Ship smaller | Review quicker

Or install our CLI.
Product Screenshot 1
Product Screenshot 2