blitz

I have a working (and not vibe coded) implementation of a "browser engine for apps": https://github.com/DioxusLabs/blitz So far it's only HTML/CSS (and we have our Rust-based framework to write the apps in). But it has been designed for fast incremental rendering, so it could be extended with JavaScript support quite easily.

I'm going to ask the obvious question: why ADA? --- My framework (Dioxus Native - https://github.com/dioxuslabs/blitz) would fit quite nicely into your comparison table: - Compiles to self-contained OS-native app bundle - <10 MB (compiled with Oz) or ~15MB (with O3) (can be golfed smaller) - GPU or CPU rendering - Windows 10+ / macOS / Linux / mobile / wasm / (+ web DOM with Dioxus Web) - Rust - Memory safety: borrow checked - Styling: CSS (support matrix: https://blitz.is/status/css)

I maintain Taffy: AMA. I am currently in the process of building a wider browser engine / GUI toolkit on top of it (https://github.com/dioxuslabs/blitz). As part of that I am implementing a lot of the messier parts of CSS layout (floats, etc), and also grinding on fixing all the WPT tests which we track here: https://blitz.is/status/wpt/css/css-flexbox. The vision is a complete standalone implementation of the web layout algorithms that can be easily embedded (with individual algorithms enabled/disabled on a pay what you use basis), and which can also be part of a modular ecosystem of browser engine components that make it easier for people to create new browser engines. Beyond Blitz, some notable users are: - Servo which uses it only for CSS Grid - Zed which uses it via it's GPUI toolkit.

This is built on top of Blitz (https://github.com/dioxuslabs/blitz): a new modular (open source) browser engine that I've been building for the last 2.5 years. (I wasn't involved in building kitesurf, but I am informed that they intend to open source and upstream their patches)

I've been building for the fast/embeddable browser engine niche: Source: https://github.com/dioxuslabs/blitz Status: https://blitz.is/status/css Typical binary sizes are around 10-20mb, although you can go smaller by doing things like excluding features or compiling with `Os`/`Oz`. There's no JavaScript yet (which can also be a benefit of course!), but people have recently started experimenting, and we may well start on this soon.

> I've always wanted to build a direct-browser integration that could use HTML+CSS for the layout, but avoids needing a JS runtime. Idk how lightweight servo is but one day I hope I will see my idea come to light Blitz (https://github.com/DioxusLabs/blitz) is exactly that. It's a new custom browser engine supporting standard HTML/CSS with a native Rust API (and optional integration with Dioxus which is a React-like UI framework in Rust). Baseline binary sizes are around 10mb. We share a few components with Servo (Stylo the CSS engine (also shared with Firefox), and html5ever the HTML parser), but we've built a bunch ourselves too: notably we have our own layout engine, DOM tree and event handling. Servo is unfortunately tightly coupled with SpiderMonkey, and there is little prospect of removing that dependency in the short term.

Some of the "use html as an output format for LLMs" conversations of the last month inspired me to put together this package. The idea being, if we are outputting HTML, we maybe care less about the idea of HTML-in-browser and more because it's a nice document description format with convenient renderers (browsers). But with things like kitty, I don't think we necessarily need to use a browser and can instead actually render HTML-described documents inline in the terminal itself. So here's kittyhtml. You can pipe HTML to it and it renders the HTML+CSS inline in the terminal itself. echo '<h1>hi</h1>' | kittyhtml It can take raw HMTL, but also is a nice output target for invocations of claude -p. claude -p "create a simple html page. return only the HTML and do not include markdown fences" | kittyhtml Under the hood it's using https://githu

For just rendering (no editing) you could use https://github.com/litehtml/litehtml (C) or https://github.com/DioxusLabs/blitz (Rust). Both are actually lightweight HTML rendering libraries, so you need to compile markdown to HTML to use them. But there are many libraries for that.

Really neat. I think the next logical step is a dom renderer, not a browser, no JS, that can be used directly without a webserver. A library you can send dom commands to and it renders them on the screen. Edit: I guess Dioxus Blitz is that: https://github.com/DioxusLabs/blitz

If you want to use no-Javascript browser as well, this browser prototype [0] is getting pretty good too. It's developed by Dioxus, a GUI framework in Rust, as part of its native renderer which seeks to create their own alternative to Skia, similar to Flutter, but it'll work on the web as well with HTML and CSS standards unlike Flutter web which is just a canvas. It's also a from scratch implementation, sort of, using existing Rust crates like stylo (which servo also uses) and taffy, but it doesn't rely on any code from existing browsers such as Chromium, Gecko or WebKit. [0] https://github.com/DioxusLabs/blitz (in /apps/browser)

I can browse HN fine with both Servo [0] and Blitz [1] (the latter of which is no-JS like Dillo). So I think there might be something Dillo-specific going on here. [0]: https://github.com/servo/servo/ [1]: https://github.com/DioxusLabs/blitz/

There is also my engine https://github.com/DioxusLabs/blitz (which compared to lightpanda: has layout and rendering but does not have JS execution).

I've done a small project with Dioxus on Blitz. It is principally very close to Xilem and in fact is using some of the Xilem components. https://github.com/DioxusLabs/blitz

"Just because you can doesn't mean you should." Wise advice I once got that I didn't follow. I like chasing problems that are quite difficult. Since 2024 I've wanted to be able to run a browser inside my browser. I know you could just do an iframe but I wanted to see if it was possible to render webpages inside webpages without that. I knew Rust would be helpful here because of it's WASM compatibility. But it still required a lot of legwork to get it to work: DOM parsing, CSS layout, rendering, this all had to come together. I started out using cheerpx which can run any x86 binaries, but couldn't find any browsers that would compile to that. So I abandoned that. I then moved onto using Servo (rust browser's engine) and its libraries like https://github.com/servo/stylo. https://github.com/DioxusLabs/blitz brought it all together and render

I'm partial to Dioxus with their native renderer coming up, it should work cross-platform on mobile, web, desktop like Flutter (except web is actually HTML and CSS, not canvas) rather than only desktop which is what most Rust GUI frameworks are targeting. https://github.com/DioxusLabs/blitz