Experimental Tauri Verso Integration

Because its main selling point isn't its only selling point. At $work we use Tauri because of the great Rust<->JavaScript API it offers. We wanted an Electron-like JS Frontend that could seamlessly use our existing IPC to talk to a long-running service, as well as being able to offload heavy work to native code. Tauri fits that beautifully.

For our use case don't care too much about the kind of webview it uses and would be fine with shipping a larger binary. Servo integration could be interesting to have one known webview to target if cross-platform consistency ever becomes a challenge

Optionally bundling would help in situations where the OS's native webview has degraded performance https://github.com/tauri-apps/wry/issues/1064

Tauri is an application framework. If you want to use Rust for your application, there's going to be one more option for rendering its UI.

This does make it closer to Electron. We'll see whether Servo can be made leaner or faster (Servo is focused on GPU-based rendering).

Long term, I dream, there could be tighter integration between Tauri and Servo's DOM, so that UI changes won't have to go through JavaScript.

For one thing, not all OSes have a "native WebView".

I think it makes sense if you think of Tauri as a "view layer" for rust apps. If you're building a rust GUI app using something like Dioxus, I could easily see wanting to bundle a cross-platform renderer with consistent "quirks", vs having to adapt your frontend to work with all the platform web views.

It has trade offs in terms of memory usage and binary size, but Electron has already conditioned users to expect every todo and chat app to be 500mb on disk and use a gigabyte of ram at idle. In other words, if Electron would make sense for your project, but you want to use rust, this seems like a good fit.

At some theoretical future time bundling servo doesn't necessarily imply a render process of Rust Tauri UI -> JS -> DOM -> render. It's theoretically possible to cut out the JS step, at which point you'd just be focusing on DOM as a well-supported intermediary between Rust and a very well-tested DOM renderer. In theory.

consistency between platforms

> I thought the main selling point of Tauri was that it uses the OS’s native WebView to create lighter apps compared to something like Electron

It was a talking point for angry at clouds people.

It was never a selling point, because nobody cares how big apps are today. For a regular user with a 256/512 GB drive, even if they had 50 electron apps 1 GB each, it would not matter in the grand scheme of things.

For me the biggest selling point is being able to write application backend logic in Rust. That's a big win.

(OT, about hypothetical BEV rx trailers, moved to a self-replay to make it a little less bad): is this already a thing for caravan trailers? An oversized generator for off-grid camping paired with some battery for load smoothing and a downlink to the car so that it does not require the enormous capacity that would be needed to solve that once-per-year worst case outlier as a BEV. Might even be modular, like a pickup truck, a "power trailer" for adding both range and cargo bed to a car tailored for transporting humans.

For me it's https://github.com/tauri-apps/tauri/issues/3988

Even if it has to be bundled, having the equivalent performance accross OSes is big. Tauri is definitely piquing my interest again because of this.

The potential demerit is: how compliant is Verso compared to Chromium and Safari?

Probably you saw my rant. We are small team, rust shop and we shipped Tauri for a couple years to more than 20k users. Our application is complex and we had a lot of unpleasant debugging to do due to differences in native webviews. Linux performance was just plain bad. We switched to electron, far from ideal but overall the right decision for us at least until Tauri allows bundling of a stable browser.

> because in practice using a native webview loses a lot of the ostensible portability of a browser-in-a-desktop app (they claimed native webviews can differ a lot between OS's)

OS Webview fragmentation was my concern from the beginning, but got pretty much shushed away by tauri proponents. Funny how after years they also came to the same conclusion that a webview running on win8 and one on linux do not necessarily render/behave the same, and the amount of bugfixes/normalisation one would have to include is just to vast.

Still it might make sense if you exactly know the OS distribution of your user base.

Was this someone on the Tauri team, or just third-party speculation?

Apparently, yes, there is movement here:

https://github.com/tauri-apps/tauri/discussions?discussions_...

It's because you aren't a web developer. I faced the same problems. Go make a web app with deno or node and you'll get the same feeling.

It's possible I don't know what I'm talking about, but I believe Dioxus is also targetting cross-platform app development and might be a reasonable fit for you. Here the frontend is written in Rust in their provided UI framework (designed with concepts from the web DOM and learnings from existing web frameworks) and it might be a more familiar approach to a C++ dev who has used Qt or whatever before.

I understand it also has experimental support (possibly still under development?) for a servo/verso render engine, which is why I mention it.

Just FYI one of the developers is looking for a job where they can work full time on Tauri. If it's a big part of your world, it might be worth getting in touch.

This looks far superior or what am I missing?