BrowserBox VS vello

Hey HN! Today, we're proud to introduce BrowserBox Pro, a powerful tool for businesses seeking a secure and reliable browser automation solution for RPA, testing, and more. Our goal is to provide an exceptional product that meets your corporate needs while supporting the ongoing development of BrowserBox.

BrowserBox Pro (Polyform): https://github.com/dosyago/BrowserBoxPro

BrowserBox (AGPL): https://github.com/dosyago/BrowserBox

Why choose BrowserBox Pro?

Enhanced Security: BrowserBox Pro is built with advanced security features, providing an isolated browsing environment to protect sensitive data and ensure secure online interactions.

Powerful Automation: Our solution simplifies RBI, RPA and testing processes, offering seamless integration with your existing workflows and saving you time and resources.

Customization & Scalability: BrowserBox Pro is designed to be flexible and adaptable, catering to a variety of use cases and scaling effortlessly as your business grows.

Dedicated Support: We offer comprehensive documentation and timely support, ensuring your team has the resources needed to maximize BrowserBox Pro's potential.

Continued Innovation: By licensing BrowserBox Pro, you contribute to the ongoing development and improvement of both BrowserBox and BrowserBox Pro, ensuring a cutting-edge product that evolves with your needs.

Open Source Commitment: We're thrilled to announce that BrowserBox is now open source under the AGPL license. This enables a strong community around the project, encourages contributions, and ensures transparency in its development. We believe in giving back to the community while offering a robust and secure solution for businesses through BrowserBox Pro.

We invite you to explore BrowserBox Pro and experience the benefits firsthand. If you're interested in learning more or discussing licensing options, please don't hesitate to reach out to us at [email protected]

Thank you for your interest, and we look forward to helping you revolutionize your browser automation experience!

I recently used Ruffle [2] to get some Flash applications [0] working in the Pro version of my web browser [1], which is specifically designed to be remotely accessible and embeddable in an iframe. To run Ruffle on pages that require it, I utilize the Chrome Remote Debugging Protocol [3], similar to how a Chrome extension content script operates. Ruffle itself relies on WebAssembly and runs smoothly. It's been exciting to see the audio and video functionality of these old games restored and being able to play them again.

-

[0]: https://github.com/ruffle-rs/ruffle/wiki/Test-SWFs

[1]: https://github.com/crisdosyago/BrowserBox#bb-pro-vs-regular-...

[2]: https://github.com/ruffle-rs/ruffle

[3]: https://chromedevtools.github.io/devtools-protocol/tot/

I'm looking forward to doing careful benchmarking, as this renderer absolutely looks like it will be competitive. It turns out that is really hard to do, if you want meaningful results.

My initial take is that performance will be pretty dependent on hardware, in particular support for pixel local storage[1]. From what I've seen so far, Apple Silicon is the sweet spot, as there is hardware support for binning and sorting to tiles, and then asking for fragment shader execution to be serialized within a tile works well. On other hardware, I expect the cost of serializing those invocations to be much higher.

One reason we haven't done deep benchmarking on the Vello side is that our performance story is far from done. We know one current issue is the use of device atomics for aggregating bounding boxes. We have a prototype implementation [2] that uses monoids for segmented reduction. Additionally, we plan to do f16 math (which should be a major win especially on mobile), as well as using subgroups for various prefix sum steps (subgroups are in the process of landing in WebGPU[3]).

Overall, I'm thrilled to see this released as open source, and that there's so much activity in fast GPU vector graphics rendering. I'd love to see a future in which CPU path rendering is seen as being behind the times, and this moves us closer to that future.

[1]: https://dawn.googlesource.com/dawn/+/refs/heads/main/docs/da...

[2]: https://github.com/linebender/vello/issues/259

[3]: https://github.com/gpuweb/gpuweb/issues/4306

Dioxus is working on this with blitz. It's leveraging wgpu through the linebender group's Vello renderer. Still in early stages.

If you're doing advanced compute work (including lock-free data structures), then it's best effort.

https://github.com/linebender/vello/issues/42 is an issue from when Vello (then piet-gpu) had a single-pass prefix sum algorithm. Looking back, I'm fairly confident that it's a shader translation issue and that it wouldn't work with MoltenVK either, but we stopped investigating when we moved to a more robustly portable approach.

There are a number of up-and-coming Rust-based frameworks in this niche:

- https://github.com/iced-rs/iced (probably the most usable today)

- https://github.com/vizia/vizia

- https://github.com/marc2332/freya

- https://github.com/linebender/xilem (currently very incomplete but exciting because it's from a team with a strong track record)

What is also exciting to me is that the Rust GUI ecosystem is in many cases building itself up with modular libraries. So while we have umpteen competing frameworks they are to a large degree all building and collaborating on the same foundations. For example, we have:

- https://github.com/rust-windowing/winit (cross-platform window creation)

- https://github.com/gfx-rs/wgpu (abstraction on top of vulkan/metal/dx12)

- https://github.com/linebender/vello (a canvas like imperative drawing API on top of wgpu)

- https://github.com/DioxusLabs/taffy (UI layout algorithms)

- https://github.com/pop-os/cosmic-text (text rendering and editing)

- https://github.com/AccessKit/accesskit (cross-platform accessibility APIs)

In many cases there a see https://blessed.rs/crates#section-graphics-subsection-gui for a more complete list of frameworks and foundational libraries)

blessed.rs lists these three crates for 2D drawing: - https://lib.rs/crates/femtovg - https://lib.rs/crates/skia-safe - https://github.com/linebender/vello

Vello (https://github.com/linebender/vello) which uses wgpu to render Edit: just saw you require images. Vello doesn't support those yet

How does this relate to Vello? Both target raw-window-handle for winit compatibility. Vello uses WGPU vs piet-glow using GL.

Finally, maybe vello could help you with ideas. It's not production ready yet, but they have some interesting ideas for 2D rendering using wgpu.