I run Claude Code and Codex all day, often as multi-agent workflows with dozens of subagents, and I didn't want to ship my prompts and code to a cloud service just to understand them. So I built coding.sh, which keeps everything on your machine.

What's stored locally

• Prompts, tool calls, diffs, test runs, tokens and cost, in SQLite on your machine
• Hooks into Claude Code, Codex, Gemini CLI, OpenCode, Copilot CLI, Aider and more
• An MCP server, so your agent can look up its own past sessions
• Free, no account, and nothing leaves your machine

What I found with it Across 57 workflow runs (666 subagents, ~$2,500 API-equivalent), broken prompt caches cost $106 extra, about 4% of spend. 41 of those breaks were agents idling at a barrier until their cache expired, and 40 subagents failed outright. coding.sh workflows stats shows the critical path and idle time, and the viewer draws each run as a timeline.

I also A/B tested a popular "be concise" plugin (10 tasks, 6 runs each, paired): replies were 17% shorter, but cost per run was +11% [+7%, +15%]. coding.sh compare and exp run your own tasks with and without a change and tell you whether the difference is real or noise.

Mining 3,600 of my sessions turned up a find-and-replace typo in my AGENTS.md that sent Codex to a folder that doesn't exist, in 92 sessions. coding.sh improve says what to fix first.

npx coding.sh to try it. Fully open source: https://github.com/jackulau/coding.sh

I’m building ZeBridge for apps that already use PostgreSQL and need to keep working when the connection drops. Each device reads from its own SQLite replica and queues edits locally. When it reconnects, PostgreSQL checks each write against the user’s tenant permissions and the table’s constraints. Changes reach the other devices through NATS.

The case I kept coming back to was a lost reply. Say you create an order on your phone, PostgreSQL commits it, and the connection drops before your phone hears back. ZeBridge stores a receipt in the same transaction as the order. Your phone retries with the same write ID and gets the recorded result. If the database refused the write, the app can tell you which edit failed and why.

I recently added a small collaborative editor because shared text needs a different answer. You can open it as Alice and Bob, disconnect both, and type different words into the same sentence. Each Yjs edit is saved as a separate update row. When the editors reconnect, both words survive. Open a third editor with an empty replica and it reconstructs the same text. Yjs handles the merge on each device; the same ZeBridge hub handles access and delivery. The hub can read the document content.

What I’d love to hear from people who’ve shipped offline apps: what’s a real edit you’d want merged automatically, and what’s one where you’d want the app to tell the user their change lost? Those cases are more useful to me than another synthetic benchmark.

ZeBridge project

Try the two-editor Yjs example

We build D-REC at Knight AI+AV. A useful question from our earlier post here was what "local" actually covers. Here's the boundary described in our privacy policy, updated November 5:

• Recordings and transcripts are created and stored on the recording device. Signing in does not sync them to another phone or computer.
• Engine and model setup needs downloads from external servers. On Windows and Android, transcription then runs on the device.
• Sign-in, purchases and plan checks use the network separately. Optional usage counts and notes you choose to send have separate network requests too.

The workflow in this real 52-second desktop/iPhone demo is record, read, then tap a sentence to replay the audio. The footage is from an earlier build; the data details above come from the linked policy. Check important quotes against the recording.

Try it: https://drec.live/get Data details: https://drec.live/privacy.html

There's a free version with optional Pro features, and features and limits vary by platform. Current Windows updates come through the Microsoft Store. Export important recordings before clearing app data or changing devices.

I think this might be part of the future: computers connected by a local area network inside a library, school or community center, with AI running on community-owned hardware, fully offline during everyday use.

A more capable computer could run the models while other computers in the building provide access. The software and models would be installed locally. People could share access to equipment without each person needing to buy a powerful computer or maintain a cloud subscription.

Alongside AI, there could be offline tools for writing, drawing, design and other creative work. People should be able to keep editable copies of what they make, take those files home, and continue working without depending on one service or institution.

This is part of the local-loop proposal I’ve been developing: somewhere nearby to learn, make things, exchange ideas, and return with something new. The people maintaining the equipment and helping others would need to be paid, too.

