Building a Dating App with No Backend: How I used Rust, Tauri 2.0, and P2P Mesh Networking to Fight the Loneliness Pandemic

Ben Sivan — Sun, 17 May 2026 03:50:00 +0000

The Problem: The "Skinner Box" of Modern Dating

Traditional dating apps have a fundamental conflict of interest: if you find a partner, they lose a customer. Their algorithms are designed to keep you swiping, not to help you meet. Plus, your most intimate preferences and behavioral patterns are stored in a centralized database, ripe for data mining.

I decided to build Aura: a dating app that is a privacy-first utility, not a business.

The Architecture: Local-First and Serverless

Aura has no central server. No "matchmaking" algorithm running in the cloud. No user database.

Here’s how it works:

Encrypted Local Storage: Everything—your swiping history, chats, and profile—lives in an encrypted SQLCipher database on your device, managed by a native Rust backend.
P2P Discovery: Instead of a cloud API, Aura uses libp2p to scan for nearby "Resonances." Devices act as nodes in a gossip mesh, propagating encrypted discovery packets.
Store-Carry-Forward: The network is "living." Your phone "carries" encrypted profiles through physical movement, gossiping them to other peers as you move through different areas.

The Tech Stack: Why I switched to Tauri 2.0 + Rust

I recently migrated Aura from React Native to Tauri 2.0. This was a game-changer:

Rust for the Heavy Lifting: P2P networking, encrypted storage, and a local preference optimizer (a tiny ML model that learns your interests and optimizes suggestions) are all in Rust. It’s fast, memory-safe, and handles background tasks beautifully.
Vite + React for the UI: I can build a premium, high-performance UI with standard web tech, leveraging glassmorphism and modern animations without a heavy framework overhead.
Atomic IPC: Tauri’s bridge allows the frontend to talk to the secure Rust core with minimal latency.

Solving Trust: The Relational Reputation Mesh

One of the biggest challenges in a serverless app is safety. How do you trust someone without a central moderator?

Aura uses a Decentralized Reputation Mesh. Your "Aura Score" isn't a global number; it’s a Relational Valence. Your score is calculated locally on your device based on specific gossip you've received. We even implemented Asymmetric Time Decay: negative signals decay 4x faster than positive ones to allow for "redemption arcs" while rewarding long-term positive behavior.

What's Next?

Aura is fully open-source (AGPL v3). I've just finished the F-Droid metadata recipe and am validating the build simulation to get it published.

I’m looking for contributors! If you're into P2P protocols, local-first architectures, or just want to build tech that actually helps people connect in the real world, check out the repo:

👉 https://github.com/bensiv/aura

What do you think about the future of local-first social apps? Let's discuss in the comments!

My Journey to Lua

Ben Sivan — Mon, 14 Jul 2025 20:27:04 +0000

I work in biotech as a full-stack data scientist and solo developer. My work spans everything from building internal user interfaces to designing infrastructure, modeling data, and optimizing lab workflows. I work closely with scientists and build tools that support their day-to-day experiments and decision-making.

Programming is a huge part of how I do that. I came into it relatively late, during my master’s degree in biotechnology, and since then, it’s become one of my core capabilities. Over time, I’ve used R, Python, and Julia professionally. But recently, I’ve found an unexpected favorite: Lua.

A Different Path to Lua

Most people who use Lua either come from:

Game development (e.g. scripting in Love2D or Roblox)
Configuration or extension tools (e.g. Neovim)

My path was gradual and practical. I needed a scripting language that was fast to start, lightweight, and simple to manage, something that could power small utilities and internal tools without unnecessary complexity. Lua met all those needs and more.

The Problem with Bigger Tools

Julia was my favorite language for a long time. It felt like what Python should have been, elegant, fast, and scientific by design. But the more I worked, the more friction I encountered:

Julia’s compilation time is great for heavy computation, but painful for short-lived scripts.
Managing environments and dependencies, while flexible, adds overhead.
Debugging often involves heavy IDEs or complex tooling setups.

Python is more mature in its ecosystem, but I’ve found it often encourages relying on heavyweight packages for even basic tasks, and debugging can be slow or bloated in practice.

Lua: Focused, Fast, and Minimal

Lua is what I reach for now when I want things to just work:

Zero-dependency debugging: I insert a breakpoint and get an interactive REPL on the spot. No IDE required.
Instant startup: Lua scripts run immediately, no waiting for compilers or virtual environments.
Flexible data model: Tables in Lua serve as lists, maps, dataframes, graphs, and more.

It’s not about replacing Python or Julia, it’s about choosing the tool that adds the least friction for the job at hand.

Building What I Need

One of the things I love most about Lua is how easy it makes it to build my own tools. I don’t want to pull in a huge library for every small task, especially when most of the functionality is irrelevant to my specific needs.

I’ve published my own helper library, lua-utils, with functions I actually use day-to-day.

Another project I built is brain-ex, a terminal companion for Obsidian. It:

Parses an Obsidian vault into a structured SQLite database
Adds task management features
Lets me search and interact with notes from the command line, without switching to a GUI

This was all built in plain Lua. No frameworks, no overhead, just simple code that does exactly what I need.

Editor, Style, and Simplicity

While I don’t use Neovim, I do use the Micro editor, which uses Lua for plugin development. It fits my style, lightweight, terminal-based, and unobtrusive.

I also prefer procedural over object-oriented Lua. The language doesn’t force any particular style on you, which I appreciate.

A Language That Stays Out of the Way

Coming from scientific computing, 1-based indexing is the most intuitive to me. But beyond that, Lua keeps my cognitive load low:

No need to vectorize everything like NumPy
No overly clever pipe chains like in R or Julia
Fewer decisions to make means more time solving real problems

In short, Lua reduces brain clutter.

Why Lua Works for Me

Most of my work involves:

Querying databases
Calling APIs
Light data wrangling
Disk I/O
Scripted automation

Basically, gluing different tools together.

Lua is fast and expressive for all of this. When I need something from a larger ecosystem, I still use Python or Julia, but I start with Lua by default.

Not Without Trade-offs

Lua has its quirks and limitations too:

REPL experience is not as smooth as in other languages. Because variables are local by default, interactive development (e.g. line-by-line execution) can feel clunky.
Limited community support for some domains: You won’t find the same level of help from LLMs for Lua as you do for Python.
Not widely used for ML or data science: If you need access to machine learning frameworks or large scientific libraries, you’ll likely need to fall back on Python or Julia.

Still, for scripting, automation, and building lightweight tools, Lua is perfect for me!

DEV Community: Ben Sivan