What does HackerNews think of tauri?

Build smaller, faster, and more secure desktop applications with a web frontend.

Language: Rust

#1 in Rust
Looks like it's so small because it uses Tauri, which uses the system webview rather than bundling its own browser engine: https://github.com/tauri-apps/tauri
Not by any means a solution to all Electron problems, but Tauri[0] is promising.

0 - https://github.com/tauri-apps/tauri

These days I’ve been absolutely impressed with Tauri:


The documentation needed a little bit of work last time I looked but they’ve made so much progress in such a small amount of time.

Also having Rust underneath it all is a huge plus

Most GUI apps don't need what Qt provides though. They mostly need stability and cross-platform support, so ... they should start with something like Tauri or Sciter, and if there is something they need natively they will be in a much better situation to pick their poison.

https://github.com/tauri-apps/tauri uses OS provided WebView

https://github.com/sciter-sdk/rust-sciter uses Sciter

Maybe ask yourself why people chose to use Electron. The cross platform alternatives (Tauri[1] pops to mind) generally offer a more complex development experience. As long as web languages remain the lowest entrypoint they will remain the dominent force, even if they're less performant.

1: https://github.com/tauri-apps/tauri

I suggest to take a look at tauri[1], lorca[2](requires chrome to be installed) or webview[3](uses system webkit). If you're interested I made a small poc that can be shipped as a single binary file with webview and react - https://github.com/snehesht/goview

1. https://github.com/tauri-apps/tauri 2. https://github.com/zserge/lorca 3. https://github.com/webview/webview

According to https://github.com/tauri-apps/tauri they are using "Node.js for running the CLI (deno and pure rust are on the roadmap)"
yeah tauri is some progress and flutter webview is also is ok if you only care about ios and android but its not enough.


For reference I'm taking my shot with https://github.com/wailsapp/wails (webview2 supported on Windows) and https://github.com/mozilla/pdf.js for a PDF processing related use case.

Wails because I imagine extensive Golang based services (preference/experience) in any cloud env. .NET would be my other approach for O365 based integrations.

Rust has something similar to wails, https://github.com/tauri-apps/tauri . Then there all the traditional native vs cross-platform methods.

No approach, or cross platform framework, really seem quite right. But I figure time and money would be the important factors in any serious avenue I want to take things.

The white app screen was an issue I ran into before as well. The error would frequently mean you had some error in your bundling or configuration which would prevent the frontend page from loading (hence, the white screen). The template doesn't have this issue.

