Hubbry Logo
Servo (software)Servo (software)Main
Open search
Servo (software)
Community hub
Servo (software)
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Servo (software)
Servo (software)
Servo (software)
View on Wikipedia
from Wikipedia

Servo
Original authorMozilla Corporation
DevelopersLinux Foundation Europe and volunteers[1][2]
Repository
Written inRust
Operating systemWindows, Linux, macOS, Android, OpenHarmony
TypeBrowser engine
LicenseMPL 2.0[3]
Websiteservo.org Edit this on Wikidata

Servo is an experimental[4] browser engine designed to take advantage of the memory safety properties and concurrency features of the Rust programming language. It seeks to create a highly parallel environment, in which rendering, layout, HTML parsing, image decoding, and other engine components are handled by fine-grained, isolated tasks.[5][6] It also makes use of GPU acceleration to render web pages quickly and smoothly.[7][8]

Servo has always been a research project. It began at the Mozilla Corporation in 2012, and its employees did the bulk of the work until 2020.[9] This included the Quantum project, when portions of Servo were incorporated into the Gecko engine of Firefox.[10][4]

After Mozilla laid off all Servo developers in 2020,[9] governance of the project was transferred to Linux Foundation Europe.[1] Development work officially continues at the same GitHub repository with the project itself entirely volunteer driven.[2]

History

[edit]

Development of Servo began at the Mozilla Corporation in 2012.[11][12] The project was named after Tom Servo, a robot from the television show Mystery Science Theater 3000.[13]

In 2013, Mozilla announced that Samsung was collaborating on the project.[14] Samsung's main contribution was porting Servo to Android and ARM processors.[15] A Samsung developer also attempted to re-implement the Chromium Embedded Framework API in Servo,[16] but it never reached fruition and the code was eventually removed.[17]

The Acid2 test was passed in 2014,[5] and Servo could render some websites faster than the Gecko engine of Firefox.[18] By 2016, the engine had been further optimized.[19] The same year, Mozilla began the Quantum project, which incorporated stable portions of Servo into Gecko.[10][4]

Servo was the engine of two augmented reality browsers. The first was for a Magic Leap headset in 2018.[20] Then the Firefox Reality browser was released in 2020.[21]

In August 2020, Mozilla laid off many employees, including the Servo team, to "adapt its finances to a post-COVID-19 world and re-focus the organization on new commercial services".[9] Governance of the Servo project was thus transferred to Linux Foundation Europe.[1]

In October 2021, the European Eclipse Foundation launched Oniro, a vendor-neutral open-source distributed operating system for Internet of things and embedded devices, with various partners such as Huawei and Linaro among others. It is based on OpenAtom Foundation's OpenHarmony for software development, and it uses the Servo web engine as part of the open source project, built on Rust language.[22] Experimental support for OpenHarmony was introduced to Servo in July 2024.[23]

In January 2023, the Servo project announced that new external funding had enabled a team of developers to reactivate the project.[24] The initial roadmap focused on selecting one of the two existing layout engines for further development, followed by working towards basic CSS2 conformance.[25] In February 2024, at FOSDEM 2024, the Servo Project team outlined their plans for a 'reboot' of Servo.[26]

In October 20th 2025, the first release build of servo named Servo v0.0.1 was released with the main addition being availability of a prebuilt MacOS version for Apple silicon Macs.[27]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Servo (software)

View on Grokipedia
from Grokipedia
Servo is a prototype web browser engine written in the Rust programming language, designed as a lightweight and high-performance alternative for embedding web technologies in applications across desktop, mobile, and embedded platforms. Initiated by Mozilla Research in 2012, Servo leverages Rust's memory safety and concurrency features to enable parallel processing and GPU acceleration, supporting standards like WebGL and WebGPU. The originated as a effort at to explore innovative browser architectures, with early development focusing on modularity and embeddability to foster reusable . In , stewardship transferred to the to broaden community involvement, and in 2023, it moved to Linux Foundation Europe to revitalize industry collaboration and open-source contributions in the region. Key advancements from Servo have been integrated into Mozilla's engine through the Quantum project, including the Stylo CSS parser for faster styling and WebRender for GPU-accelerated rendering, significantly enhancing Firefox's performance since 2017. Servo remains an active, independent project governed by a Technical Steering Committee, with ongoing development emphasizing stable APIs, standards compliance, and portability to platforms like Windows, macOS, , Android, and . It contributes to web standards bodies such as W3C and , with core team members editing adopted specifications, positioning it as a foundational technology for future embeddable web engines.

