Our goals

Writing a web engine is not an simple task. There are many components involved, and many things to consider. Our goal is to create a web engine that is fast, secure, and easy to use. We want to make it easy for developers to incorporate our engine into their browser, and we want to make it easy for users to use those browsers. We want to make the web a better place for everyone.

Our current goals are:

• Implement a basic HTML parser that understands HTML5
• Implement a basic CSS parser that understands CSS3
• Implement a basic layout engine that can generate most layouts
• Implement a basic rendering engine that generate things on screen fast
• Implement a basic networking stack that is secure and flexible
• Implement a basic JavaScript engine

🏁 Implement a basic HTML parser

We currently have a HTML parser that can parse almost all HTML5 documents. We are passing almost all tests from the html5lib test suite which is a good sign that our parser is working correctly. There is a lot of room for improvement, as the parser is not the fastest, and we want to deal with invalid HTML in a better way.

🏁 Implement a basic CSS parser

CSS is a very difficult component to get right. Besides user CSS input that needs to be parsed correctly, CSS also defines a lot of properties that have their own syntax. Thus we also have a CSS syntax parser as CSS Value Syntax is defined as a separate language.

At this point we can parse user input, and validate the properties to make sure they are valid. Next up is to make sure the values can be used by the renderer. Based on external inputs like the viewport size, and the properties of the elements, we need to calculate the final values for the properties.

🏁 Implement a basic layout engine

There is a basic experiment running on the layout engine. We are using a simple box model to calculate the position of the elements. The layout engine is currently very simple, and does not support all CSS properties yet. We are working on adding support for more properties, and making the layout engine more robust.

🏁 Implement a basic rendering engine

The current rendering engine is very much intertwined with the current layout engine. Next iterations will separate these two components so both can focus on their own tasks

🏁 Implement a basic networking stack

We use internal Rust crates to fetch data from the web. We are currently working on implementing a basic networking stack that can fetch data from the web, and pass it to the parser. We do have our own DNS resolution system that allows us to use different kind of resolvers, including a custom system to add your own domain names so you don't need to edit /etc/hosts (or windows equivalents), or use a separate dns resolver.

🏁 Implement a basic JavaScript engine

Because of the complexity of JavaScript, we do not create a JavaScript engine ourselves, but use the existing v8 engine for now. The idea will be that this will be pluggable so browser creators can choose their own engine. We are working on a basic API to interact with the JavaScript engine, and are working on a way to make sure the JavaScript engine can interact with the rest of the browser.