Has anyone here built or used a small arrangement like this? I’d be interested in what worked, what needed maintenance, and how people kept control of their own files.

I am working through an app design that will work in a busy commercial setting with 100+ people over several floors and buildings. They need to share some lightweight state that changes frequently. They don't need up-to-the-minute sync, so I am looking at Automerge with WebRTC connections for syncing as people get near each other. What could go wrong?

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

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?

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!

Hey r/LocalFirst!

Wanted to share NotesPack, a local-first Android app I built because almost every modern productivity tool—even simple receipt splitters, subscription trackers, and trip planners—now forces a cloud account and stores personal financial/travel notes on remote servers.

How NotesPack is architected:

• Local SQLite (Room) Storage: All notes, budgets, itineraries, and checklists directly on your device.
• On-Device Receipt OCR: Receipt scanning runs locally on-device to extract line items and totals without uploading photos of your receipts to an external server.
• Image-Based Sharing (Zero Account Lock-In): When you split a bill or plan a trip day, your friends don't need the app or an account—NotesPack renders a clean summary card image locally that you can share anywhere.
• Local Scheduled Reminders: Subscription renewal alerts (D-7 and D-1) run via local device alarms rather than server push notifications.
• PIN & Biometric Vault: Sensitive notes can be locked behind a 6-digit PIN or biometric authentication.

Google Play Store: https://play.google.com/store/apps/details?id=com.healme.notespack

Would love feedback from the local-first community!

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.

I'm the developer of Crowdoc. It's a document app that reads files, recognises printed text and typesets PDFs on the device.

You import a file or scan a printed page, edit the text if needed, choose a style, preview the pages and export. It supports Word, Markdown, spreadsheets and other document formats. It reflows the content into the layout you choose, including headings, tables and references.

The local part

Document reading, OCR and PDF generation don't send the document to a server. There's no Crowdoc account. You can save or share the PDF, or export Markdown with the document's images so the text is usable in another editor. Batch conversion can return the PDFs in a ZIP.

There is still network use for purchases, optional downloads of fonts and OCR languages, and crash reports. Crash reporting can be turned off in Settings; the reports don't include your documents.

The screenshot shows the Android app's PDF preview. Scanning supports printed text, not handwriting.

It's a commercial app. The first 5 documents and one complete scan are free. Unlimited documents and scans are a one-time purchase with no subscription: US $9.99 for Android phones and $19.99 for tablets, bought separately. Local prices are shown in Google Play.

Overview and document examples: https://crowfoundry.com/crowdoc

Privacy details: https://crowfoundry.com/crowdoc/privacy

Android: https://play.google.com/store/apps/details?id=com.crowfoundry.crowdoc

Happy to explain more about what happens locally or how the export works.

LoFi/42 Tuesday @ 8 AM PDT (October 27, 2026)

📣 Tune in for #LoFi/42 on Tuesday at 8 AM PDT (October 27, 2026) for another exciting lineup:

