The Vercel platform makes it a collaborative experience with deploy previews for every code change, by seamlessly integrating with GitHub, GitLab, and Bitbucket. Build an optimized, secure, and frontend-independent application for multi-platform deployment. Like any critique, it begs for a prescription and I didn’t give one, other than gesturing toward server-side frameworks like Rails and Django. I had queued up some time to really dive into the frameworks, but things like walking in parks have taken priority, so here’s just a grand tour. Today, GraphQL is being used by several production apps across PayPal. It is now a default pattern to use GraphQL for building new UI apps.
Instead of including a Node.js runtime, Tauri applications are built with Rust, a low-level systems language. This is how Tauri itself interacts with the operating system and “borrows” its native webviewer. All of the Tauri toolkit is compiled , which allows the built application to remain small and efficient.
Connecting The Dots In Public
Digging into and/or adding Rust parts was “bonus material” and is only required if my app requires it. The above defines the redis crate as a dependency and opts into the “tokio-native-tls-comp” feature, which the documentation says is required for TLS support. This creates a src-tauri directory alongside the src directory . This is where all Tauri-specific files live, which is nice for organization.
Many existing apps are in the process of migrating to GraphQL. The Seed templating system uses a macro syntax that makes Rustaceans feel right at home. This means linting, formatting, and commenting will work, and it’s all in Rust. This is opposed to a JSX-like syntax that relies on IDE extensions to improve the developer experience. I built one of the first big SPAs (remember Grooveshark?), but I’ve shied away from them ever since. With an SPA, the entire site or app lives in a single HTML file.
There are some awesome Rust and WebAssembly projects out there. For example, Yew and Seed let you create front-end web apps with Rust in a way that feels almost like React.js. And, of course, SvelteKit certainly made this timeline possible. Not only did it save me a half-day-slog configuring my toolbelt, but the instant, HMR development server probably saved me a few hours of manually refreshing the browser — and then the Tauri viewer.
At Cloudflare, we have a great product called Workers KV which is a key-value storage layer that replicates globally. It can handle millions of keys, each of which is accessible from within a Worker script at exceptionally low latencies, no matter where in the world a request is received. Workers KV is amazing — and so is its pricing, which includes a generous free tier. Then we declare all the possible routes of our application. A hard and fast introduction to Rust-to-WASM compilation and using web-sys to write Rust that runs in the browser. For more information about Rust and WebAssembly, check out the Rust and WebAssembly Book.
But I digress… read this post it’s a good one for sure. My app is basically a browser tab running Svelte, right? Having thought about it for a bit, I decided to use Redis as my backing store because it also is a key-value store.
Connecting To Redis
By using the OS’s native web renderer, the size of a Tauri app can be less than 600KB. Relicensing and redistribution is possible thanks to MIT or MIT/Apache 2.0 licensing where applicable. Hyperapp claims to be twice as fast as React, weighs in at 1.8KB, and renders interactively in ~10ms.
- Instead of including a Node.js runtime, Tauri applications are built with Rust, a low-level systems language.
- The Seed templating system uses a macro syntax that makes Rustaceans feel right at home.
- A hard and fast introduction to Rust-to-WASM compilation and using web-sys to write Rust that runs in the browser.
- Frontend development is not meant to be a solo activity.
- Tauri allows us to send messages across this bridge so that the two worlds can communicate with one another.
- Today, GraphQL is being used by several production apps across PayPal.
That’s the question Jonathan Creamer is here to answer. In so doing, we cover the past, present, and future of frontend tooling. You may prefer other Rust frameworks like MoonZoon or Yew. Heck, even Chris’s disclaimer of ‘when SPAs make sense’ section at the top is easily defeated by our Turbolinks implementation.
However, in order to do this, NodeGui requires some adjustments to your application code in order for it to translate your components into Qt components. While I’m sure this certainly would have worked, I wasn’t interested in this solution because I wanted to use exactly what I already knew, without requiring any adjustments to my Svelte files. By contrast, https://wizardsdev.com/ Tauri achieves its savings by wrapping the operating system’s native webviewer — for example, Cocoa/WebKit on macOS, gtk-webkit2 on Linux, and Webkit via Edge on Windows. Webviewers are effectively browsers, which Tauri uses because they already exist on your system, and this means that our applications can remain pure web development products.
For example, when the /viewer started up, all the keys should be listed and ready to go. In Svelte terms, that means I need to dispatch a Tauri command when the /viewer component mounts. Additionally, clicking on a key name in the sidebar reveals additional “details” about the key, including its expiration , its metadata , and its actual value .
Basically the “…but it works on my machine” problem went away because all of the users were running the exact same localhost setup. Through the Node.js layer, you could interact with the filesystem, run servers on multiple ports, or include a bunch of node_modules to — and I’m just spit-balling here — connect to a Redis instance. Luckily, there are a few alternatives — I evaluated Svelte NodeGui and Tauri. Both choices offered significant application size and utilization savings by relying on native renderers the operating system offers, instead of embedding a copy of Chrome to do the same work. NodeGui does this by relying on Qt, which is another Desktop/GUI application framework that compiles to native views.
Tauri allows us to send messages across this bridge so that the two worlds can communicate with one another. Before Wednesday ended, I had to get my Svelte to talk to my Redis. After poking around a bit, I noticed that all the important stuff seemed to be happening inside the src-tauri/main.rs file.
This starts to matter when dealing with millions of keys which, as mentioned, is not uncommon with Workers KV. So, with the intro out of the way, let me tell you how I built Workers KV GUI, a cross-platform desktop application using Svelte, Redis, and Rust. In this post, I go into details about building a real production app with Hotwire and what we learnt as a team, plus some of the things we don’t like and the problems we bumped into. There’s lots of info out there about building a simple app with Turbo, but there’s very limited content about architecting apps, scaling or building anything that’s not simply a blog. This time we’re arguing whether or not single-page apps were a big mistake. This premise was inspired by Chris Ferdinandi’s SPAs were a mistake post.
However, this also means that we, the application developers, can include any additional crates — the “npm module” equivalent — into the built application. And, of course, there’s an aptly named redis crate that, as a Redis client driver, allows the Workers KV GUI to connect to any Redis instance. Also, as web developers, we expect to bring all our tooling with us. Again, this phase of the project is no different than your typical web application development cycle. You can expect to run yarn dev as your main command and feel at home. Keeping with an “easy” theme, I’ve elected to use SvelteKit, which is Svelte’s official framework and toolkit for building applications.
Next.js powers the biggest websites like Patreon, for use cases in e-commerce, travel, news, and marketing. Our platform enables frontend teams to do their best work. With performance and security at the center, Rust is the language for the next generation of apps. This is a lengthy, sprawling piece on the evolution of frontend development by someone who really gets the web. It also has its own art-direction and design so you’ll want to read it onsite vs in an Instapaper-alike.
As a low level language, Rust is perfectly suitable for making user interfaces the old fashioned way, with native APIs. However, competing in today’s world typically means Buttons or Dropdowns in FrontEnd Development supporting many platforms, and that makes using native APIs an unattractive option for many. Reading data out of Redis is a very similar process, just inverted.