Gerrit vs. Phabricator: Key Differences

In collaborative software development, code review is one of the most crucial steps in maintaining code quality. Two popular tools that serve this need are Gerrit and Phabricator—both open-source, yet fundamentally different in how they approach code reviews and project management. Gerrit is known for its strict, pre-submit workflow, which enforces rigorous checks before integrating changes. Phabricator, meanwhile, offers a broader set of tools, combining code reviews with task tracking, wikis, and more, all in a single platform. Whether you’re working at enterprise scale or seeking an all-in-one development environment, understanding the nuances between these systems is key to selecting the right fit for your team. Below, we dive into their workflows, feature sets, community support, and more.

Overview

Gerrit

• What it is: Gerrit is a web-based code review tool that integrates closely with Git. Originally developed at Google and later open-sourced, it was designed to streamline patch-based reviews.
• Key use cases: Primarily used for reviewing and approving changes to Git repositories before merging into the main branch.
• Philosophy: Gerrit encourages a “pre-submit” review workflow, where code changes are reviewed prior to merging them into the central repository.

Phabricator

• What it is: Phabricator is an open-source suite of tools developed by Phacility (initially built at Facebook). It contains a code review application (Differential), along with applications for task management (Maniphest), wikis (Phriction), and more.
• Key use cases: Phabricator is a broader platform, offering an all-in-one approach for software development: code review, project management, bug tracking, and wiki/documentation.
• Philosophy: Phabricator encourages a more holistic approach to development projects with integrated tooling, while still facilitating both pre- and post-submit reviews.

Code review workflow

Gerrit’s workflow

1. Push changes: Developers push changes to Gerrit rather than directly to the Git repository’s main branch.
2. Automatic change creation: Gerrit automatically creates a “change” (review entry) for each set of commits.
3. Review process: Reviewers inspect the change, leave comments, and vote on whether it should be merged.
4. Continuous integration: Gerrit typically integrates with CI systems. Builds and tests may run automatically.
5. Approval and merge: Once the change is fully approved, it gets merged into the main branch.

Pros

• Strict pre-merge review ensures code quality.
• Patch-based approach (each commit is atomic, tracked as a separate “change”).
• Highly scalable and used by large projects (e.g., Android Open Source Project).

Cons

• Steep learning curve for Git newcomers.
• Some developers find the UI less intuitive compared to modern code review systems.

Phabricator’s workflow (Differential)

1. Create a revision: Developers either push commits to a hosted repository or upload diffs manually.
2. Reviewers add feedback: Reviewers comment line-by-line and provide feedback.
3. Updates and revisions: Developers address feedback, update the revision, and re-request review.
4. Land commit: Once approved, the developer (or a designated service) merges it into the main branch.

Pros

• Flexible workflows for pre-merge, post-merge, or patch-based reviews.
• Comprehensive platform with task tracking (Maniphest), wikis (Phriction), and more.
• Generally considered more user-friendly.

Cons

• Complex setup, given the many integrated applications.
• Official support from Phacility ended, though an open-source community continues to maintain it.

Feature set

Gerrit

• Primary feature: code review Gerrit’s main focus is facilitating code review and gating merges based on approvals.
• Change sets and patch sets Each change in Gerrit can have multiple “patch sets” (i.e., iterations).
• Continuous integration hooks Pluggable hooks integrate with popular CI/CD systems like Jenkins.
• Access control Fine-grained permissions control who can view, review, and submit.
• Project dashboard Basic dashboards display open changes, reviewer assignments, and statuses.

Phabricator

• Differential (code review) Similar to Gerrit’s patch review but with more features for revision management.
• Maniphest (task tracking) A robust issue/bug/task tracker tied closely to code reviews and commits.
• Phabricator Projects Lightweight project management with tags, workboards, and sub-projects.
• Phriction (wiki) A built-in wiki system for internal documentation.
• Herald (automations) A rules-based engine to automate tasks (e.g., auto-assign reviewers based on file paths).
• Audit Phabricator’s optional post-commit review system.

Usability and user experience

• Gerrit UI/UX

  • Minimalist and purpose-built for review flows.
  • Some find it less intuitive if they’re used to GitHub or GitLab.
  • Emphasizes patch sets, diffs, and reviewer comments.

