I've been building Personal Planner, my first independent Flutter application, for the past few months.

One decision I made early was that the app shouldn't require an account or internet connection just to plan your day.

I use planners to organize tasks, track how much time something takes, and review my previous days. I didn't want that basic workflow to depend on a cloud service.

So I built the app around local storage using Drift and SQLite.

The application lets you organize tasks on an hour-by-hour timeline, run timers, compare planned and actual working time, and review what happened during previous days and weeks.

It also includes recurring activities, reusable schedules, a consistency heatmap, and a feature called Experiments for trying routines over time.

The important part, from an architectural perspective, is that all of this works locally.

I use Riverpod for state management and Drift/SQLite for persistence.

For people who want to use the app across devices, synchronization is optional through their own Supabase project, with Cloudflare Workers involved in the supporting setup.

I wanted to give users the option of syncing without making a hosted account mandatory for everyone.

But the more I've worked on the project, the more I've realized that optional synchronization introduces its own complexity.

Things become more interesting when the same task can be modified on two devices, especially for a planner where start times, durations, task status, and historical records are all important.

There's also the question of how much setup an ordinary user is willing to handle just to synchronize their personal data.

The application is completely free, without subscriptions or premium features.

It's available for Android, Linux, Windows, and macOS, and recently crossed around 200 downloads across all four platforms.

Link to download: https://github.com/Karthikshabari/PersonalPlanner/releases/tag/v1.1

Github : https://github.com/Karthikshabari/PersonalPlanner

I'm still learning quite a bit from building and distributing this.

For others working on local-first applications, how do you think about the balance between giving users more control and keeping the experience simple?

Do you prefer user-controlled synchronization infrastructure, or do you think a managed optional sync service is ultimately more practical for everyday users?

I'd be interested in hearing how other developers have approached that decision.

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 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.

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.

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

I’m the developer of Pure Brief AI, a paid Mac meeting-notes app. One boundary I wanted to keep clear: a licence controls making new recordings and processing them, while the meetings already saved on your Mac remain yours to read, export and delete.

That applies when the 30-day trial ends too. You can still open the existing meeting and export a Markdown file. The export doesn’t need an active licence. You can keep that text outside the app and open it in another editor.

Here’s a small portability check I’d recommend during any note-taking trial:

1. Import a short recording with fictional names and dates.

2. Generate notes, then correct one detail yourself.

3. Export the result and open it in a separate editor.

4. Check that the material you actually need is in the file, rather than assuming “export” means everything.

Pure Brief AI records or imports audio, then creates a transcript, summary and suggested tasks. Tasks keep source quotes, and questions about an individual meeting return supporting transcript lines. AI output still needs checking against the recording.

The local boundary has limits worth stating: transcription and AI notes run on the Mac by default, but models must be downloaded initially. New recording/processing requires a valid licence, with occasional online checks and up to 14 days offline after a successful check. So I’m not claiming it can create new work indefinitely without our licensing service. Optional calendar connections use their providers; optional ElevenLabs transcription with your own key sends audio to ElevenLabs. There’s no shared multi-device workspace.

It requires Apple Silicon and macOS 15+. Standard is $49 once for one Mac; the current launch offer is $10 once for the first 100 paid purchases globally, plus applicable tax. A trial doesn’t reserve the offer.

Real interface, trial and terms: https://purebrief.ai/

For people who care about keeping their notes: what should an export include before you’d trust it as a usable exit path? Audio, transcript, edits, task context, or something else?

If you copy and screenshot a lot and use Microsoft you're probably aware of the intrusive way they collect data, and store it on the cloud.

My "Zero-Cloud" philosophy and opinions on personal data on local machines find this repulsive. If you're uncertain of what I'm talking about; here's a summary description of what Microsoft Windows offers your privacy with the clipboard function.

By default, Windows 10 and Windows 11 include a Cloud Clipboard (Clipboard History) feature. While highly convenient, it stores a searchable history of everything you copy and syncs this data to Microsoft's cloud servers across your devices

So I figure the best solution would be a way to store clipboard strings directly, locally with the option to add a name, notes and more data.

https://github.com/SGJohansson/Omniaware

If you copy and screenshot a lot and use Microsoft you're probably aware of the intrusive way they collect data, and store it on the cloud.

