This is how it's look

🟣 Prism — A Local-First API Testing Tool

Inspiration

Modern developers rely heavily on API testing tools like Postman and Insomnia. While powerful, these tools have gradually become bloated, cloud-dependent, and account-driven for even the most basic workflows.

We wanted something simpler:

No forced login
No cloud sync
No telemetry
No proprietary formats
Just a fast, reliable API testing tool that lives entirely on your machine

Our inspiration was to bring API testing back to its roots:
fast, local, private, and developer-controlled.

That idea became Prism.

What it does

Prism is a lightweight, desktop-native API testing tool built with Rust and Tauri.

It allows developers to:

Build and send HTTP requests
View formatted responses
Manage authentication (Bearer, API Key, Basic Auth)
Use environment variables with {{VARIABLE}} syntax
Save requests as Git-friendly JSON files
Store request history locally with SQLite
Export requests as cURL commands

Unlike cloud-first tools, Prism works 100% offline and keeps all data on the user’s machine.

No accounts.
No cloud.
No tracking.

Just APIs.

How we built it

Prism is built using a hybrid native architecture.

Backend (Rust)

HTTP request execution using reqwest
Authentication handling (Bearer, API Key, Basic)
Environment variable resolution
SQLite-based request history
File-based save/load system
cURL command generation
Async execution with tokio

Frontend (Web UI)

HTML5
CSS3 (Grid, Flexbox, dark mode, custom theming)
Vanilla JavaScript (no frameworks for speed and simplicity)
Modular UI components:
- Request builder
- Response viewer
- Sidebar history
- Auth editor
- Environment variable manager

Desktop Framework

Tauri 2.x for native desktop integration and IPC between frontend and Rust backend
Produces a native application around 10MB in size

Storage

SQLite for local persistence (history and environment variables)
JSON files for portable request definitions that can be committed to Git

Challenges we ran into

Designing clean communication between the frontend and Rust backend through Tauri IPC
Implementing consistent {{VARIABLE}} resolution across URLs, headers, and authentication fields
Creating a stable and portable JSON request format for saving and loading requests
Managing async HTTP execution without blocking the UI
Optimizing startup time and overall performance

Accomplishments that we're proud of

✅ Fully local-first architecture
✅ Native Rust HTTP engine
✅ SQLite-based request history
✅ Environment variables with {{VAR}} syntax
✅ Save and load requests as Git-friendly JSON
✅ cURL export
✅ Keyboard shortcuts and dark mode UI
✅ Cross-platform builds (Windows, macOS, Linux)
✅ App size around 10MB
✅ No telemetry, no cloud, no accounts

Most importantly, Prism is feature-complete and ready for daily use, not just a prototype.

What we learned

Rust enables building fast, safe, and reliable backend systems
Tauri makes it possible to create native desktop apps without Electron bloat
Local-first design greatly improves privacy and security
Simplicity leads to better developer experience
Building developer tools requires careful balance between usability and technical robustness
Portable file formats make collaboration easier and more transparent