Pre-alpha of libservo available

[Till Schneidereit]

Hello friends of Servo!

We're happy to announce the availability of a pre-alpha version of
libservo, a Rust embedding API for Servo.

You can find documentation for the API and a tutorial for using it at the
following locations:
https://doc.servo.org/servo/struct.Servo.html
http://github.com/paulrouget/servo-embedding-example

Binaries for demo applications for the three desktop platforms can be found
here:
https://github.com/paulrouget/servoshell/releases


Please take a look, play around with the API and the demo applications, and
let us know what you think.

With the TL;DR out of the way, let's take a look at the details.


## What is this announcement about?

To some extent, Servo was always embeddable. Over the past year a lot of
effort has gone into the design and implementation of a clean low-level API
- libservo. The API is designed for maximal flexibility, with the goal
being to cover all use cases for Servo - ranging from simple webview-like
uses to fully-fledged browsers to server-side uses as a headless utility.

We do not anticipate most embedders to use this API directly: to address
the use cases of the majority of embedders, we intend to build higher-level
APIs on top of this. Those will range from higher-level Rust APIs to an
implementation of CEF[1] to drop-in replacements for the Android WebView
component[2].

Because most embedders won’t be using this low-level API directly, we are
choosing flexibility over usability when adding functionality.We want the
API to be as usable as possible - but not more so. The API requires
embedders to provide a GL rendering context and manually drive the event
loop to ensure rendering and input processing. It also allows fine-grained
influence on behavior such as navigation. Going forward, it'll grow more
capabilities along those lines, such as rendering to buffers or output of
raw display lists to be consumed by compositing systems such as a
customized WebRender, or delegating all I/O to the embedder.



[1] https://en.wikipedia.org/wiki/Chromium_Embedded_Framework
[2] https://developer.android.com/reference/android/webkit/WebView.html


## What's the current status?

At this point libservo is far from complete, but ready for early
experimentation. Crate-level documentation is here:
https://doc.servo.org/servo/struct.Servo.html

A How To guide for setting up a project to use libservo can be found here:
<http://github.com/paulrouget/servo-embedding-example>
http://github.com/paulrouget/servo-embedding-example

In addition to this example application Paul has built two additional demo
apps: a cross-platform minimalist browser with as reduced a UI as is
possible and a more fully-fledged macOS version with a native tabbed UI and
a proper location bar. These are both implemented as ports of the
ServoShell project:
https://github.com/paulrouget/servoshell

Releases for the three desktop platforms are available as github releases:
https://github.com/paulrouget/servoshell/releases

We're happy with the overall shape of the API, but expect at least cosmetic
changes to most of it. Additionally, there is a lot of functionality
missing, so you should see this as the kernel of an API to be fleshed out.

Additionally, there are a number of issues making it harder to get a
project up and running than it should be. From a build system and
dependency management perspective, embedding Servo should be as simple as
adding it as a dependency to a crate's Cargo.toml. For now Paul's
above-mentioned embedding example has a detailed explanation of the
required steps.


## What's next?

Our highest priority right now is to streamline the process. That means
reducing the build system complexity and doing the above-mentioned cosmetic
changes.

We're also working on more examples and demos. Specifically, Paul is
experimenting with a simple C API and with an integration into a Xamarin
Forms-based C# application.

We'll share more information about those experiments and about our plans
for more high-level ways of embedding Servo, such as bindings for
high-level languages like Java and JavaScript.

For now, please download the demo applications, take a look at the
documentation, play around with the example code, and let us know what you
think: ping Paul or me in #servo on IRC, file issues in the servo/servo or
repository or Paul's ServoShell or Servo Embedding Example repositories, or
simply reply to this email.

We'd be particularly interested in experiments around integrating Servo
into platform-native toolkits. E.g., a Gtk-based Linux equivalent to Paul's
macOS ServoShell demo would be fantastic.


Thank you,
the Servo Embedding team

[Alan Jeffrey]

Excellent!

Alan.

> _______________________________________________
> dev-servo mailing list
> dev-...@lists.mozilla.org
> https://lists.mozilla.org/listinfo/dev-servo
>

[Nicholas Nethercote]

What is the backwards compatibility story? Are the APIs stable?

I ask because, as I understand it, API instability has always been the
problem with embedding Firefox.

Nick

On Thu, Sep 21, 2017 at 2:03 AM, Till Schneidereit <

[Till Schneidereit]

On Wed, Sep 20, 2017 at 11:36 PM, Nicholas Nethercote <
n.neth...@gmail.com> wrote:

> What is the backwards compatibility story? Are the APIs stable?
>
> I ask because, as I understand it, API instability has always been the
> problem with embedding Firefox.
>

I agree that backwards compatibility is important. While we haven't
stabilized the APIs yet, but we plan to do so before anything approaching a
stable release.