Overview

Project origins and goals

Servo originated as a research and development project initiated by Mozilla Research in 2012, with the aim of building a new web browser engine that could exploit the growing prevalence of multicore processors and parallel hardware while enhancing memory safety. The project was specifically designed to leverage the Rust programming language, which was developed concurrently at Mozilla, to address longstanding challenges in web rendering such as memory-related vulnerabilities and concurrency limitations prevalent in C++-based engines like Gecko. In Gecko, an analysis revealed that approximately 50% of critical security bugs stemmed from issues like use-after-free errors, out-of-bounds access, and integer overflows, prompting Servo's emphasis on Rust's ownership model and affine type system to prevent such defects at compile time. The name "Servo" draws inspiration from Tom Servo, the wisecracking robot character featured in the American television series . This choice reflects the project's experimental and innovative spirit, aligning with the show's theme of critiquing and reimagining media through a technical lens. At its inception, Servo's high-level objectives centered on fostering a modular architecture that supports embedding in diverse applications, from desktop browsers to mobile and embedded systems. Key goals included enabling fine-grained parallel processing of —such as data-parallelism in layout and task-parallelism in scripting—to improve scalability on modern hardware, while integrating GPU acceleration for efficient rendering of complex graphics and animations. These aims positioned Servo as a next-generation engine to overcome the single-threaded bottlenecks and safety shortcomings of legacy systems like , prioritizing conceptual advancements in concurrency and over immediate production deployment.

Licensing and platforms

Servo is licensed under the 2.0 (MPL 2.0), a that permits free use, modification, and distribution of the software, provided that any derivative works are made available under the same and the source code remains accessible. The project supports building and running on several 64-bit platforms, including macOS (with compatibility for both Intel x86-64 and ARM architectures), , Windows, Android, and . Experimental support for , an open-source operating system for smart devices, was introduced in to expand Servo's reach to mobile and IoT ecosystems. Servo is primarily developed and tested on 64-bit systems, requiring tools such as (via rustup), a , and platform-specific dependencies like for macOS or the for mobile builds. Its architecture, leveraging Rust's concurrency features, enables adaptability across desktop, mobile, and embedded devices without fundamental platform-specific overhauls. The source code and builds are distributed through the official repository at servo/servo, where contributors can access the , , and instructions for compiling from source using the ./mach build command.

Technical architecture

Core design principles

Servo's core architecture is built around the Rust programming language, which enforces compile-time memory safety to eliminate entire classes of vulnerabilities, such as buffer overflows and use-after-free errors, without relying on a garbage collector. This design choice addresses longstanding security challenges in browser engines written in languages like C++, where runtime memory management often introduces risks. By leveraging Rust's ownership model and borrow checker, Servo achieves robust protection against memory-related exploits while maintaining high performance. A key principle is the emphasis on concurrency, enabling fine-grained parallelism that allows independent processing of web rendering tasks—such as CSS cascade resolution, layout calculations, and —across multiple threads. Rust's safe concurrency primitives, including thread isolation and fearlessness in parallel code, support this approach without the pitfalls of data races common in other systems. This parallelism is fundamental to Servo's goal of scaling efficiently on modern multi-core processors, distributing workload to accelerate page rendering. Modularity forms another cornerstone, with Servo structured as a collection of loosely coupled, reusable components rather than a monolithic . This allows individual modules, like the layout or script engines, to be embedded or integrated into diverse applications, from desktop browsers to embedded systems. The design promotes easier experimentation, testing, and contribution by isolating concerns and avoiding the tight interdependencies that complicate traditional engines. To enhance rendering performance, Servo incorporates GPU acceleration, directly supporting for 3D graphics and for modern compute and graphics workloads. This integration offloads intensive computations to the GPU, enabling efficient handling of interactive and visually rich while adhering to web standards.