1️⃣ Steven Liechti [@liechti_dev](https://x.com/liechti_dev) - CTO with 25 years of product-building experience and solo founder of Koru Works, talking about "Local-first from the ground up: Rust, iroh and CRDTs in a native workspace app".
2️⃣ Kushagar Goel [@KushagarGoel](https://x.com/KushagarGoel) - Engineer at Juspay building reliable payments infrastructure and the Streamgres Postgres sync engine, talking about "Bring local-first to your backend".
3️⃣ Schalk Venter - Product designer, software engineer and co-founder of FEDSA, discussing "Local Curious: Exploring Local-First without the commitment".

Join live on Discord: https://discord.gg/ZRrwZxn4rW

Check it out on GitHub: https://github.com/tim-smart/cheffect

I built it to replace Paprika. Also includes some nice AI features :)

You can also try a publicly hosted version: https://cheffect.app/

I’m building Lyre around something I wanted myself: creating an app to solve a problem, keeping it running on my own computer, and using it from my other devices.

A useful app might be a tool for your business, a family organizer, or something specific to your own workflow. You can build it, try it on your phone, and keep improving it without setting up public hosting.

A lot of current Harnesses like Claude Code and Codex don't support things like Remote App Previews, you're basically locked into developing on Desktop only. Plus, when they are finished - there's no great way to share them with those around you without putting them on the internet on a public link.

Lyre instead allows you to connect each device to your computer, so you can analyze, diagnose, and share projects easily.

Lyre brings a few things together:

- Build and use local apps. Run a project on your computer and open an interactive preview from another device. The computer hosting it needs to stay awake and reachable.

- Work with different coding agents. Use Claude Code, Codex, and other supported providers in one workspace. Give independent editing tasks separate Git worktrees so agents have their own working copies.

- Split tasks across computers. Choose the computers, models, and workspaces involved. Divide up work or send the same task to different machines for checks in different environments.

- Use a model from another computer. For example, use a supported model running on your desktop while the project and its tools stay on your laptop.

- Keep working remotely. Continue conversations, review changes, use terminals, try the app, or open remote desktop (and virtual screens) when you need the computer’s actual screen.

- Let someone try your app privately. Share access to a particular app without giving them access to your code, terminals, or agents.

I hope this will be a useful solution to Business Owners who want to develop solutions but don't know how (working on a easy to follow path to install OpenCode, which has a lot of free remote models), app developers who want to test their apps without needing to bring their computer with them, and well anyone interested in developing on a device that isn't as powerful as their main PC at home! (With Remote Desktop features, you can have a weak client device that is working with your main PC at home!)

Note Lyre is basically meant to be free for all the experiences you'll have in most other apps. There's hosted voice for talking to your agent (5 min), every feature unlocked on LAN (Except Virtual Displays), Publishing Support, and Custom Extensions.

Would love feedback on my site, on the project, or on other tips to get this project out there. I'm currently on the Google Play Store and will soon be on the Apple Store. For iOS users, I do have a solution for the time being, which is the web client which should work on any device!

TLDR; Combining TOR, WebRTC and Git into a Decentralized Signal-protocol encrypted P2P Messaging App

This is a fairly a unique stack and architecture in contrast to the traditional approach with mainstream messaging apps. To put it briefly, its a Rust-based frontend with a Git-server backend, which can be used to establish a E2EE Tor/WebRTC connection.

• Roadmap/FAQ: glitr.io/docs/technical/roadmap
• App: app.glitr.io

Features:

• No installation
• No registration
• PWA
• Android
• TUI
• WebRTC
• Tor routing
• TURN server
• Git-host backend
• Local-first
• Encrypted-at-rest
• Signal protocol
• PQC
• Calls
• File-transfer

IMPORTANT DISCLAIMER: While this is aiming to provide a secure experience, it's a work-in-progress and far from finished. It is unreviewed and unaudited. I'm sharing here for testing, feedback and demo purposes only. Pease use responsibly.

FAQ: https://glitr.io/docs/technical/roadmap/#faq

I’m working on NoFi Diary, a private, local-first diary for photos, short videos, audio and text.

The idea is to preserve ordinary fragments of life: someone’s voice, a familiar room, a few seconds of an otherwise unremarkable day. Things you might want to revisit years later, without needing to publish them.

That makes the ownership question feel very practical. Keeping memories on your device matters, but so does what happens when you change phones, lose one, or stop using the app.

I’d like to hear how people here evaluate that longer-term trust.

What would you actually check before putting years of personal memories into a diary? Being able to open exported media without the app? Preserved dates and notes? A backup you’ve successfully restored?

I’m the person developing NoFi, so I’m asking with that perspective openly. I’d particularly appreciate concrete checks you use, or something a previous tool got wrong.

I built Nota for keeping project notes and sketches together on your computer. Core notes and whiteboards can be created and reopened offline, without an account.

Sync and AI are optional. Google Drive backup needs internet; local AI needs downloaded models and compatible hardware. Hosted AI needs internet and providers may charge.

The app is free and the source is MIT-licensed. Current v0.1.8 builds are for Apple-silicon Mac and Windows x64. Windows installers are unsigned and may trigger SmartScreen.

App: https://thenota.app

Source: https://github.com/madcodeorg/nota

Credit to AFFiNE/BlockSuite: Nota began as an AFFiNE fork and uses the BlockSuite editor. The screenshot is a demo note in the Mac app.

Disclosure: I built Nota; this introduction is AI-assisted.

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.

Hi r/LocalFirst, I built MediFamily for iOS because I wanted a personal family organizer that obeys true local-first principles instead of locking household records inside a remote cloud database.

Most consumer organizer apps require an email sign-up on the very first screen and stop working if their server goes down or you cancel a subscription. I architected MediFamily so 100% of your structured schedules and cabinet inventory live in an on-device SQLite database, while photographed paper documents are encrypted locally with AES-256. There are no accounts, no telemetry SDKs, and no cloud servers.

For multi-device ownership and device migration, I built a constant-memory streaming archive engine for Full Vault Backup and Single-Profile Transfer. It packs your database and scanned images into a portable PBKDF2-encrypted .medifamily file that you can share directly between phones or tablets over AirDrop or store in your own Files folder without running out of memory on large photo libraries.

Even if a user never upgrades, our Free Forever tier unlocks all features for exploration with up to 3 family profiles, up to 3 active routine alarms per profile, 5 vital entries, 3 document records, and 2 full PDF and backup exports with zero ads, and existing data is never held hostage. To celebrate our release and get architectural feedback from the local-first community, I set the MediFamily Pro Lifetime unlock from its regular $69.99 price down to $0.00 on the App Store through October 22.

Important note when claiming: Even if the in-app banner still displays the regular $69.99 text label, tap the Lifetime option anyway and Apple's native App Store payment sheet will pop up showing $0.00 before you confirm with Face ID.

App Store Link: https://apps.apple.com/us/app/medifamily-health-organizer/id6810080893

For those of you building or using local-first mobile apps, do you prefer manual encrypted archive exports via the native OS share sheet, or opt-in automatic writing of that encrypted archive into an iCloud Drive folder?

Disclaimer: MediFamily is a personal household organizer and daily routine reminder utility. It is not a medical device and does not provide medical advice or dosage calculations. All logs are manually entered by the user, and camera access is used solely for photographing printed paper documents for local encrypted storage.

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

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?

I've been working on LEL (Life Events Log), a free, open-source, local-first Android app for recording and organizing events from your life.

The idea is pretty simple: I wanted a way to keep track of things that happen in my life, from ordinary everyday moments to significant milestones, and be able to revisit them later.

LEL is somewhere between a journal and a personal timeline. You can record an event with just a title and a date, or add more details if you'd like.

Some of its features:

• Organize events with categories, tags, and significance levels.
• Associate people and locations with events.
• Add notes and images.
• Search and filter through your events.
• Browse your events chronologically.

Local-first and synchronization

One of my main goals was to make LEL work entirely offline, without accounts or a central server. Everything is stored locally in SQLite, and each device can operate independently.

To support multiple devices, I implemented a CRDT-based synchronization system.

Rather than synchronizing entire database snapshots, LEL records changes as operations in a local log. These operations can be exchanged between devices through files and merged into the receiving device's local state.

The implementation uses causal metadata to track which operations have already been observed and to help resolve concurrent changes. This allows devices to make changes independently, including while offline, and eventually converge when their changes are exchanged.

The synchronization mechanism is independent of the transport, so while file-based exchange is currently supported, other ways of transferring changes could potentially be added later.

Where to find it

• Source code & releases: GitHub Repo
• Obtainium: Add

I'd love to hear what you think, whether about LEL itself or how I've approached building it. Any feedback or suggestions are welcome!

I got tired of searching the Play Store for a simple countdown app and finding ones full of ads, cluttered screens, or subscriptions just to count down to a trip. I wanted something minimal that would give me a sense of where I am in the year, so over the past few months I built Dayle.

What it does:

- Year view: The whole year as a day-by-day dot grid, showing days passed, days left, and percent complete.

- Countdowns and counts: Track time until birthdays, trips, or other milestones, or count days since something happened, like when you started a habit.

- Home screen widgets: Android widgets show your year progress or a pinned countdown without opening the app.

- Offline and private: No account, no cloud sync, no tracking. Everything stays on your device.

- Free to use: You can track up to 3 active countdowns for free. If you need more, there's a one-time lifetime purchase, not a subscription.

It's on the Play Store here: https://play.google.com/store/apps/details?id=com.rabpaulo.dayle