SourceHut is a suite of powerful, independent tools built on a foundation of minimalism

Editor’s Note: This article is part of our definitive guide to GitHub Alternatives. Click here to read the main overview.

In a world dominated by the feature-rich, UI-driven platforms of GitHub and GitLab, it’s easy to assume the “Pull Request” model is the only way to collaborate on code. But what if there was a faster, more focused, and philosophically different alternative? What if a platform was built on open, time-tested standards instead of proprietary APIs, and prioritized developer freedom above all else?

Enter SourceHut, the hacker’s forge. It’s not a direct competitor aiming to replace GitHub, but a suite of powerful, independent tools built on a foundation of minimalism, the Unix philosophy, and an email-driven workflow designed for a different kind of developer.

Table of Contents

1. What is SourceHut? The 10,000-Foot View
2. The Core Philosophy: Why SourceHut is Radically Different
3. A Tour of the SourceHut Suite
4. Who is SourceHut For? (And Who It’s Not For)
5. Getting Started: Your First Patch on SourceHut
6. Frequently Asked Questions (FAQ)
7. Conclusion: A Deliberate Choice in a World of Defaults
8. References

1. What is SourceHut? The 10,000-Foot View

SourceHut is not a single, monolithic application. It is a “forge”—a collection of distinct, interoperable services for software development. Created by developer Drew DeVault, SourceHut is a testament to a vision of a 100% free and open-source software (FOSS) development platform. It operates with no tracking, no advertising, and is sustained by a transparent, subscription-based business model.

The platform is composed of several key services:

git.sr.ht: Git and Mercurial repository hosting.

builds.sr.ht: A powerful continuous integration (CI) service.

lists.sr.ht: Mailing lists for discussion and patch review.

todo.sr.ht: A lightweight, email-driven issue tracker.

pages.sr.ht: Static site hosting.

These tools are designed to work together seamlessly but can be used independently, allowing developers to mix and match them with other services like GitHub or GitLab.

2. The Core Philosophy: Why SourceHut is Radically Different

SourceHut’s design is guided by a set of principles that intentionally set it apart from its mainstream peers.

The Unix Philosophy: Each component “does one thing and does it well.” Instead of a single, complex platform, SourceHut provides small, focused tools that can be combined to create a powerful workflow.

Email-First Workflow: This is perhaps the most significant departure from the norm. Collaboration on SourceHut revolves around mailing lists and the git send-email command. This approach, used by long-standing projects like the Linux kernel and PostgreSQL, is decentralized, scriptable, works entirely offline, and fosters in-depth, threaded discussions.

Aggressive Minimalism & No JavaScript: The web interface is intentionally spartan, fast, and accessible. By avoiding JavaScript for essential features, pages are incredibly lightweight, load instantly, and work perfectly on any browser, including text-based ones. The design philosophy is to minimize distractions and bring the content—the code—to the forefront.

100% Free and Open Source (FOSS): Unlike “open core” models where premium features are proprietary, the entire SourceHut platform is FOSS. Anyone can self-host the exact same software that powers the official site, ensuring ultimate freedom and control.

Ethical Stance: SourceHut operates with a strong ethical compass, explicitly condemning discrimination and refusing to do business with entities that violate human rights.

3. A Tour of the SourceHut Suite

Each component of SourceHut reflects its core philosophy in practice.

git.sr.ht (Source Code Hosting): Provides simple, fast, and reliable hosting for both Git and Mercurial repositories. The focus is on the underlying version control system, not a heavy web UI.

lists.sr.ht (Mailing Lists): The central hub for project communication. This is where patches are submitted for review, discussions take place, and announcements are made. It replaces the “comment thread” of a pull request with a time-tested, archivable format.

builds.sr.ht (Continuous Integration): A remarkably powerful and flexible CI system. Using a simple YAML manifest, you can run fully virtualized builds across various Linux and BSD distributions. Its features include the ability to submit ad-hoc jobs for testing without pushing to a repository and even SSH-ing into a failed build environment for interactive debugging. It can also be configured to automatically test patches submitted to a project’s mailing list.