Key components and parallelism

Servo's architecture is built around several major components that handle distinct aspects of web rendering, enabling modular development and efficient processing. The compositor manages windowing, input handling, and event routing, forwarding display lists to the WebRender library for GPU-accelerated rendering of visual elements. It processes user inputs such as and keyboard events, directing most to the content process while handling scroll events directly for improved responsiveness. The layout engine computes the positioning and sizing of page elements by building a and fragment tree from a DOM snapshot, then generating display lists for the compositor. Servo maintains two layout engines: the original Layout 2013, which supports features like incremental layout and counters, and the newer Layout 2020, initiated in 2019 with a two-tree design for better alignment with CSS specifications, including opportunistic parallelism. Since 2023, Layout 2020 has been the primary engine, incorporating Taffy for support, with post-2023 development continuing to address limitations in the original engine such as incomplete support for certain CSS features like floats. The style system parses and resolves CSS rules, computing styles from the DOM snapshot to inform layout calculations and support dynamic, media-rich web applications. Integrated closely with the layout process, it leverages parallel computation for selector matching, separate from flow tree construction. The rendering orchestrates interactions among script, layout, and compositor tasks, utilizing script workers for DOM manipulation and event handling, alongside paint workers for generating visual output. This employs multiple script threads per content process to parallelize tasks like DOM traversal and style resolution. Parallelism in Servo is achieved through a task-based with isolated heaps, allowing concurrent execution across multiple threads while maintaining clear boundaries for failure isolation and recovery. Task scheduling distributes workloads for DOM traversal, CSS style resolution, and layout calculations across threads, including parallel selector matching and that divides the screen into a grid for concurrent processing. Layered rendering further enables parallel subtree rendering on the GPU, complemented by concurrent decoding. This multi-threaded approach, supported by multiple content processes, enhances performance on multi-core hardware. Rust's model ensures by enforcing compile-time checks on access, preventing data races and enabling fearless concurrency without traditional locks in many cases. Servo provides partial support for web standards, including through its DOM implementation in the script task, CSS up to level 2.1 with a focus on conformance testing via Web Platform Tests (achieving around 64% for CSS2 in Layout 2020 as of March 2023, with pass rates improving significantly to over 90% for CSS2 tables tests as of February 2025), and execution via the embedded engine. The HTML parser adheres to specification compliance for robust parsing. Experimental features in Servo include WebGPU integration for advanced graphics rendering, enabling high-performance compute and graphics operations directly in the rendering pipeline. This support builds on capabilities and aligns with Servo's goal of efficient, parallel web content rendering.

Development history

Mozilla-led development (2012–2020)

Servo was initiated in 2012 as a project by to develop a next-generation web rendering engine capable of leveraging modern hardware parallelism and features. The effort aimed to create a prototype that could inform future improvements to Mozilla's existing engine, with early work focusing on as the primary programming language to enable safe concurrency. In 2013, partnered with to accelerate Servo's development for mobile platforms, porting the engine to Android and the architecture. This collaboration provided funding for optimizations targeted at resource-constrained devices, emphasizing parallel processing to enhance performance on multicore processors common in smartphones. By 2014, Servo achieved a significant milestone when it passed the Acid2 rendering test in March, validating its basic layout and CSS capabilities against web standards. This accomplishment demonstrated the engine's progress from a conceptual to a functional renderer, though full web compatibility remained a work in progress. In 2016, elements of Servo were integrated into through Project Quantum, Mozilla's initiative to overhaul the browser's rendering pipeline for better parallelism and speed. Specifically, Servo's parallel layout and CSS components, such as the Stylo engine, were adapted to improve Gecko's handling of complex web pages, contributing to measurable gains in rendering efficiency. From 2018 to 2020, Servo found practical applications in emerging technologies, powering experimental browsers for augmented and virtual reality. In late 2018, Mozilla ported Servo to the Magic Leap One AR headset, releasing a developer preview that enabled web content rendering in mixed-reality environments with minimal effort—achieved in about two person-months. Similarly, Firefox Reality, Mozilla's VR/AR browser, incorporated Servo as an optional rendering backend, allowing users to toggle it for enhanced performance on headsets like Oculus and HTC Vive starting in 2018. These integrations highlighted Servo's adaptability for non-traditional form factors, where its lightweight design and Rust-based safety proved advantageous. In August 2020, Mozilla conducted major layoffs affecting approximately 250 employees, including most of the dedicated Servo development team, as part of a strategic shift toward commercial products and away from long-term efforts. This slowed active development on Servo, marking the end of 's primary stewardship of the project.

