Seems like 4.6 is still all-around better?

https://skyvm.dev/

Nobody offered multiplatform and we really needed it!

https://skyvm.dev

Comments URL: https://news.ycombinator.com/item?id=46649808

Points: 24

# Comments: 2

https://github.com/dioxuslabs/blitz

Maybe we ended up in the training data!

WASM for frontend, at least, has been held back by fundamental tools like bundle splitting, hot-reload, debugger symbols, asset integration, etc. We spent a lot of 2025 working on improving this. Vite and friends are really good!

I've been working on a big Dioxus project recently and am pretty happy with where WASM is now. The AI tools make working with Rust code much faster. I'm hopeful people gravitate towards WASM frameworks more now that the tools are better.

better to crash than leak https keys to the internet

If I were building a company around a new browser, I'd reach for the solid stuff that can be pulled in. Our whole blitz project is designed to be modular exactly for that use-case.

https://github.com/dioxuslabs/blitz

Also I think it's a little ridiculous to build yet another new browser in a new language when so many amazing pieces are just sitting around ready for someone to use. Come contribute, we're already much further along :)

https://github.com/DioxusLabs/blitz/pull/292

I’m not sure what timeline to place on that but there has to be a floor for how bad it can get for the regular man.

Shit is just expensive. Young people can’t buy houses, good jobs are drying up, and inflation isn’t stopping.

To reframe your scenario: imagine you went to a school and some of your classmates came from poor families and couldn't afford clothes, food, or a laptop etc. To help those students, the teacher used class funds to buy them new shoes and get them a nice laptop to get their work done. Do you still think it's unfair that you don't get new shoes, laptop, or cookies?

The solution to your original question is to understand why the teacher is giving girls 4 cookies and then just be happy that more people get a fair shot at life.

I think we played an important role in the community. In our mission we stated we wanted to help bring "equity to STEM education."

In 2025, according to the current admin's stance on "DEI," my robotics team would not be able to receive grants without risk of being sued. It's plainly obvious the line is not drawn at restraining "overly progressive policies" - it's just arbitrarily placed so the govt can pick and choose the winners based on allegiance.

It's a shame that folks with a strong moral fiber are now punished for wanting to help their communities.

We could aim lower, or make it entirely automatic. The first prototype was entirely automatic, but I realized that you definitely need to signal to the program to hot-reload.

For code like:

```rust

while true {

    let msg = io.poll();

```

you're now stuck because the program is hung on a syscall. Doesn't matter if you hot-patch the loop, the program is stuck. My first prototype used the exception tables to unwind the program, but that didn't work on WASM and led to weird issues with cancellation and effects.

Similar issues with one-time initialization code at the beginning of the program. You could just hot-patch from `main` - basically restarting the program - but the whole point of hot-patching is that you can keep as much state around as possible while also changing its behavior.

For most apps, you just need one `subsecond::call()` and it works. The bevy folks wrote a `#[hot]` macro which we might integrate, but I'm also keen for frameworks to just adopt it and/or distribute a simple universal adapter.

That being said, bevy is using bevy-reflect to implement proper struct hot-reloading between hot-patches.

I looked into liveplusplus a lot and their unreal integration also requires a broker to get the most out of it. If you're building a game engine and want to support struct layout and alignment changes, you'll need to do some re-instancing. Hiding a `subsecond::call` deep in the bowels of the host framework hides it from the user and lets the framework handle any complicated state management it needs during hotpatches.

I wouldn't say it's purity - the first version of subsecond actually did do in-process modification - but after playing around with it for a while, I much preferred the light runtime integration. The dioxus integration was about 5 lines of code, so it's quite minimal.

The goal is that frameworks just bake `subsecond::current` into their `tick()` function and end-users get hot-patching for free.