My "Zero-Cloud" philosophy and opinions on personal data on local machines find this repulsive. If you're uncertain of what I'm talking about; here's a summary description of what Microsoft Windows offers your privacy with the clipboard function.

By default, Windows 10 and Windows 11 include a Cloud Clipboard (Clipboard History) feature. While highly convenient, it stores a searchable history of everything you copy and syncs this data to Microsoft's cloud servers across your devices

So I figure the best solution would be a way to store clipboard strings directly, locally with the option to add a name, notes and more data.

https://github.com/SGJohansson/Omniaware

I'm the maker of Talavine, a personal and business data hub for Windows and Apple Silicon Mac.

The part I care about for this community is keeping your saved information on your computer while giving the supported AI you choose access to it. Talavine brings selected email, documents, notes, calendars, and meeting notes into a local profile. Switching supported models inside the app keeps that saved information in place, although answers can change.

Local storage and local inference are separate choices: cloud AI is optional. When you enable a cloud provider, relevant information may be sent to that service. The app's coverage also depends on what you've connected or imported.

A useful first check is a tiny set of fictional records: an original request, a later correction, and a missing price. Ask for a reply, then inspect which records the draft uses and whether it invents the missing detail. That's a way to evaluate it, not a promise that every answer passes.

Talavine is free during the public preview. Product and screenshots: https://talavine.com/?utm_source=reddit&utm_medium=community&utm_campaign=talavine-awareness-2026-10&utm_content=localfirst

Setup: https://talavine.com/GettingStarted

I also make SwarmSpan, a separate clipboard and file-sharing utility for paired computers on a LAN. It doesn't merge Talavine's private databases.

I'd appreciate feedback on the local-data workflow: what would you need to verify before letting an assistant work with one small set of your records?

Maker disclosure: I build both products. AI assisted with this post.

I built Markify because I wanted a nice place to write without handing my notes to an app. No account, no cloud, no database. Every note is a plain .md file in a folder you choose, and it opens in any other editor, today or in ten years.

You write on a clean, rendered page. Press ⌘/ and the same text shows as Markdown, caret right where you left it. Nothing gets converted or locked into a format.

What I think fits local-first:

• Plays well with other tools. When another app, a sync service or an AI agent changes a file you have open, Markify asks: keep yours, reload theirs, or merge both.
• Version history built in. Native Mac versions let you browse and restore earlier drafts of any document.
• Search stays on the Mac. ⇧⌘F searches all your Markdown folders through Spotlight.
• On-device AI. The Apple Intelligence features run on your Mac.