• Phabricator UI/UX

  • Modern design in Differential, with robust code review features.
  • Navigating between multiple applications (Differential, Maniphest, etc.) can be a learning curve.
  • Offers customizable dashboards for tasks, reviews, and other items.

5. Scalability and performance

• Gerrit

  • Well-known for scaling effectively on large codebases (e.g., Android Open Source Project).
  • Patch-based design helps keep repositories clean and atomic.
  • Widely adopted by enterprise teams.

• Phabricator

  • Can handle large installations but requires more resources due to the number of integrated applications.
  • System tuning (database config, caching, etc.) may be necessary for huge deployments.
  • Offers clustering options for repositories and databases.

6. Integrations and ecosystem

Gerrit integrations

• Git: Gerrit is inherently designed for Git repositories.
• CI/CD: Integrates with Jenkins, Zuul, and other CI systems via REST API or event streams.
• Plugins: Gerrit has a plugin architecture (e.g., replication, analytics).
• Community: Active but more specialized, with a strong enterprise presence.

Phabricator integrations

• Version control systems: Supports Git, SVN, and Mercurial.
• CI tools: Via webhooks and the Harbormaster system, can trigger builds or receive statuses.
• Slack/Team chat: Various third-party integrations or the Conduit API.
• Community: Broad open-source community, though Phacility no longer provides official support.

Installation and administration

Gerrit

• Deployment: Typically self-hosted on-prem or in the cloud (requires Java, a servlet container, and Git).
• Configuration: Involves editing configuration files (gerrit.config) and setting up authentication (LDAP, OAuth, etc.).
• Maintenance: Upgrades are straightforward but need admin knowledge.
• Documentation: Official site covers setup, plugins, and advanced configurations.

Phabricator

• Deployment: Typically self-hosted, using a LAMP stack or similar (PHP, MySQL/MariaDB, Apache/Nginx).
• Configuration: Web-based config for many settings, plus command-line tools (bin/config).
• Maintenance: Administrators manage multiple apps from a single installation; updates are community-maintained.
• Documentation: Available through archived Phabricator sites or community forks.

8. Security and permissions

Gerrit

• Granular permissions: Control who can read, push, or submit code.
• Group-based access: Assign permissions at the repository or branch level.
• Built-in authentication: Local user accounts or integration with LDAP, OAuth (Google), or SAML.

Phabricator

• Application policies: Each application (Differential, Maniphest, etc.) can have separate permissions.
• Granular object-level access: Set view/edit policies on tasks, code reviews, wiki pages, etc.
• Authentication: Supports LDAP, OAuth, Duo 2FA, and more. Policies are set via the web UI.

Community and support

• Gerrit

  • Active developer community via mailing lists, GitHub, and Gerrit’s own instance.
  • Widely used by large organizations, with various enterprise support options.

• Phabricator

  • Phacility (the original company) shut down in 2021, but the project remains open source.
  • Community forks (often referred to as “Phorge”) continue development.
  • Official support no longer exists, but community-based support is available.

When to choose Gerrit vs. Phabricator

Choose Gerrit if:

1. You need a strict gating system: Gerrit enforces mandatory code reviews before merges.
2. You work with large repositories and teams: Gerrit excels at scale, handling continuous streams of patch sets.
3. Your need is primarily code review: If you already have other project management tools, Gerrit’s focus on the review process is ideal.

Choose Phabricator if:

1. You want an all-in-one platform: Phabricator offers an integrated set of tools for code review, tasks, wikis, etc.
2. You need flexibility: Supports Git, SVN, and Mercurial, and can do pre- or post-merge reviews.
3. You desire powerful customization: Herald rules, detailed permissions, and multiple applications let you adapt to many workflows.

Summary

Gerrit is a specialized code review solution that enforces a highly controlled, pre-submit workflow. It’s ideal for teams that want a formal, rigorous approach and need to handle large-scale projects.

Phabricator, on the other hand, provides a more comprehensive platform, combining code review with task tracking, wikis, and more. This makes it especially attractive for smaller or medium-sized teams that want a single environment for all their development needs.

However, while Gerrit remains actively developed (particularly for enterprise), Phabricator’s official support ended when Phacility shut down. The open-source community continues to maintain Phabricator (via forks like Phorge), so the main consideration is whether your organization is comfortable relying on community support.