Tauri (https://github.com/tauri-apps/tauri) uses less memory, but relies on a different browser so your app may be inconsistent cross-platform.

According to Tauri's documentation (https://github.com/tauri-apps/tauri) minimal app:

                                    Tauri   Electron

    Memory Consumption Linux        180 MB  462 MB

Note Tauri is full fledged Client/Server with WebView (client) running in separate process with RPC between UI process and Rust code (Server).

For the comparison:

Standalone Sciter (scapp.exe, https://github.com/c-smile/sciter-js-sdk/tree/main/bin) takes ~8 MB of RAM (with minimal Cairo and GDI backends).

That's 20 times less than even Tauri.

WebView based solutions are not suitable for applets - small portable desktop applications.

If anyone wants to know how it works:

> [leverages] WebKit on macOS, WebView2 on Windows and WebKitGTK on Linux.

So cross-platform compatibility isn't guaranteed, unlike Electron.


I've never used it, but I've heard good things about Tauri: https://github.com/tauri-apps/tauri
Heck if it's a general purpose web app - ie not only Chrome, maybe give Tauri[1] a try?

[1]: https://github.com/tauri-apps/tauri

I just opened this today, what a nice coincidence to see it here. I want to create a cross-platform app to show some information on a Git repository. I do not have many UI widgets, it is just a visualization in a way. I also want to continue learning Rust. So I want to create this in Rust, but I am not sure if that means my project will take many many months. I thought of desktop web-app too, using Tauri (1), if this effort is too much.

1. https://github.com/tauri-apps/tauri

It's a webview wrapper.

> ...the Tauri-team incubated and maintained WRY, which creates a unified interface to the system webview (and other goodies like Menu and Taskbar), leveraging WebKit on macOS, WebView2 on Windows and WebKitGTK on Linux.


Hey - I am nothingismagick aka Denjell, one of the founders of Tauri, and will do my best to answer your questions about the project, rust, wasm, etc.


I found Wails very simple to use, and would highly recommend it to anyone looking for a lightweight GUI library.

However, Wails v1 uses mshtml (basically ie11) on Windows, so some features are unavailable.

Wails uses Webpack so you need npm installed when developing your app.

You might also be interested in Tauri [1] which is a similar framework but in Rust.

[1] https://github.com/tauri-apps/tauri

I agree. And it's sort of perverse, isn't it? At least they’ll have extensions soon (or they do, already?) so it’ll become more usable. I would gladly use Safari on desktop, too. The graphics are excellent, which is one of the reasons I’m excited about https://github.com/tauri-apps/tauri
Have you looked at https://github.com/tauri-apps/tauri as a more lightweight and Rust friendly alternative to Electron ?
I feel you. A CLI is on our roadmap, as well as moving to a lighter-weight app container[0]

[0]: https://github.com/tauri-apps/tauri

If people complain about the binary size and/or memory usage, one tip would be to see if it'll run with either NW.js or Tauri, should be close to a drop-in replacement.

Tauri is even smaller than NW.js (I think ~600kb hello-world binary size) but uses Rust in it's toolchain way under the hood to build, so take that as either a positive or a negative.


NW.js is essentially lighter-weight Electron.


Would be neat if it was a straighforward implementation and produced tiny self-containing cross-platform binaries.

Disclaimer: I also have no idea how gamedev works though, so this might not be applicable

I just recently discovered https://github.com/tauri-apps/tauri

It looks like a good alternative to Electron but haven't tried. Anyone?

I'm confused. How can a full HTML/CSS/javascript engine fit in 600KB? It is not clear to me from the article.

Edit: It uses the OS-native engine https://github.com/tauri-apps/tauri

There's always Electron, Wasm, and the few smatterings of decent GUI frameworks being worked on. Also https://github.com/tauri-apps/tauri which claims to be a... Light, more native Electron?

Just depends what you want. A common pattern is essentially to build your app as a Rust library or CLI binary that your GUI wraps in whatever is most convenient for the GUI

Keybase is a little like "Linux on the desktop". I love it, I use it. With my help, even my dad can use it. The underlying architecture is righteous, it's open-source, and I want it to be good enough so that everybody can use it... but it's just not. Too many basic things that "normal people" want to do just don't work well enough.

Keybase's desktop and mobile apps sometimes hang while decrypting old messages, and until you force quit, the messages won't load.

The Mac app gets into this mode where it can't be hidden, and just insists on staying on the screen.

It doesn't work at all, for any reasonable value of work, on the iPad (it shows a tiny little phone-sized window that fills about 25% of the screen, and doesn't support rotate so it's rotated 90 degrees if you try to type into it with the keyboard).


OTOH, the underlying platform seems well-designed and that's obviously where most of the effort is going — it's been a steady march of new and valuable features. They only added the chat feature itself 3 years ago. Keybase git, Stellar wallet, Keybase SSH, the awesome new bot architecture...

While I too wish the apps were smooth and polished, Keybase might be right to focus on the platform first. Making a good app using cross-platform UI toolkits is hard.

Those toolkits are evolving fast, too. It's not inconceivable that in another 3 years, the apps they have today will have been completely replaced by new ones based on a next-generation UI library that runs on top of Tauri[1] or whatever the new hotness is in 2023, and maybe those will be smoother and more polished due to general advances in cross-platform app cores and UI libraries, and if that happens we might end up being glad that the Keybase people spent their energy on building out this reliable crypto platform instead of trying to fix Electron's window layering bugs or whatever.

But yeah, in 2020, I agree the Keybase app's aren't even close to being polished enough to replace Slack for most people. (And Slack itself is pretty awful!)

[1] https://github.com/tauri-apps/tauri (no idea if that will take off, it's just an example)

For other types of security try https://github.com/tauri-apps/tauri

It is an electron-like framework written in Rust, and is designed to be as lightweight as possible.

zserge’s webview has been adopted by a bunch of maintainers who made Rust bindings for it. They have forked webview to continue maintaining it, and are now gradually rewriting it in Rust.


Made on top of that is Tauri, a cross-platform webview-based app just like WebWindow. The key differentiator being that they are actually committed to continuous development as they’re trying to get established as an open source company.