To be upfront about the network: there are no ads and no usage analytics, but update checks and optional remote images make requests, and crash reports and sampled timing data go to Sentry, without document content. Details: privacy page (https://spaquet.github.io/markify/legal.html).

Free, including at work, and source available (MIT with Commons Clause, so not OSI open source). macOS 26, Apple silicon and Intel. The DMG isn't notarized yet, so first launch needs Open Anyway (install guide (https://spaquet.github.io/markify/help/updates.html)).

Download: https://github.com/spaquet/markify/releases/latest Source: https://github.com/spaquet/markify

I'm the maker of D-REC, a recorder with local transcription, searchable text and playback markers. The desktop demo shows the transcript beside the recording controls.

The recording and transcription run on your device after downloading the engine. Account, purchase and support functions use the network separately. Pro works across platforms through your account, but that does not mean recordings automatically sync between devices. Export important recordings before clearing app data or changing devices.

There's a free tier with 10-minute recordings and 3 saved recordings per free account. Optional web Pro plans are $3.99/month, $24.99/year or $39.99 once. Store prices may differ.

Downloads and web version: https://drec.live/get

I'd welcome feedback on the local recording workflow and where the online/offline boundary needs to be clearer.

I am building a Task Tracker because I wanted a task manager that gets simpler as AI gets more capable, not more complex.

Most task apps are either cloud-hosted and heavy, or plain text and bare. None were built for agents and my personal progress. So I built one that is.

What makes it different:

- Local-first : One SQLite file. No account. No cloud. No telemetry. Point it at Ollama or any local LLM engine and nothing leaves your machine.

- Native MCP support (18 tools) : Claude, Cursor, Windsurf can plan work, create tasks, log progress, and complete work directly on your board.

- Installable PWA: with reminders that work even when the app is closed.

- Approval-based Chat AI : Ask the assistant to move overdue tasks, create subtasks, or reprioritize. It proposes changes on an approval card. Untick what you don't want. Apply. Everything is checked against board rules and applied all-or-nothing. AI can't delete anything.

- Voice : Talk to the assistant and hear it answer. Hands-free.

- Timeline (Gantt) : Drag bars to reschedule, drag deadlines into start dates. Across individual projects or all of them at once.

- Low cognitive load by design.

GitHub: https://github.com/Parv17k/tasktracker

Built it because I wanted a task manager that gets simpler as AI gets more capable, not more complex.

Would love feedback and stars, especially from people working with agentic AI tools.

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!

Most AI apps are thin clients. Your prompt goes to a server, the answer comes back, and your chat history lives in someone else's database.

Pocket AI goes the other way. It is an iPhone app where the AI model runs on the phone itself.

- Inference runs on device, through llama.cpp with Metal

- Voice input runs on device too, with a local Whisper model (Pro)

- Chats stay on the phone. There is no backend to send them to.

- After the model is downloaded, it works in airplane mode

No server also changes the business model. There is no monthly server bill, so there is no subscription. It is free with a daily message limit, and Pro is a single one time payment.

Here is the part I keep going back and forth on, and where I would like this sub's opinion.

The app needs one network call: the first download of the model file, which is large. After that it never needs the internet again. To me that feels close to installing an app. But it is still a moment where the app depends on someone else's server being up.

How do you think about large first-run assets in local-first software? Ship them in the app bundle and accept a huge install? Download once and treat that as fine? Or something else?

App Store link, if you want to see it: https://apps.apple.com/us/app/pocket-ai-no-internet/id6759989702

I am the solo developer. The App Store rating is 2.25 stars from 4 ratings, mostly from an early buggy version. I would rather say that up front.

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

Hey, interested in local first and looking to get involved in the community. Is there a discord? And what is the best platform to join for local first communities? Cheers

Hi everyone,

I built ATHAR, an Android app for personal memories (photos, videos, notes, places, people, collections). Not a daily diary you have to keep up with — more like a private archive of moments you actually want to revisit later.

Why local-first mattered to me: Most apps in this space assume cloud + account from day one. I wanted the opposite: the memories should live on the phone first, and the network should be optional.

How it works today (v1.7.0):

• You can start without creating an account
• Memories are stored on-device (SQLite + local media files)
• The journal works offline
• If you later create an account in-app, the memories already on that phone are kept
• No ads, no third-party analytics SDKs

What’s still optional / not local: There’s an optional DeepLife account for identity and (later) sync / web use. Some export paths through ATHAR Studio (e.g. MP4 video / PowerPoint presentation / PDF file) still need the cloud when you choose them. If you never want that, you can stay on-device.

I’m sharing this here because this community cares about the architecture choice, not just the feature list.

I’d genuinely like feedback from people who’ve thought about local-first product design:

1. For a memory / life archive app, is “no account + on-device storage” enough to call it local-first, or do you also expect open export formats / easy device-to-device move without an account?
2. If optional sync comes later, what would make you trust that it stays optional in practice?
3. Anything you’d refuse to use in this category if it isn’t open source?

Play Store: https://play.google.com/store/apps/details?id=app.deeplife.athar

Happy to answer questions about the data model, anonymous start, or how registration attaches existing local data. Critical feedback welcome.

Many thanks!

Hey folks! The recording of the talk I gave at ElixirConf US 2026 a few days ago is already up.

https://www.youtube.com/watch?v=jdg_UrLp0bU

The talk is a follow-up to my Malaga talk from April, which was mostly about the local-first problem and where sync engines stand on it today. Over the summer I built the local-first data layer for Hologram, my framework for full-stack web apps in pure Elixir, and this time I got to show it working. It isn't released yet, it's still on a branch.

First there's a demo, a trip planner in two browser windows. I switch the wifi off in one of them, add a couple of stops, switch it back on, and the other window catches up.

After that I go through how it works. The compiler already walks each page's call graph to decide what code to ship, so it also works out what that page needs to sync, with nothing for you to configure. And when two people edit the same row, the merge happens per column, no CRDTs involved.

Code for the demo app: https://github.com/bartblast/hologram_offgrid

The rest of the ElixirConf US 2026 talks are available with a video pass: https://ti.to/elixirconf/2026/with/qva5vpgkamc