Differential: Phabricator’s Code Review Application

Differential is an extensible code review application originally developed as part of the Phabricator suite. It provided structured workflows, inline commenting, and policy-driven review processes that helped teams collaborate effectively. However, with Phabricator no longer actively maintained, Differential has become outdated, lacking support for modern integrations and developer workflows.

In this guide, we'll take a look at how Differential has been traditionally used for code reviews, as well as explore some modern tooling like Graphite, which builds on Differential’s approach to stacked diffs

Core concepts

1. Revisions: At the heart of Differential is the concept of a revision, which represents a single proposed change or a set of related changes. A revision includes:

   • Diffs: The actual code changes, highlighted and contextualized.
   • Summary & test plan: A textual description of what the change does and how it has been tested.
   • Reviewers & subscribers: A list of engineers and stakeholders responsible for reviewing or interested in the code.

   By structuring proposed changes in this formal manner, Differential ensures that reviewers receive the necessary context to evaluate code effectively.

2. Inline and contextual comments: Differential’s review UI allows reviewers to leave inline comments directly on specific lines of code, reducing ambiguity and promoting detailed, line-by-line discussions. This makes it easier for authors and reviewers to track feedback, request clarifications, and identify exactly what needs refinement. Discussions can be easily revisited and serve as an audit trail of the decision-making process.

3. Workflow integration and automation: Differential integrates smoothly with other Phabricator tools (such as Herald for automated rules and Harbormaster for continuous integration), as well as external services. For example, you can configure:

   • Automatic linting and unit tests: Trigger external builds or tests when a revision is updated.
   • Herald rules: Automatically add reviewers, block changes that don’t meet certain criteria, or require specific approvals based on project-specific policies.

   These integrations help ensure that code must pass certain quality gates before it can be landed, thereby reducing defects and regressions.

4. Review states and actionable statuses: Each revision in Differential progresses through well-defined states, such as “Needs Review,” “Accepted,” and “Needs Revision.” Authors and reviewers can take standard actions—like “Request Changes” or “Accept”—to signal whether the code meets the required standards or must be improved. This clear workflow ensures everyone understands where a proposed change stands at any given time.

Collaboration and configuration

• Flexible permissions and policies: Differential respects Phabricator’s robust policy system, allowing administrators to fine-tune who can create revisions, who can act as a reviewer, and who can land changes. This ensures that code review processes scale across large organizations and multiple teams while maintaining appropriate governance.

• Custom fields and metadata: Teams can configure custom fields in Differential to capture additional metadata—such as related tasks, priority, severity, or component area. Such fields can be used by automation, reporting, or to enforce unique internal engineering guidelines.

Example workflow in Differential

Consider a scenario where a developer, Alice, wants to add a new feature to an internal microservice:

1. Authoring a revision: Alice creates a new feature branch in Git, implements her changes, and uses the arc diff command (part of Phabricator’s command-line tool Arcanist) to upload her work to Differential. The code is encapsulated as a revision, complete with a summary and test plan.

2. Assigning reviewers and policies: Phabricator’s Herald rules automatically assign the backend team as reviewers based on the service directory the changes affect. Additional subscribers (such as a lead architect) are also added, as per organizational rules.

3. Performing the review: Bob, a backend engineer, opens the revision in Differential. He leaves inline comments suggesting improvements to the error-handling logic. Carol, a QA engineer, runs the automated tests and verifies that the changes pass all checks before leaving a comment noting that tests passed successfully.

4. Accepting and landing changes: After Alice addresses Bob’s feedback and updates the revision, Bob “Accepts” the change. Alice then uses arc land to merge the revision, at which point Differential updates the revision’s status to indicate that it has been closed and successfully integrated.

Comparing Differential with Graphite: A modern code review alternative

With Phabricator no longer actively maintained, Differential is now outdated, lacking modern integrations and UI improvements. Many engineering teams are considering Graphite, a modern alternative that enhances Differential’s stacked diffs concept while offering seamless GitHub integration and automation tools.

Here's what Graphite offers:

• GitHub integration: Works natively with GitHub, syncing PRs and branches seamlessly while allowing incremental adoption.
• Stacked pull requests: Graphite enables stacked PRs for better organization, faster reviews, and fewer merge conflicts.
• Better DevEx: Graphite boasts a modern UI, PR inbox for managing reviews, and built-in analytics for workflow optimization.
• Powerful CLI & automation: The Graphite CLI simplifies Git workflows, making stacking, rebasing, and merging effortless.
• AI-powered code reviews with Diamond: Graphite’s AI tool Diamond helps automate code review with actionable feedback and one-click suggestions, reducing review time and improving code quality.
• Easy transition from Differential: No need for a full migration; Graphite allows teams to gradually adopt stacked PRs while still using GitHub’s ecosystem.

For teams still relying on Differential, Graphite provides a scalable, Git-native replacement that improves efficiency and integrates seamlessly into modern DevOps workflows.

Summary

While Differential was once a powerful and widely used code review tool, its lack of active maintenance has made it increasingly difficult to integrate with modern development workflows. As engineering teams seek more streamlined, actively supported alternatives, Graphite has emerged as a strong successor. Graphite preserves Differential’s best features, such as stacked diffs, while providing a more modern UI, native GitHub integration, and automation capabilities that significantly improve the developer experience.