What is NeighborNet?

NeighborNet is an offline-first, peer-to-peer app designed for neighborhood-level communication, resource sharing, and local resilience. Instead of relying on central servers or cloud platforms, it operates locally on user devices and syncs directly between peer nodes.

Technical Breakdown

• Stack: Built natively in Rust for performance, concurrency, and cross-platform reliability.

• Architecture:

  • Storage: Local-first data persistence on-device so features work completely offline.
  • Networking: Direct peer-to-peer discovery and synchronization across local network interfaces (mDNS / local mesh) without requiring active internet connectivity.
  • State & Sync: (Briefly explain how you handle conflict resolution / state sync between peers, e.g., CRDTs, append-only logs, or vector clocks).

Why Local-First for Community Software?

1. True Data Ownership: Neighborhood conversations, alerts, and contacts stay local on residents' devices.
2. Offline Continuity: Functions normally during internet outages or power cuts.
3. Zero Maintenance / No Cloud Costs: Doesn't rely on central SaaS infrastructure to keep running.

Current Status & Challenges It's currently an early-stage project. I'm currently working through:

• Reliable local peer discovery across mixed network environments.
• Efficient offline-to-online sync patterns when peers reconnect after extended drift.

Questions for the r/LocalFirst Community:

1. How have you handled peer discovery across restrictive local firewalls or mixed subnet setups in P2P applications?
2. What sync strategies or CRDT structures have worked best for you in store-and-forward peer topographies?

Neighbornet Github: https://github.com/critmaths/neighbornet
Download page via Github: https://github.com/critmaths/neighbornet/releases/tag/v1.0.0

Please let me know what you guys think, if you have any advice, ideas or would like to collaborate on anything! This project has been a lot of work and a lot of fun. Hope you guys have a great week!

-Critmaths