Independent era and revival (2020–present)

In November 2020, following Mozilla's decision to lay off its Servo team, the project's governance was transferred to the to ensure neutral, community-driven oversight and continued open-source development. This shift marked Servo's transition from corporate incubation to independent stewardship, allowing broader collaboration while preserving its Rust-based architecture for web rendering. From late 2020 through , Servo entered a period of , with development sustained primarily by a small number of volunteers amid significantly reduced activity—averaging fewer than three contributors per month by and only 65 pull requests merged that year. Despite this lull, the project remained accessible on , laying the groundwork for future revival through sporadic maintenance and community interest. Reactivation began in January 2023 when secured external funding to dedicate a team of engineers to the project, boosting volunteer contributions and refocusing efforts on core advancements like layout system improvements. This influx enabled consistent progress, including the project's move to in September 2023 for enhanced European open-source ecosystem integration and community growth. By mid-2023, monthly pull requests had surged, signaling a robust revival under volunteer and funded . In 2024, key updates included the addition of experimental support for in July, expanding Servo's adaptability to Huawei's alongside ongoing enhancements to the layout engine, such as better CSS2 compliance and parallel processing for tables. These developments prioritized modularity and performance, with the new layout engine evolving to handle more spec-aligned features like sticky positioning and typography controls. Ongoing efforts remain volunteer-driven, with monthly progress reports highlighting advancements in performance—such as rendering loop throttling to 60 FPS and memory optimizations reducing unused code—and standards compliance, including 99.6% pass rate on CSS geometry tests and support for variable fonts and IndexedDB features as of August 2025. These updates underscore Servo's commitment to embedding web technologies in diverse applications while fostering contributions. A major milestone arrived on October 20, 2025, with the release of Servo's first official version, v0.0.1, providing prebuilt binaries for macOS on among other platforms and featuring a demo browser in experimental mode for testing web rendering capabilities. This tagged release, drawn from recent nightly builds and manually verified, represented a step toward reliable distribution via , with plans for monthly updates to sustain momentum. In October 2025, experimental support for the OS was introduced, enabling initial web rendering on this Rust-based operating system, though with limitations such as crashes on page loads.

Applications and integrations

Integrations with other browsers

