Tauri plugin lets developers write app backends in JavaScript instead of Rust

A Tauri backend without Rust

A developer has released tauri-plugin-bare-kit, a plugin that embeds a standalone JavaScript runtime inside Tauri applications, according to a post on dev.to. With it, the backend of a desktop or mobile app can be written entirely in JavaScript, and the only Rust a developer needs to touch is the single line that enables the plugin — though logic can also be split between JavaScript and Rust if a project wants both.

What Bare and BareKit are

The plugin builds on Bare, a JavaScript runtime created and maintained by Holepunch. Per the post, Bare sits on libuv and V8 — the same foundations as Node.js — but treats embedding and cross-device support as core design goals rather than afterthoughts, aiming to run as well on a phone as on a laptop. The V8 engine can be swapped for alternatives such as JavaScriptCore or QuickJS.

N-API addons are supported out of the box, which is why most modules on npm run unchanged. Bare ships without Node's built-in modules, but the post notes that official replacements exist for them.

BareKit is the companion toolkit that makes embedding Bare in other applications straightforward, with bindings for several languages. It provides a web worker-like API for launching and managing isolated threads, called worklets, which expose an IPC abstraction. That IPC is a plain duplex stream, so developers wanting an experience closer to Tauri's native IPC would reach for a library such as bare-rpc.

How the plugin wires the two together

Because Tauri splits an app between a webview frontend and a Rust backend, runtimes like Tauri or React Native need extra plumbing to host another runtime. The plugin calls the BareKit C-API through FFI — an interface the author describes as stable but not yet fully public — to tie BareKit deeply into Tauri. From the webview, you initialise a worklet, start your JavaScript on it, and get two-way communication between code running in the webview and code running on Bare.

The plugin also handles the unglamorous parts. Native addons are autolinked during the application build on all currently supported platforms: Windows, macOS, Linux, iOS and Android. Backend logic can optionally be packed into a Bare bundle that the frontend simply imports, and manual packing is possible with a tool called bare-pack. The author says there is essentially no configuration to manage — postinstall and build scripts take care of everything, although the postinstall step requires allowing scripts to run at install time.

Security caveats

Backend code running on Bare is not subject to the restrictions that frontend code in the webview faces — through native addons it can reach the filesystem and operating-system APIs. The author flags this explicitly: never run code you did not write yourself on a worklet. Loading remote code into a backend is not a common practice, the post adds, but it would be a bad idea regardless.

Where Rust is still required

The plugin does not expose Tauri's own APIs to Bare, so apps that need deeper OS integration or more complex behaviour will probably still require at least some Rust code. For simpler apps, though, the Rust surface shrinks to the one line that registers the plugin.

Why it matters

Tauri's appeal — smaller bundles and native performance compared with Electron-style apps — has always come with a catch: backend logic lives in Rust, which is a steep climb for developers arriving from JavaScript. This plugin removes that climb for a large class of applications, and because most npm packages work unchanged, existing JavaScript skills and libraries carry over directly. It also reflects a practical motivation rather than an ideological one: the author built it because they depend on the Holepunch stack, which exists primarily in JavaScript and has no full Rust equivalent yet. The trade-offs are real — a backend with unrestricted filesystem and OS access demands careful handling of what runs on it, and anything beyond moderately simple apps will still dip into Rust. For web developers who want Tauri's footprint without first learning a systems language, though, it meaningfully lowers the barrier to entry.