OK, welcome, everyone. Next up, we have Manuel, who's going to talk about the solo project.
Man, over to you.
Yeah, thank you. OK, so thank you for having me here. Thank you for organizing a world platform.
Track at four of them. I mean, the world platform now is full of open source, so it's the perfect place to be there.
So, yeah, I'm going to talk about servo project and the impact on the world platform ecosystem,
just a quick introduction. In myself, I'm an old rego, I work at Arigalia, part of the world platform team,
and working, yeah, I was working as a engineering, chromium work kit, implementing CSS features,
and other HTML features and the like. And since 2023, I'm the chair of the servo
technicalist in committee and help me to coordinate the fourths around the project.
Avodigalia is the third talk. Maybe it's a lot of basically an upper source consultancy. We work
in all the web engines and we are top contributors there, and we also have a flat structure that kind of
a cooperative. So, servo, I guess a lot of you have here about it. Here, right, I hope. And you know,
the project that are even some servo contributors in the room. So, yeah, you can talk to any
fast later. So, basically, a word is a web rendering engine, we think in Rust, that's a very
quick summary, basically. It has a bunch of features. It's a incredible, in the sense, it has
a web view API. We are working on it. It has a few features, thank you, to the Rust programming language,
like memory safety and parallel lens. From the beginning, it was tried to use concurrency as much
as possible for for some for everything, basically. And it's cross platform. We could not really
support like five platforms, like three desktop main ones, like Linux Windows and Mac, and then we also
support Android and Open Harmony on mobile. And it's modular. It has a lot of libraries, which are
called crazy on the Rust world that are used by many popular Rust projects and all that. So,
I need to have modules that we use with Firefox, I will tell more about that later. And it's also
a independent project. It's under Linux Foundation, Europe, umbrella. And it's govern with Open
Governance by the TSC committee and all that. So, yeah, independent from from the actors. So, yeah,
like you saw the quick videos, better to explain this. We are seeing here the Serpocial,
which is like the minimal browser we have to test. Serpo, while we are developing on it,
is nothing special, nothing fancy, just to help us test in the project. Here is gross in the
server. The door website, I'm using that icon on the right corner, which is a bit.
Then, the RUS may be, it's experimental features that I'm enabling. So, we can also browse
more complex sites, like GitHub and others, it enables some features that we are still working on them.
And, yeah, basically, like any other webbending, it can render different pages. It's of course,
still many glitches here and there. We'll find some things that doesn't work. As expected,
but the heat kind of of work, it can do a bunch of things. We are having some new features every
day. I mean, there are a lot of work on the project. There are new features that are landing.
And we have just recently landed, like, window, multiple windows support. That's what I'm showing here.
So, you can have even different windows running and things kind of work. You can even play chess.
No, that's something new. It wasn't possible a while ago. So, you can, you can spend some time on
it even playing. And, it also works. I mean, playing very well, of course.
And, yeah, I mean, probably you will know that a little bit about the history of service was
started by Mozilla in 2012. And then, after several years of development, there, in 2020, the whole
team at Mozilla was laid off, basically. So, we can see here a clear impact on the evolution. This
is showing like the PR's Merget. And, per year on the project, we turn off from both, basically,
the PR's from real people, because we have some both that are to make some things. And then,
the average contributors per month, in the red line, and the average contributors per month,
that have no more than 10 PR's that month, the yellow line. And we see that there were a couple of
years, Mozilla kind of, yeah, transition the project to Linux Foundation. And there was a couple of years
that probably were kind of surviving, basically, of mostly that. And, since 2023, you got to
cover the project maintenance. And, the main goal was to bring the project back to life, reactivate
the community, and make it active again. And, since we are managing to do it, I mean, we are now
having way more contributors than before. And, also, a lot of active contributors every month,
which is very nice. And, at least, we have like four or five people here in the room working on
servo these days. So, just focusing on this last period that we were working on, there were
a lot of teams happening and it's impossible to describe them all. You know, we call that, you know,
we talk, but basically, the yellow tending was a very big piece, because in 2020, the Mozilla team was
starting a new layout ending, actually, for servo. And, we took that one and implemented
teams, I flowed, stable, flexbox, so many, many different teams there. There are a lot of
people working on different features, gamepad API, web XR, streams, webcript API, web driver,
I mean, a lot of things like, we have so many contributors, people picked different teams.
There will be a API, we have been working on it a lot. We have a experience also, Sarigali,
with the WPA API that Mario was explaining, and the taking that experience, we are also trying to
make the servo API good. We bring back that tools to life. Now, you can also use them to
to spare servo and each of these VG support and many other things. And on plans, there are also
a lot of plans, a lot of things coming. So, some initial accessibility support, we expect to land
it this year. We want to complete the web API to something that we consider is more or less okay,
or more or less minimal, that people can start to use servo. For real, in their project,
we want to focus a lot on performance, service expected to be fast, and we wanted to be really fast.
We are improving interaction, forums, you can have select things, we want to add selection,
invite that that are not possible yet. More layout improvement, more CSS features,
HTML features, all that. I mean, a lot of things are coming. Just another example, this is a
demo of how you can use a web driver with servo. You can run servo with this. Come online
argument that is specified. A port and then just connect to it. This is a Node.js library
called web driver. Io, you just connect to it, a local host here, and just open hacker news, for
example. So, in this video, I mean, I'm running that, but I run it as a bit longer as
clear that goes to hacker news, and then goes to the search box, enter servo, search for servo,
order by date, and gives you like the last thing, thing, entries about servo there. So,
something you can do pretty easily with, I mean, with servo or with a language, but yeah, with this API,
that is now. We also use in our web driver for running the WLPT test, and that's also very,
nice because that's why the rest are doing also. And yeah, in the last few months that are having
a lot of new projects, you see in servo that are showing up, that's very exciting for us,
and very interesting, because that's why, I mean, the main purpose of the project is to become
something people can use, and then there was a new class here before talking about the Apache
Cordova plugin, that you service a web view, it's still, I mean, most of them are basically
spamming, and it's still experimental, but it's good to see them. Showing up, this beaver browser,
it's something from last night's main directly, and actually we had a half a name, and last night
we decided maybe beaver, because what was the icon, the person to think it was decided,
and it's a good browser that you say it's the mail to the whole UI, I will show a video later,
it's really cool. Servo GDK, I'm like GDK, and by then for use in servo,
it's lean, it also has now experiment, it's in servo underneath, and Paul is a liware mark
down beware, that is part of a bigger project called Marko, so Marko Paulo, and then Marko is
a mark down editor, that you can use, and they have now a branch that also use servo underneath,
so, yeah, you can go to this page, they make with page on the website, and find more examples,
and this is this HTML browser, that last night when I get to the hotel after dinner,
I saw the message on solid, this is the chat we use, that was saying, okay, I have this really
now, and then I was building it, and recording it, because it's really cool, everything is HTML,
you have tabs, you can display the views, and everything is HTML running on top of servo,
and showing what servo can do these days, of course, I mean, something very new, it has a lot
glitches and whatever, but that is cool, you can have this split view, there are different tabs,
and even the older UI is made on HTML and all that, so this is like the settings, but everything is
HTML, you can switch the theme, and I mean, really cool things you can already do with servo,
so, yeah, now the main topic of the toll somehow, like the impact of servo on the web platform
ecosystem, and maybe the first thing is even more than the web platform ecosystem alone,
that I mean, it's not that servo created Rust, but basically Modzilla started the Rust language,
and then the servo project in parallel, and use in service kind of a, if we can build a web engine,
then the language is good, right? I mean, not picking as small example, so just going,
trying to validate faster as a good language by developing a whole web engine, and then on the first
years, the needs of servo kind of help to or influence the design of the Rust programming language,
so this is, I mean, not application of servo, but I mean, but on the whole software community at
the end, and the work community is more and more used in service, Rust is days,
there are a lot of servo crates that I was mentioning before that are very popular, and many,
many servo libraries use these days, many Rust libraries use these days,
I mean, Rust URL HTML55, I mean, many things, if you need, in order application to access some
some web content you are going to probably use, some of these crates that were created by
servo, and also, yeah, to the point that now this day's programming is moving called to Rust,
like all the fonts, code, and all that is moving to Rust with these new fontations libraries,
and all that, so it's like, at the end, Rust is going to be very important for the web platform as
a whole. It also has impact on new web engines, showing that it is possible to write a new
web engine from scratch, like we were seeing, like the web engines that we use these days,
come from like 30 years ago or more, I mean, they come from very old codevases, and all that,
they are like mid-dinners that have been here forever, and at the end, it looked like it was impossible
to do something like that from scratch, and servo kind of demonstrated that was a possibility,
of course, is complex to reach the level of party with the others, but still is a possibility,
and then since then more new web engines have been appearing and all that, and the thing is that,
most of them follow similar principles to what servo was doing since the beginning,
that is basically trying to be as close as possible to the spectrum inology and
the structure and all that, because when you are implementing a web feature, I mean, the spec
has a text that if you also implementation in the different engines, maybe it's not very close to,
and the idea here was try to be as close as possible, so it's easier when there is a back in the
spec, it's easier to fix it in server, because they call try to follow the spec as much as possible,
and also the terms of the things are the same, so that's easier to identify. And then,
yeah, it provided a lot of room for innovation and new things, like servo from the beginning,
was thought to take advantage of the new market architectures that are all multi-core,
and instead of in single-thread, like the regular web engines, it was multi-core from the beginning,
trying to explore that as much as possible, at all the levels, to the point that the layout
engine that was originally designed, that uses parallelings a lot, had to be discarded after
seven years or so, because it was like impossible to implement CSS with doing parallelings for
everything, and now we have in the situation where we can use parallelings for some parts,
but at some point when you get some flows or some things, you need to stop that in that part or whatever,
so trying to explore the limits, a lot of experimentation, new ways to implement
features like CSS and all that, and identify gaps or potential improvements and things like that,
so that's also very, very useful in general. Then, of course, with Firefox, there was a very good
synergies, of course, they are both projects I must see initially, and they share a lot of
components after the work on servo to develop all these libraries, on Rust, they decided to move
some of them to Firefox, and be adopted by Firefox, and they are used these days, and yeah,
that was, I mean, these Firefox quantum projects that they were doing a few years ago, and basically
there are a lot of modules, yes, CSS partners, select or style or web render that are shared by both,
they will think here is that both projects contribute to them, so if servo improves something on web
render, five of will get benefit from it, if five of them improve, several of the same,
so it's very useful that both projects are sharing this and getting, seeing it and all that,
and then more contributors of servo, like WPT, something we talked about before a little in the
morning, is the web platform test, this shared test suite that all the web engines run,
it has like more than two million sub tests these days, and growing, and basically servo
out of things, WPT and both directions, like when there is new tests on WPT, we don't load them,
when there is changes on the test on servo, we upload them upstream, that's why all the engines,
what other engines also do, and since the beginning we have this both running, I mean probably not the first year,
that's very still, that has already landed more than, I mean, for 150 pRs, on WPT,
last year only we landed more than 250 pRs, on WPT, so those are improvements from the servo community
to the whole WPT repository, and that's like, improvement for basically all the engines at the end,
because maybe we find this using other engines to pass, or we increase the coverage there,
and not only that, we also, for example, have to help with the infrastructure storing WPT,
FYI, this website to check the results, that we migrate the Docker image to the next version of
Ubuntu, because that was needed for some of our dependencies, and that was for everybody,
but only for servo. And then, of course, there are also impact on the standard,
you're implementing a new feature, and you are finding issues, it doesn't matter where you implement it,
if it's in Chrome, if it's in server, but especially if you're implementing everything from scratch,
you will find more issues, even, you will find gaps on the specs, you will find lack of clarity in many
parts, and at the end, you're going to be reporting them, you're going to be contributing to those
expectations, and making the specs more clear for everyone, maybe ending up having to fix some
issues on different engines, things to that, and not all of them on the new engines, so yeah,
they're having a lot of issues filled, and the discussions on CSS, HTML, Dom, Fets,
what driver, I mean, everything you implement at the end is likely you need to clarify the
spec or improve it. There are some cool examples of these, like the session history,
it was a long, standing issue on HTML, in the sense that the what was in the spec was not what
any end was implementing, some implementations were doing something different that was was in the spec,
and there was a paper by Connor Bistolang, Alan Jeffrey, that we're working on servo,
16, where they were writing this paper, explaining all these models, how this could be solved
for the web, and how this could be a good solution, at the end that helped to solve that,
HTML use it with all that research, on servo and all that, it helped to solve it, and now the
spec is clear, and everyone follows the thing of that. Similar things, like CSS tables,
having with us, since ever on the web, right, I mean, like the first website, what is in CSS tables,
everywhere, and we were implemented in CSS tables, in the last couple of years,
in the layout 2020, engines of the new engine from scratch, and we found multiple
interop issues. CSS have tables, I've never had a good spec, and that causes a lot of
interop issues, and we have been reporting them, and you can see examples here that,
the rendering of some test cases look very different on bling, then work it's servo,
and get going one case, by in the other case, each of them is different, in the other case,
servo matches link and not get, because a lot of interop issues are nice to be sorted out,
and because that improved the web platform for everyone else. So trying to get some conclusions
from this, like new web engines help the wider web platform ecosystem is not the only useful
for themselves, at the end, you contribute to more, way more things, you improve the web for everyone,
they improve the specs, they help identify interop issues, they increase the test coverage,
they cover many corner cases that were not covered before, they can find bugs in other engines,
and they also provide new ways to use the web, which is also very useful, and help with
the problem we have these days, that is the lack of diversity on the web, which can also help with,
I mean, we have a more diverse web, we will have also, that will be better for everyone,
more inclusive web, and help your platform for everyone, and these days, it's like,
kind of getting more complex, that's so, yeah, it's very useful, and just last few slides,
if you want to join the project, I mean, all the code is in GitHub, if you are curious about
the rest, or you have some rational edge, I want to learn about how it is to develop our web
engine, you can join us, you can come to the solid chat where, and the whole community is,
what are the discussions happening, here you can email us a servo director, and then, of course,
we are very thankful to all this sponsor, we have a lot of individual sponsors and some organizations,
that are the native money to the project, GitHub and open collective, that's very useful,
we are using that money, mostly for the CI, basically continuous integration, running all the tests,
and all that, we have some self-hosted runners that we can have, thank you to this money,
and that have to speed up a lot of time for the developer working on the project,
we are also using that money to sponsor time from just Matios, one of the long-term contributors
to the project that is helping new contributors to join the project, providing hints and guidance
and to interviews, and yeah, we are looking to keep growing the project, growing the community
around it, and to make this happen, and it continues for a long term, and even if you are not
so deep interest, and you don't want to add so deep into web engine development, you can have
the project also by testing it, you can go to the website, download it, it has, I mean, you can run it
on the five platforms, you can report issues, participate in the discussions and GitHub,
basically, play with a project, let us know your experience, how things are going, that's always
very useful, and thank you everyone, you can follow us on this URL, social channels,
I'm of course doing the talk with Shareboy itself, I didn't say before, but this is using
cerebral, this is like, awesome, so we have about five minutes for some questions, if there
are any, okay, I'm curious if there's any effort to keep the API at all similar to web case,
yeah, I will repeat the question, they are asking if there are any effort to keep the API similar
to the one in WebKit, it's not that, I mean, we are starting to draft the API, missing a
getting to a point that many things can be done already, we are following it, basing it on what
WebKit has, I don't know if it's going to be like very similar or not, but I mean, like the idea is
try to cover what work it is used by many people to do applications, if we can have a similar API,
we will have a good one, so that's why we are following it, but yeah, I mean, maybe it's not
exactly the same or not, I mean, we are still not, we in the next few months we are going to have
like the first kind of release of the API, then of course it's going to iterate, but the first
alpha release and then we will see where we can go. I may be wrong, but I thought that the originally
server will start it as a project to replace Kekko in Firefox, are there any plans to again
to join Firefox? I mean, that's, I don't really know how it was started in Mozilla, maybe there
are some one here, I'm sorry to that, I don't know what were the initial plans that Mozilla,
I guess the long-term plan was that maybe eventually it will replace Kekko, at this point, I mean,
we will be happy, of course, if Firefox is server was rendering engine, but I guess it's more
up to Mozilla to decide if they want to try that or not, of course. I didn't suggest that question,
it's wrong, I work from it, yeah, and so it was really a 90 project and we are already
using a lot of part of server, so if you look at web render, style, and some other pieces,
it's already already collaborating a lot with a server project on those pieces, so we don't have any
plan to replace Kekko by server, because we think that there are a lot of work to do with web
contact and so on, but if the quality is good, maybe in one day, the founder is not part of any plan.
That would be great for sure, of course. That would be a great success story for sure, if I
thought I was a lot of shit. All right, I think we're good. Oh, we have another question.
So, server will recently adopted a version release process, has that had any noticeable
noticeable effects on your development process? So far, we are just exploring it, I mean, starting
to have some releases every month, basically, to try to see how that works, try to have a release process
that at least works. And we are exploring with it, I guess, soon, maybe in one two months, we can
release a single one, but it's not going to mean anything special, other than, okay, the release process
is working for us, we can start doing releases. I think that's going to be useful for people that are
playing with it to have a release, you can use and all that, so that's why we are exploring that.
When the fact that the guy got to be fully compatible with other major engines, I mean,
he used that there I still some work to do, some APs to implement, some gaps to fill,
when they expect to, the major part of that work to be done.
Hi, that's a very hard question to answer, because we're incompatible, I mean, like,
there are many, many different things missing, and you can get to one point, but it's going to be
new features here out there, so it's really hard, but maybe for some use cases, it's already
good enough, that's the question. If you need this, just this murder-down viewer, maybe it's
good enough, what servo can do, this day is to render Macdown, you don't need another more
complex engine, maybe, and that can save you. Perfect, thank you so much. Thank you,
you're a huge round of applause for Manille. Thank you.