Servo's integration into other browsers primarily occurred through Mozilla's Project Quantum, initiated in 2016, which aimed to enhance Firefox's Gecko engine by incorporating select parallelized components from Servo to improve rendering performance without a full engine replacement. A key outcome was the adoption of Servo's parallel style system, known as Stylo or Quantum CSS, which replaced Gecko's single-threaded CSS engine with a Rust-based, multi-threaded alternative capable of processing stylesheets across multiple worker threads. This integration enabled faster page loading and better responsiveness on multi-core processors, with benchmarks showing up to 30% improvements in stylesheet processing times in early tests. Additionally, Servo's WebRender, a GPU-accelerated rendering pipeline, was embedded into Gecko as part of the Quantum Render initiative, offloading layout and compositing tasks to the graphics hardware for smoother scrolling and animations. These style and rendering threads from Servo thus augmented Gecko's layout capabilities, allowing parallel execution of rendering stages while retaining Gecko's core layout logic. Following the completion of Project Quantum in 2017, which powered the 57 release, select Servo-derived features like Stylo and WebRender continued to evolve within , contributing to ongoing performance optimizations as of 2025. However, full-scale adoption of additional Servo components into paused after Mozilla discontinued dedicated funding for the Servo project in 2020, leading to the layoff of its development team and a shift toward maintaining only the integrated elements. Despite this, these parallel features remain active in , providing sustained benefits such as enhanced concurrency for complex web pages, with WebRender now enabled by default across most platforms to handle hardware-accelerated rendering. Beyond , discussions have highlighted Servo's modular architecture as potentially suitable for integration with other major engines like Chromium's Blink or Apple's , leveraging its embeddable design for targeted enhancements in parallelism and . For instance, Servo's components have been explored as alternatives in frameworks like Qt WebEngine, where they could replace parts of Chromium or for lighter-weight web views. However, as of 2025, no major production implementations have materialized in these engines, with efforts remaining at the experimental or embedding level rather than core engine mergers. The primary benefits of these integrations lie in bolstering host browsers' concurrency without requiring a complete overhaul, allowing established engines to incorporate Servo's innovations in parallel processing for style computation and rendering, thereby improving overall efficiency on modern hardware. This selective approach has enabled to achieve competitive performance metrics, such as reduced main-thread blocking, while preserving compatibility and stability.

Experimental uses and builds

Servo has been utilized in various experimental contexts, primarily as an embeddable web rendering rather than a full-fledged browser. Its WebView facilitates integration into other applications, enabling developers to render web content without the overhead of larger engines like Chromium's CEF. This embedding capability has been demonstrated in prototypes and research projects, highlighting Servo's potential for lightweight, high-performance web rendering in custom software. One prominent experimental build is servoshell, Servo's minimal first-party browser interface built using the egui Rust GUI library. Servoshell serves as a test harness for the engine's web platform features and includes an experimental mode toggle (☢) that activates all incomplete and bleeding-edge capabilities, such as Trusted Types and canvas strokeText support, bypassing standard command-line flags. Recent enhancements to servoshell include single-process mode for simpler debugging and improved navigation on Android, making it suitable for rapid prototyping of browser behaviors. In October 2025, Servo released its first official binaries (v0.0.1) for servoshell across supported platforms, improving accessibility for experimentation. Community-driven experimental browsers have also leveraged Servo to explore new embedding APIs and user interfaces. For instance, Moto is a desktop-focused browser that extends servoshell, aiming to add features like bookmarks, history, and WebExtensions while informing Servo's broader embedding development; it currently operates without tracking the latest Servo updates due to its nascent Android support. Similarly, Verso is an experimental built atop Servo, emphasizing embedding solutions and gradual maturation into a full browser, with integrations like an experimental runtime for cross-platform app development. Another niche build, Cuervo, provides a for Servo, allowing terminal-based rendering as an early for non-graphical environments. Beyond browsers, Servo has been experimentally embedded in graphical frameworks to render in native applications. A notable example is its integration into Qt applications using the CXX-Qt library, which bridges and C++ to create a ServoWebView component capable of displaying sites like servo.org within QtQuick windows; this approach demonstrates Servo's viability as a Rust-native alternative for web views in . These builds underscore Servo's role in toward safer, more parallelized web rendering, though they remain prototypes without production-scale adoption.

