⏱️ Lectura: 10 min
Josh Bowman-Matthews, a longtime Servo maintainer, reviewed 1,150 pull requests over the past twelve months thanks to a role paid exclusively through community donations. The announcement came in September 2025: the project would use money raised on OpenCollective and GitHub Sponsors to fund part-time work by @jdm dedicated to improving the experience of Servo’s contributors.
📑 En este artículo
A year later, jdm himself published a recap with concrete numbers: new maintainers nominated, issues created to ease onboarding, and a deep rewrite of the JavaScript engine integration aimed at chasing down intermittent errors. Here’s a look at what got done and what it means for Servo development, the browser engine written in Rust.
TL;DR
- Josh Bowman-Matthews (@jdm) completed a year of donor-funded work for Servo, via OpenCollective and GitHub Sponsors.
- He reviewed 1,150 pull requests and nominated 8 new maintainers for the project in twelve months.
- He filed 114 issues designed for new contributors; 92% have already been resolved.
- He wrote new documentation on borrow hazards, experimental features, the AI policy, and how to find tasks.
- He supported the rewrite of Servo’s JS engine integration to fix intermittent panics caused by garbage collection.
- He uncovered broken behavior in window.open and helped stabilize flaky tests.
- He backed another contributor’s grant proposal to work on Servo, which was approved.
What happened
On September 15, 2026, Servo’s official blog published a recap of the first year of this funded role. Bowman-Matthews himself wrote the post in the first person, something uncommon in open source project announcements, and detailed exactly what the community’s money translated into.
The recap includes four key figures: 8 new maintainers nominated, 1,150 pull requests reviewed, 114 issues created specifically to make it easier for new contributors to get started (92% of which are already resolved), and several new technical documents that are now part of the official documentation: on borrow hazards (the risks of sharing mutable references in Rust within the engine), experimental features, the policy on using artificial intelligence in contributions, and how to find tasks to start with.
Beyond the work visible in the numbers, jdm spent time diagnosing hard-to-reproduce failures in other people’s pull requests: builds that failed intermittently, tests that passed on one run and failed on the next. That plumbing work rarely shows up in a changelog, but it’s what determines whether merging a change takes minutes or hours.
Context and history
Servo was born in 2012 inside Mozilla Research as an experiment: build a web rendering engine from scratch in Rust, a language that was still young at the time and that was developed in parallel with Servo to solve the memory and concurrency problems that plagued engines like Gecko. For several years, Servo was the testbed where Mozilla validated ideas about parallelism in layout and rendering.
In 2020, Mozilla cut staff and stopped funding Servo as an internal project. The code moved to the Linux Foundation, and for a while development was left in the hands of a small group of volunteers. A serious revival came later, under the umbrella of Linux Foundation Europe, with the stated goal of turning Servo into a lightweight, embeddable alternative to engines like Chromium or WebKit for applications that need to render HTML and CSS without carrying the weight of a full browser.
jdm’s funded role is part of that second stage of Servo development: instead of relying solely on sporadic volunteer contributions, the project uses recurring donations to support someone dedicated, among other things, to making sure a new contributor’s experience doesn’t come down to luck.
Technical details and performance
One of the most concrete technical focuses of the year was Servo’s JavaScript engine integration, based on SpiderMonkey. The team took on a large-scale rewrite to fix intermittent panics related to the garbage collector: failures that only showed up under certain memory conditions and were nearly impossible to reproduce on demand. jdm didn’t write all of that code, but he did review a large share of the associated pull requests and filed the issues that let the work be split among several contributors in parallel.
Another notable finding was broken behavior in window.open, the API that opens a new tab or window from JavaScript. The bug surfaced while investigating intermittent test failures, and ended up leading to the stabilization of a broader set of flaky tests (ones that sometimes pass and sometimes fail without any code changes).
To understand why test stability matters, look at how Servo is tested: the engine runs a large share of the Web Platform Tests (WPT), the interoperability test suite shared by all browser engines.
# clone and build Servo (works the same on Linux and macOS)
git clone https://github.com/servo/servo.git
cd servo
./mach bootstrap
./mach build --releaseThat block builds Servo in release mode using mach, the build system inherited from the same scheme Firefox uses. The next one runs a specific WPT file, the same kind of test jdm reviews when an intermittent failure shows up:
./mach test-wpt tests/wpt/mozilla/tests/mozilla/webgl/context_creation.html
./mach test-wpt --log-raw wpt-run.log dom/interfaces.htmlRunning the same test several times in a row (for example, in a shell loop) is the most direct way to confirm whether a failure is truly intermittent or there’s a reproducible race condition.
| Engine | Language | Embedding model | Status |
|---|---|---|---|
| Servo | Rust | embeddable library (libservo) | Active, donor-funded under Linux Foundation Europe |
| Chromium (CEF) | C++ | Chromium Embedded Framework | Mature, high memory footprint |
| WPE WebKit | C++ | WPE API for embedded devices | Used in smart TVs and set-top boxes |
| GeckoView | C++/Rust | Limited embedding, Android-focused | Maintained by Mozilla, mobile-focused |
💭 Key point: Servo doesn’t compete for end users as a desktop browser: it competes for developers who need to embed a lightweight rendering engine in their own application, without carrying the weight of a full Chromium.
How to start contributing
Building Servo requires Python (for mach) and an up-to-date Rust toolchain. On Windows, the commands are nearly identical, only how the script is invoked changes:
# Windows (PowerShell)
git clone https://github.com/servo/servo.git
cd servo
python mach bootstrap
python mach build --release
python mach run --release https://example.comOn Linux and macOS, the same flow runs with ./mach instead of python mach. The run command opens a window with Servo rendering the given URL, useful for confirming the build works before touching any code.
For someone just starting out, the most sensible entry point isn’t the JS engine or layout: it’s the issues tagged E-easy in the GitHub repository, many of them filed over the past year specifically to give newcomers a small, well-scoped first task. jdm documented that process in the finding things to do guide that was added to the official documentation.
💡 Tip: Before opening your first pull request, run the local linting suite (./mach test-tidy) to avoid style comments during review and get straight to the technical discussion.
Impact and analysis of Servo development
Servo’s case is an example of a funding model that’s growing in the open source ecosystem: instead of depending on a large company absorbing the project, as happened with Mozilla until 2020, support comes from recurring donations by individuals and organizations through OpenCollective and GitHub Sponsors.
The difference from other crowdfunding models is that here the money didn’t go to infrastructure, like CI servers, but to human work hours dedicated specifically to lowering the friction of contributing. It’s a bet that a project with more active maintainers (8 nominated in a year) ends up more resilient than one with just a few very busy maintainers.
flowchart TD
A["Donors (OpenCollective and GitHub Sponsors)"] --> B["Servo Fund"]
B --> C["Funded part-time role (@jdm)"]
C --> D["Pull request review"]
C --> E["Mentoring new contributors"]
C --> F["Technical documentation"]
D --> G["More active maintainers"]
E --> G
F --> GThe diagram summarizes the loop: the money doesn’t fund a specific feature, it funds the project’s capacity to absorb more external contributions without every pull request depending on a single person’s availability.
What’s next
jdm closed out the recap with the intention of staying in the role for another year, though the post doesn’t mention new numeric goals for the coming period. What is clear is the direction: more documentation to lower the barrier to entry, more work on test stability (a structural problem in any engine running thousands of WPT cases), and continuing to spread maintenance responsibilities across more people.
For the Rust ecosystem at large, every new Servo maintainer is also someone with real experience in a large, concurrent codebase, something that eventually translates into contributions to other tools in the language.
📖 Summary on Telegram: View summary
Try it yourself: clone the repo with git clone https://github.com/servo/servo.git and run ./mach build --release to see the engine build on your own machine today.
Frequently Asked Questions
What is Servo?
Servo is a web rendering engine written in Rust, designed to be embedded in applications that need to display HTML and CSS without carrying a full browser. It was born at Mozilla Research in 2012 and is now developed under Linux Foundation Europe.
Who is Josh Bowman-Matthews and what role does he play?
He’s a longtime Servo maintainer, known in the project as @jdm. Since September 2025 he’s worked part-time in a paid capacity, funded exclusively by donations, focused on improving the experience of the project’s contributors.
How is that work funded?
Through recurring donations on OpenCollective and GitHub Sponsors. There’s no single company backing the salary: the money comes from the community that uses or follows the project.
Can I use Servo today to embed a browser in my app?
Servo exposes an embeddable library (libservo) designed for that use case, although it’s still under active development and doesn’t cover 100% of the web standard. It’s an option worth evaluating against alternatives like CEF (Chromium) or WPE WebKit when the goal is a lighter footprint.
How do I start contributing to Servo?
The recommended starting point is the issues tagged E-easy in the GitHub repository, many of them created over the past year specifically to give a small, well-scoped first task to someone unfamiliar with the codebase.
What’s the relationship between Servo and the Rust language?
Servo and Rust were developed in parallel within Mozilla: several of the engine’s needs, like memory safety without a traditional garbage collector and safe parallelism, shaped the language’s design decisions in its early years.
References
- Servo Blog: official recap of the first year of @jdm’s funded role.
- servo/servo on GitHub: source code, E-easy tagged issues, and contribution guide.
- Servo’s OpenCollective: where the donations that fund the project are received.
- servo.org: the project’s official site and general documentation.
📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.
Imagen destacada: Foto de Pankaj Patel en Unsplash
0 Comments