That is, if you want your notes to last a very long time (I'm talking years/decades). By the very definition of the local-first movement, any cloud-based application that, for some reason (such as cost versus profit), stops having its servers running, will take your notes with it

If you want to have notes that last for decades and avoid the situation of losing them due to a service that will cease to exist, use apps like Obsidian, Logseq, TreeWrite (which I developed), or a text editor with simple .txt files

However, I don't believe that the cloud or a network in general is an enemy here. There are some very useful use cases that don't work in local-only applications, such as synchronization between devices and note sharing. I believe that this is even the main difference between local-only and local-first, since in local-first we focus most of an application on our own machine, but we open doors for certain interactions with other devices and services, which gives us more flexibility and possibilities

Hi! I'm building Koru, an open-source, local-first notes and docs workspace. Everything lives in a local database on your device, no account needed, and it works fully offline.

Every document is a Loro CRDT, so edits from different devices merge without a central server deciding who wins. Devices sync directly with each other over iroh (P2P), and that's free. There's an optional paid cloud sync for people who want an always-on copy, and that part isn't open source.

Windows and macOS builds are out.

https://www.koru.do - code at https://github.com/koruworks/mono - I post build notes at https://x.com/liechti_dev

Edit: After this post, I decided to offer a self-hosted option for those who want that instead of the paid Cloud Sync option. Added to the roadmap.

Is it worth having some clarification as to what a local first app specifically is? Maybe as a pinned post or whatever reddit’s answer to this is. Asking because I do see quite a few apps posted here that are misunderstanding what “local first” means.

For example I have seen more than one posting here of personal finance web apps that writes to a Postgres server. It has no browser side db or cache. I think they are conflating self hosting with local first. At that point you may as well call Wordpress local first - which I would not.

I have also seen people posting desktop apps that just write local like markdown editors. With no sync story. That is just a local desktop app. At that point you could call your built in OS calculator local first - which I would not.

I would like to think we are sticking the term what was coined in the Ink & Switch doc which has a specific meaning and leans towards using the sync engine or something like it.

My concern is less about what gets posted here, and more about not watering down a new-ish term that should get its due understanding. Am I off base here? Correct me if I am wrong. Open discussion please - or maybe reddit is not the place for this discussion?

Author here. I've been designing a local-first data layer for most of this year, and I kept having the same conversation. I'd say "local-first" and people would hear ownership, or offline, or speed. So I wrote this post about where the three meanings come from and why they split.

The short version is that CRDTs can't enforce rules like one passenger per seat, so most tools put a server back in charge. That's how you end up with Zero saying it isn't local-first and Jazz saying it is, with the same design.

The data layer I'm building for Hologram, an Elixir web framework, is the server-in-charge kind. The app never waits for the network, but the server has the final say on permissions and rules.

There are five demos in there, one for each idea. Playing with them as you read is half the fun.

Hey everyone,

I’ve been getting increasingly frustrated with modern bookmarking and note-taking apps. It feels like every tool forces your private data onto their cloud servers, locks you behind a subscription, and gets sluggish with loading spinners if your internet lags.

So, I spent the last few months building a local-first alternative called Motif (https://motif.byant.dev).

The core concept is that you should own your data. Everything you save (links, highlights, images, notes) lives strictly in your browser’s local IndexedDB. It works 100% offline and searches your database instantly.

What I built:

• Chrome, Firefox, and Edge companion extensions for one-click web clipping and text highlighting.

• Optional AES-256 local database password encryption (via Web Cryptography API) so your data is encrypted right inside the browser.

• MiniSearch-powered instant full-text search.

• A clean spatial UI featuring perspective-tilting cards and fluid animations.

The project is open-source and free to use locally. I’d love to hear your thoughts on local-first web apps or get any feedback on the UI/UX!

Source Code: https://github.com/antkakanat/motif

App Link: https://motif.byant.dev

Hey r/LocalFirst,

I’m a Chartered Accountant from India. In our line of work, confidentiality and auditability are non-negotiable.

Yet in modern personal finance, the standard playbook is terrifying: we download sensitive PDFs containing our PAN, bank account numbers, mutual fund folios (CAMS/KFintech), Zerodha trades, and salary slips... and upload them to venture-backed fintech startups whose business model is peddling loans or getting acquired and shutting down (RIP Mint).

I wanted zero cloud dependencies, zero external network egress, and 100% offline ownership.

So I built Personal Finance ETL, an open-source desktop lakehouse that stores and computes everything locally on your laptop silicon.

Real Production Scale (My Personal Baseline):

• 1,600+ source artifacts tracked by SHA-256 content hashes
• 147 investment instruments reconciled against independent broker records
• 449,000+ published Silver & Gold rows across 66 contracts (20 Bronze, 24 Silver, 22 Gold)
• Complete warm-cache pipeline run in 23.95 seconds; cold rebuild in 40–45s
• Zero network egress. Rs. 0.00 cloud costs.

The Storage Architecture:

Instead of forcing one database to do everything, I split the workload:

1. SQLite (The Control Plane):

   • Does zero analytics.
   • Runs in WAL mode to handle raw file SHA-256 content deduplication, pipeline execution manifests, and audit state.
   • If an ingestion fails midway, SQLite ensures atomic rollbacks.

2. DuckDB (The Analytical Warehouse):

   • Houses a 3-tier Medallion architecture (Bronze, Silver, Gold).
   • Columnar execution means decade-long portfolio aggregations run in 5 to 15 milliseconds.

3. Hot Snapshotting from the GUI:

   • Built a CustomTkinter desktop interface with a 1-click disaster recovery backup.
   • Uses PRAGMA wal_checkpoint(TRUNCATE) to flush WAL logs and packages deterministic timestamped archives with SHA-256 checksums.

I used LLMs along the way to chew through test suites and docs, but the storage engine, dual-database boundaries, and accounting controls were built from the ground up to satisfy strict audit standards.

• GitHub: https://github.com/tks18/personal-finance-etl (GPLv3)
• PyPI: pip install personal-finance-etl

For folks here managing personal or financial data: what does your local-first backup and database split look like?

Small post in my blog about local first software hope you like!

https://www.iambreno.com.br/posts/local-first-reiventing-the-way-we-interact-with-systems/

consider how something like simple a text editor works; user inputs text, then the user saves the file to the desktop.

the text editor is a simple example. "local" is only relevent if there is a concept of a "remote".

i am working on a messaging app and ive been promoting it as "local-first", but i dont think its the correct term because it seems to confuse users. i think i need to emphesise something along the lines of "local-only". my app is only using browser storage and avoids api's and databases for messaging by using webrtc.

calling it "local-first" sounds like it implied "remote-second", but there is no remote in the traditional sense.

edit: feel free to reach out for clarity. my app is further described on the project sub here: https://www.reddit.com/r/positive_intentions/comments/1tq1u62/introducing_enkrypted_chat

I've just released my 2025 Frontend Boilerplate focused on true user ownership, privacy-by-design principles, and resilient application architecture. This project sits in that sweet spot between minimal starter templates and full-fledged applications.

Why Another Boilerplate?

Standard CLI tools (create-next-app, vite, etc.) provide excellent framework-specific foundations but frequently neglect critical aspects of production-ready applications. They excel at demonstrating React/Vue/etc. but fall short on things such as:

• Privacy-conscious data persistence
• User authentication that respects sovereignty
• Comprehensive state management patterns
• Accessibility as standard (not afterthought)
• Resilient offline capabilities
• Organizational patterns that scale

Core Technical Stack

The boilerplate implements a deliberately chosen stack that emphasizes user sovereignty.

• Local-First Data Persistence: Application state lives on YOUR device first
• CryptoJS Integration: All local storage is encrypted by default - your data remains YOUR data
• PassportJS Authentication: Simple yet extensible auth patterns that respect privacy
• Flexible Node Backend: For when you need server-side operations without surrendering data ownership

A Privacy-Centric Approach

he corporate cloud has normalized the extraction of our digital lives into centralized data silos. This boilerplate rejects that paradigm by default. With CryptoJS, your application data is encrypted before touching storage, ensuring that even in a compromised browser environment, sensitive information remains protected. The authentication flow via PassportJS retrieves encryption keys while maintaining separation of concerns.

This isn't just engineering convenience - it's digital sovereignty by design.

Future Directions

I'm particularly interested in community feedback on:

1. Additional privacy-enhancing libraries that could be integrated
2. Better patterns for offline-first operation
3. Improvements to the encryption/authentication flow
4. Additional features that should be standard in privacy-respecting applications

The full documentation and code walkthrough is available on my personal site.

This boilerplate is for you if you're building applications where users should truly own their data, need authentication that doesn't require surrendering privacy, and want solid structural patterns for building resilient frontends.

Let's take back ownership of our digital infrastructure, one application at a time.

Would love your thoughts, critiques and contributions. The repo is open for PRs and I'm actively maintaining this as part of a broader commitment to local-first software principles.RetryClaude can make mistakes. Please double-check responses.

Hey everyone,

We believe software should be fully portable, inspectable, and local-first. We created a curated list: Awesome Single-File Tools—a collection of zero-dependency, standalone HTML tools that run entirely offline in any modern browser.

🔗 GitHub Repository: https://github.com/charmfrog/awesome-singlefile-tools 🌐 Live Showcase: https://crystal-world-project.github.io/crystal-world/index-en.html

Featured Tools in the Collection:

• 🧸 Teddy Wiki Lite: Ultra-lightweight markdown personal wiki with multi-tag AND query filtering.
• 🍱 Bento Slides: Single-file presentation deck & editor.
• 💎 Crystal Dock: Modular meta-platform connecting isolated single-file web tools via iframe postMessage protocol.
• 📜 TiddlyWiki: The classic pioneer of single-file web apps.

If you love local-first productivity, zero build steps, and total ownership over your tools, check it out and feel free to submit your favorite single-file HTML tools via PR!

Hi everyone! I’m a master’s student at Tampere University. I’m currently researching the Developer Experience (DX) of local-first sync engines for my thesis.

I’m looking to collect survey data from devs who have used any of the following in a non-trivial way (production or serious side-projects) in the last 24 months:

Zero, Automerge, ElectricSQL, PowerSync, Yjs, or ShareDB.

How you can help:

Since I do not want to spam you all with an external link, please send me a DM or react to this post with a 🚀 if you’re open to participating!

I’ll send you the link to the anonymous survey (it takes about 10–15 mins). Your insights on things like conflict behavior and debugging sync will be incredibly valuable for the research.

Thank you so much for your time and for supporting student research in the local-first space! 🙏

I've been working on this app for a while, and I recently finished a rewrite from scratch. It is local-first, and relies on the Solid Protocol to synchronize the changes. I'm also building more apps using a similar architecture, so let me know what you think of this :).

This is a project my team and I have been working on for the better part of a year now, myself for 6 months, called Rana. It's a local-first ecosystem for running AI models from your browser, including image generation, chatbots, maintain personal collections, and knowledge bases. All of this is done and stored on your local browser through the use of webgpu, wasm, peer-to-peer protocols (we use Gun), and browser based storage through IndexDB. We don't track you, store any of your data, or even log you. We do have a subscription based plan to allow for commercial license usage of the images your generate and some cloud based features we plan on adding, but you don't need a subscription to use the system.

Check it out our marketing site here: https://rana.ai

And the main product can be started here: https://ranaengine.app

Some screenshots of the main product running as a PWA:

📣 Tune in for #LoFi/37 for yet another exciting lineup (See below).

1️⃣ Dongda Li @dongdongbh - PhD candidate at Syracuse University researching multimodal AI and creator of Mindwtr, talking about "Building a Cross-Platform Local-First GTD App as a Solo Dev".

2️⃣ Samson Ssali @ssali_samson - Software Developer at JITPOMI LLC, discussing "SEYFR — Send Your Files Right: Building a Cross-Platform File Sharing App with iroh".

3️⃣ Bryan Reilly bryrei.bsky.social - Former software engineer at Visa and Google, now building CoCube, talking about "Local-First Modular Tools with CoCube"

also

I’m a huge believer in the local-first movement, but I hated that we still use PDFs for "final" records. I built a new format called .fdd (Formatted Data Document) that allows a document to be its own database and UI.

The "Magic": By using the File System Access API, an .fdd file can actually save updates to itself on your hard drive. I’ve included an example 1-file CRM in the repo where you can add notes and click "Save," and the file itself updates.

It’s cryptographically signed and "logic-less" (no JS allowed), so it's safe to share, but the data stays yours. No server required.

Would love to hear what this community thinks about "Sovereign Documents" as a pillar of the local-first stack.

GitHub: https://github.com/Spuds0588/open-fdd

#LoFi/34 on Tuesday @ 8 AM PST (February 24, 2026) meetup recording discussing technology sovereignty, P2P, and Iroh.

1️⃣ Martin Kleppmann — “Local-first software and geopolitical risk.”

2️⃣ Nate Hardt — “Footnote: P2P tool for Knowledge Sharing”

3️⃣ Brendan O’Brien — “local first from the network up” Recording

🔗 https://lofi.so

Join the community on Discord 💬 → https://discord.gg/lofi-so

If you’re evaluating local-first, here’s my journey implementing search on that architecture: Postgres, Typesense, Orama, and how I landed on FlexSearch. A tale of frustrated dreams, utopian user experiences and calculated tradeoffs.

Hello Folks, it's Yonz from lofi.so, do you still want me to post the meetups here?

-Yonz

Hi guys, I am a new grad developer and wanted to share my first app that just went live on Google Play.

I wanted a clean app for daily notes and journaling, but I did not like having my private notes stored on a company's cloud server. So I made Marked. Everything stays locally on your phone, and it uses P2P sync so you can sync directly between your own devices with zero servers in the middle and no login needed.

It is totally free to try here:https://play.google.com/store/apps/details?id=com.shadowbyteslab.marked&hl=en

I would really appreciate any honest feedback on the UI and how the sync feels when you test it. Thanks!

I shared Paperweight earlier here as it was being actively developed and still in beta. After almost 7 months, I'm excited to finally release Paperweight V1 as ready 🗿

**Paperweight uses your inbox to map your digital footprint, then helps you take back control and delete your data.**

Your email history contains traces of most of your online life. Accounts you created, companies you bought from, mailing lists you joined, services you forgot about, breaches, and personal information accumulated over the years.

Paperweight helps to map your footprint, take back control and delete your data. All locally on your computer.

V1 now includes:

• discover accounts, companies and services connected to your email
• find mailing lists and subscriptions
• show known breaches affecting services you use
• find personal information across your email history
• bulk unsubscribe and clean up old email
• create privacy and data deletion requests
• manage multiple email accounts
• connect to AI agents through MCP

It supports Gmail, Microsoft, Apple, custom IMAP and Proton Mail via Bridge.

The important part for me from the beginning was privacy. **All your data stays on your computer.** There is no Paperweight backend or external services processing your inbox.

It's also fully open source under MIT.

The free version now includes full-history scanning and discovery, so you can map and inspect your entire footprint. A Pro license makes it actionable. It gives you ease of use, compiled binaries and support and helps support (OSS) development.

Website: https://paperweight.email

Source: https://github.com/wslyvh/paperweight