use an API client every single day. And for a long time, every single day it was the heaviest app on my machine.
So I built my own. It's called Elisa, it's free, and its Windows installer is 30 MB.
| Client | Windows installer |
|---|---|
| Elisa | 30 MB |
| Bruno | 122 MB |
| Postman | 214 MB |
| Insomnia | 525 MB |
Official installers of each stable version as of October 19, 2026.
This post is about how it gets there, and what I learned building it.
Why not Electron?
Almost every API client is built on Electron. That's not a bad choice: it's mature and it lets you ship one codebase everywhere. But every Electron app ships its own full copy of Chromium, plus Node.js. That's where most of those megabytes go, and it's why five Electron apps open at once feel like five browsers.
Tauri takes the opposite approach: it uses the web engine your OS already has (WebView2 on Windows), and the backend is Rust instead of Node.
For Elisa that means:
- A much smaller download.
- It opens faster and uses less memory, so it can sit next to your editor, your browser and Docker without your laptop complaining.
- A real native backend for the heavy lifting.
The frontend is plain React 19, built with Rsbuild. The same frontend also runs as a web app, so you can try it in the browser with nothing to install.
What Rust does under the hood
The fun part of Tauri is that the Rust side isn't just a wrapper. In Elisa it does real work:
Requests go out from Rust. On desktop, requests are sent with reqwest, not from the browser. That means no CORS, real cookie handling, multipart uploads, timeouts and custom certificates. If you've ever had to tell someone "it works in curl but not in the browser", you know why this matters for an API client.
Scripts run in a sandbox. Pre-request and test scripts run in QuickJS through rquickjs, with a pm.*-style API. Postman collections with scripts can come along when you import them.
Load tests stream live. The load tester runs in Rust with Tokio and streams progress to the UI through a Tauri Channel, so the chart updates while the test runs instead of waiting for the end.
A mock server, for real. You can serve any collection as a local API. It's a small hyper server that answers with your saved examples. A browser can't open a port on your machine, so this one is desktop only.
A real terminal. The built-in terminal uses portable-pty (ConPTY on Windows), the same idea VS Code uses.
Local-first, not cloud-first
The other thing I cared about: your collections are yours.
Everything is stored on your machine first, in IndexedDB. Elisa works with no account and no internet. If you want to work with your team, you can sign in and sync to the cloud in real time, but that's optional, not the price of opening the app.
When you're offline, changes go into a queue and sync on their own when the connection comes back.
What else it does
Lightweight doesn't have to mean basic:
- REST, GraphQL and MCP. You can test MCP servers with auto-generated forms, or turn on "Elisa for agents" so Claude Code or Cursor can read your collections (every change asks for your permission).
- Flows: drag requests onto a canvas and chain them. Capture the login token once and the rest of the flow uses it.
- Code and types from any response: TypeScript, Zod, Go, Rust, Python, C#, Java, Kotlin, Swift and Dart.
- Import from Postman, Insomnia, OpenAPI, HAR or a cURL command.
- Git: save a collection to a folder and commit, branch and push from the app.
What I learned
- Tauri is not "free" size. You give up a bundled browser, so you have to respect the system web engine. Testing on the real WebView matters.
- Moving work to Rust pays off twice: it's faster, and it removes whole classes of bugs, like CORS, that a pure web app can't fix.
- Local-first changes how you design everything. Every feature has to answer "what happens offline?" before it ships.
Try it
Elisa is free, with no account needed:
👉 elisa.develoops.dev
You can import your Postman collection in seconds and see the difference on your own machine.
I'm building it on my own, end to end: the app, the Rust engine and even the little mascot. So feedback means a lot. What's the one thing that annoys you most about your current API client? Let me know in the comments 🙂
Top comments (0)