[dev-servo] 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

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
___
dev-servo mailing list
dev-servo@lists.mozilla.org
https://lists.mozilla.org/listinfo/dev-servo

Re: [dev-servo] Pre-alpha of libservo available

[Patrick Walton]

Super excited to see this. Awesome!

Patrick

On Sep 20, 2017 9:03 AM, "Till Schneidereit" 
wrote:

> 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
>
> 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
> ___
> dev-servo ma

Re: [dev-servo] Pre-alpha of libservo available

[Alan Jeffrey]

Excellent!

Alan.

On Wed, Sep 20, 2017 at 11:03 AM, Till Schneidereit <
t...@tillschneidereit.net> wrote:

> 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
>
> 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
> ___
> dev-

Re: [dev-servo] Pre-alpha of libservo available

[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 <
t...@tillschneidereit.net> wrote:

> 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
>
> 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

Re: [dev-servo] Pre-alpha of libservo available

[Till Schneidereit]

On Wed, Sep 20, 2017 at 11:36 PM, Nicholas Nethercote <
n.netherc...@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.
___
dev-servo mailing list
dev-servo@lists.mozilla.org
https://lists.mozilla.org/listinfo/dev-servo