todo.sr.ht (Issue Tracker): A minimalist, email-driven ticket tracker. You can submit bug reports, track tasks, and comment on them entirely through email, keeping the workflow consistent and accessible.

pages.sr.ht (Static Site Hosting): A straightforward service for hosting static websites. Deployments can be easily automated using the CI system.

4. Who is SourceHut For? (And Who It’s Not For)

SourceHut is not for everyone, and that’s by design.

The Ideal User Profile:

• Developers who are comfortable and proficient with the command line and Git.
• Projects and individuals who value open standards, long-term stability, and the transparency of an email-based workflow.
• Proponents of FOSS, privacy, and minimalist design.
• Teams looking for a fast, no-nonsense, and highly scriptable development environment.

Who Might Prefer Alternatives:

• Beginners who rely on graphical interfaces to learn and interact with Git.
• Large enterprise teams deeply integrated into proprietary ecosystems like Azure DevOps.
• Projects that require heavy, non-technical user interaction on a web platform.
• Those unwilling to learn the git send-email workflow, which has a learning curve for those accustomed to pull requests.

5. Getting Started: Your First Patch on SourceHut

Experiencing the workflow is the best way to understand it. Here’s a simplified guide.

1. Create an Account: Registration is simple. Hosting your own projects requires a subscription, but contributing to existing projects is free, and many features don’t even require an account.

2. Configure Git for Email: Before you can send a patch, you need to tell Git how to use your email account’s SMTP server. This one-time setup involves adding a few lines to your global .gitconfig file.

   [sendemail]
       smtpserver = smtp.your-email-provider.com
       smtpuser = [email protected]
       smtpencryption = tls
       smtpserverport = 587

3. The Basic Workflow:

   Clone a repository: git clone <repository-url>

   Make a change and commit it: git commit -m "My awesome change"

   Format your commit as a patch: git format-patch HEAD~1 (This creates a .patch file for your last commit).

   Send the patch to the mailing list: git send-email --to="~project/[email protected]" 0001-my-awesome-change.patch.

For a complete walkthrough, the guide at git-send-email.io is an excellent resource.

6. Frequently Asked Questions (FAQ)

Is SourceHut free to use?

It’s free for contributing to existing projects, and many features can be used without an account. To host your own projects, you are expected to pay a subscription fee based on what you can afford. This sustainable model ensures SourceHut’s interests remain aligned with its users, not venture capitalists. Financial assistance is available for those who need it.

Is the email workflow hard to learn?

It’s different from the PR model, but not inherently difficult. The git send-email command is a standard part of Git. Once configured, the process of creating and sending a patch is just a couple of terminal commands. The main learning curve is in understanding mailing list etiquette.

Can I use SourceHut’s CI with my GitHub repository?

Yes. The services are designed to be independent. You can use builds.sr.ht as a standalone CI service for repositories hosted on GitHub or other platforms.

What if I don’t want to self-host but want to use the tools?

The hosted service at sr.ht is the official, maintained instance of the platform. The subscription fee supports its development and maintenance.

7. Conclusion: A Deliberate Choice in a World of Defaults

SourceHut is more than just a code forge; it’s a statement. It represents a deliberate choice to favor simplicity, efficiency, and developer freedom over UI polish and proprietary ecosystems. By embracing the time-tested, decentralized power of email and the Unix philosophy, it offers a powerful, fast, and refreshingly direct way to collaborate on software.

It may not be the default choice for every developer, but for those who value its principles, SourceHut provides a development environment that is not only highly effective but also deeply rewarding to use.

8. References

• SourceHut Official Website: https://sourcehut.org/

• Drew DeVault’s Blog Post on Spartan Design: https://drewdevault.com/2019/03/04/Sourcehuts-spartan-design.html

• A Guide to the Email Workflow: https://git-send-email.io/

• SourceHut Pricing Model: https://sourcehut.org/pricing/

• Documentation for builds.sr.ht: https://man.sr.ht/builds.sr.ht/

• SourceHut’s Stance on Ethics: https://sourcehut.org/blog/2021-01-13-on-the-subject-of-ethics/