References

  1. https://servo.org/about/
  2. https://github.com/servo/servo
  3. https://wiki.mozilla.org/Quantum
  4. https://linuxfoundation.eu/newsroom/servo-web-rendering-engine-joins-linux-foundation-europe
  5. https://medium.com/mozilla-tech/a-quantum-leap-for-the-web-a3b7174b3c12
  6. https://arxiv.org/pdf/1505.07383
  7. https://people.igalia.com/mrego/talks/2023-09-21-open-source-summit-europe-servo.pdf
  8. https://book.servo.org/hacking/building-for-openharmony.html
  9. https://blogs.igalia.com/mrego/servo-revival-2023-2024/
  10. https://book.servo.org/hacking/setting-up-your-environment.html
  11. https://servo.org/
  12. https://www.mozillafoundation.org/en/research/library/engineering-the-servo-web-browser-engine-using-rust/
  13. https://github.com/servo/servo/wiki/Design
  14. https://blogs.igalia.com/mrego/servo-a-new-web-engine-written-in-rust/
  15. https://book.servo.org/architecture/overview.html
  16. https://github.com/servo/webrender
  17. https://github.com/servo/servo/wiki/Servo-Layout-Engines-Report
  18. https://github.com/servo/servo/wiki/Roadmap
  19. https://news.ycombinator.com/item?id=45373501
  20. https://book.servo.org/architecture/concurrency-and-parallelism.html
  21. https://servo.org/blog/2025/02/19/this-month-in-servo/
  22. https://servo.org/blog/2024/04/15/spidermonkey/
  23. https://www.theverge.com/2013/4/3/4178714/samsung-mozilla-servo-browser-engine-announcement-rust-programming-engine
  24. https://techcrunch.com/2013/04/03/mozilla-and-samsung-collaborate-on-servo-mozillas-next-gen-browser-engine-for-tomorrows-multicore-processors/
  25. https://research.mozilla.org/2014/04/17/another-big-milestone-for-servo-acid2/
  26. https://hacks.mozilla.org/2017/11/entering-the-quantum-era-how-firefox-got-fast-again-and-where-its-going-to-get-faster/
  27. http://bholley.net/blog/2017/stylo.html
  28. https://servo.org/blog/2018/12/04/magicleap/
  29. https://github.com/servo/servo/wiki/FirefoxReality-build
  30. https://blog.mozilla.org/en/mozilla/news/update-on-firefox-reality/
  31. https://www.zdnet.com/article/mozilla-lays-off-250-employees-while-it-refocuses-on-commercial-products/
  32. https://www.itprotoday.com/rust/rust-based-servo-web-engine-moves-to-linux-foundation
  33. https://www.linuxfoundation.org/press/press-release/open-source-web-engine-servo-to-be-hosted-at-linux-foundation
  34. https://servo.org/blog/2020/11/17/servo-home/
  35. https://servo.org/blog/2023/01/16/servo-2023/
  36. https://servo.org/blog/2024/07/31/this-month-in-servo/
  37. https://servo.org/blog/2025/01/31/servo-in-2024/
  38. https://servo.org/blog/2025/09/25/this-month-in-servo/
  39. https://servo.org/blog/2025/10/20/servo-0.0.1-release/
  40. https://www.phoronix.com/news/Servo-0.0.1-Released
  41. https://www.phoronix.com/news/Redox-OS-October-2025
  42. https://wiki.mozilla.org/Quantum/Stylo
  43. https://blog.rust-lang.org/2017/11/14/Fearless-Concurrency-In-Firefox-Quantum.html
  44. https://wiki.mozilla.org/Platform/GFX/Quantum_Render
  45. https://mozillagfx.wordpress.com/2017/09/21/introduction-to-webrender-part-1-browsers-today/
  46. https://www.phoronix.com/news/Servo-Embed-API-2025-Progress
  47. https://www.kdab.com/embedding-servo-in-qt/
  48. https://servo.org/blog/2025/10/24/this-month-in-servo/
  49. https://www.phoronix.com/news/Servo-September-2025-Highlights
  50. https://book.servo.org/running-servoshell.html
  51. https://github.com/moto-browser/moto
  52. https://github.com/versotile-org/verso
  53. https://github.com/mcclure/cuervo
  54. https://v2.tauri.app/blog/tauri-verso-integration/
  55. https://servo.org/blog/2024/09/11/building-browser/
Add your contribution
Related Hubs
User Avatar
No comments yet.