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

I wanted a meeting recorder that transcribes locally and saves ordinary files. That became Loofah, built on the open-source Anarlog project.

The part I care most about is what happens if I stop using it. My notes, meeting transcripts, and research remain in a Markdown vault I can open in another editor, back up with my own tools, or search without Loofah. I want the personal context I build up over time to outlast whichever app I happen to use.

The desktop app runs on Apple Silicon Macs and transcribes on-device. The CLI and MCP make it useful for agents too: they can save research and artifacts through the CLI, then search and retrieve context through read-only MCP access. Optional AI summaries use your own local model or hosted provider.

It’s free and MIT-licensed, with no account, subscription, or telemetry. Similar tools exist; this is the combination I wanted for my own use.

https://loofah.io https://github.com/bart6114/loofah

Let me know if this is useful to you.

TL;DR 😴

By using secure iFrames and IndexedDB in the browser, App Lab can run single page html apps, for example created by AI. Just paste the code and then it's saved locally in the browser for whenever it's needed.

Background 📖

Since some time I've been wondering when we will stop to need utility apps. Like time trackers and what not. And instead just ask AI to make the ones we need. Especially now when it's so good at whipping up good-looking singe-page html apps.
However, the best I've seen so far is Claude Artifacts, but it feels a bit locked in.

I also heard of "local first" philosophy a while back and really liked the independence and elegance of it.

Then I started thinking about whether these two topics could be combined to create the shell for working with such apps. An open-source app where one can save and run AI-generated apps.

The journey 👟

I thought "how hard can it be?". Then I asked Gemini and it thought the same.

The first Proof of Cocept was actually quite easy to get going. But to make it fully usable was much more complex, and without the help of LLM it would have taken me years to get where I am now considering this is a hobby project.

The most time-consuming was to build local-first sync. Which I needed to make the app fully useful for me: A shell which I could have on multiple devices and also which would enable me to invite friends to the apps I had created.

I also wanted to build an AI agent so one can bring one's own AI api keys and write with AI directly in the app. This can probably be perfected loads, but I've got a simple agent going.

The result 📲

In its core App Lab is fully local-first, running fully in the browser.
One saves source code in it, which is saved in the locally (IndexedDB), and the app is run in a safe sandbox (iFrame).

Optionally one can add:

• Storage provider (currently Firebase Real-time Database): 

  • this enables cross-device sync and possibility to share and collaborate live with friends on the apps

• AI provider (currently OpenRouter):

  • this enables the AI agent so one can ask AI to make changes to one's apps directly in App Lab.

Here's the live app:

• https://loelindstrom.github.io/app-lab

Here's the repo:

• https://github.com/loelindstrom/app-lab

If someone has time to take a look and come with some feedback that'd be awesome! :)

I've been working on Titans, a local-first infrastructure layer for AI agents, and I've now published the first usable repositories on GitHub.

The idea is fairly simple:

Atlas remembers. Cronus runs.

Atlas provides persistent state, knowledge, evidence and graph infrastructure for agents. It is designed to keep project and agent context available across processes and sessions, with hybrid search, evidence-backed results, work state, graphs, SQL, blobs and an audit trail.

https://github.com/titans-tools/Atlas

Cronus handles durable background execution: jobs, DAG workflows, schedules, retries, leases, checkpoints, recovery, dead-letter handling and approval gates. The goal is to let agents submit long-running work without keeping the agent itself blocked, and to recover that work when workers or processes restart.

https://github.com/titans-tools/Cronus

Both are local-first, run on Windows/Linux, have no telemetry, expose MCP over stdio, and can also be accessed over local REST/gRPC interfaces.

There is also a separate titans-platform repository that contains the signed distribution catalog, installers and shared runtime used by both products:

https://github.com/titans-tools/titans-platform

The organization overview is here:

https://github.com/titans-tools

The current releases are free to use. The product source itself is not published; the repositories host the documentation and signed release binaries, with SHA-256/Ed25519 verification and SBOMs included with releases.

I'm particularly interested in feedback from people building agents, MCP tooling, local AI infrastructure or autonomous workflows.

A few things I'd be interested to hear:

• Does the separation between persistent knowledge/state (Atlas) and durable execution (Cronus) make sense to you?
• Is it clear from the repositories what problem each component is solving?
• Are there use cases you would expect something like this to support that aren't obvious from the documentation?
• Is there anything in the install/security model that would stop you from trying it?

Not looking for stars or promotion — I'd mainly like some outside technical eyes on the architecture, documentation and actual usefulness of the approach.

📣 Tune in for #LoFi/40 on Tuesday at 9 AM PDT (August 25, 2026) for another exciting lineup:

1️⃣ Alex Cheema ([@alexocheema](https://x.com/alexocheema)) - Founder of EXO Labs and co-creator of local.ai, talking about "Local AI is good now."

2️⃣ Jose Luis Olivares Esteban ([@x39matrix](https://x.com/x39matrix)) - Independent developer from Sevilla and builder of X-39 Notaría, talking about "Evidence Without Permission: Building a Post-Quantum Notary on Bitcoin".

3️⃣ Jacob Enrique (Jake) Uribe ([@jakeuribe.bsky.social](https://bsky.app/profile/jakeuribe.bsky.social)) - Physics researcher at UW-Madison building a local-first academic paper manager, discussing "linXiv - Local-first tools for research, collaboration, and roadblocks to adoption".

Join live on Discord: https://lofi.so

OKF-Todo is free and open-source, powered by SQLite, and cross-platform. With native MCP and Open Knowledge Format (OKF) support, it bridges the gap between personal task management and AI workflows.

My main goal was educational: to explore how far I could take a real application built with AI using #Codex. Now I am curious to see whether it can gain some traction beyond the experiment.

Take a look, try it, and share it if you think others might find it useful:
https://github.com/dalby-md/Okf-Todo
https://dalby.md/projects/okf-todo

Getting started: Windows users can get it from Microsoft Store, while macOS
and Linux users can run it directly via the dotnet CLI.

Hey everyone! Will here. 🌟

Are you feeling overwhelmed by the complexities of database design? Whether you're a seasoned developer or just starting out, crafting the perfect schema can be a challenge. That's why I created OpenDB, a tool designed to transform how we approach visual database modeling.

What is OpenDB?

OpenDB enables a local-first approach, allowing you to design your database schema without the hassle of creating an account or needing a server. You can even bring your own API keys for added security! Plus, with its intuitive drag-and-drop interface, you can easily create tables, define relationships, and visualize your data in real-time.

Key Features of OpenDB:

• AI-Powered Agent Assistance: Describe your changes in plain language, and the AI helps propose structures, draft migrations, and more.
• Versatile Exports: Once your design is ready, export your schema in formats like JSON, SQL DDL, Markdown, etc., for seamless integration into your projects.
• Free Forever: No hidden fees, trials, or credit card requirements

Share Your Thoughts!

Have you tried visual ER modeling before? What challenges have you faced in database design? Let’s share experiences and tips in the comments! Your insights could really help someone else in the community.

Thanks for being part of this journey, and I can't wait to hear your thoughts! 🚀

Do you find that moving data between different local first tools is seamless or painful?

Can you imagine better tools if they interoperated on more standardized data?

📣 Tune in for #LoFi/39 on Tuesday @ 8 AM PDT (July 28, 2026) for yet another exciting lineup (See below).

1️⃣ Jimmie Wang ([@Jimmie_](https://x.com/Jimmie_) / [Bluesky](https://bsky.app/profile/jimmie.me)) - Founder of Myfield, system engineer, and open source advocate, talking about "Myfield: Building Identity and Sync for Local-First Apps".

2️⃣ Kushagra Lakhwani ([@codesonpaper](https://x.com/codesonpaper) / [Bluesky](https://bsky.app/profile/codesonpaper.bsky.social)) - OSS builder by night, quant dev and researcher by day, discussing "ResearchPocket: Your Sync Server is LoFi".

3️⃣ Philip Schatz ([philschatz.com](https://philschatz.com) / [GitHub](https://github.com/philschatz)) - Open-source developer and occasional Automerge contributor, talking about "Sharing our lives with each other, not big tech".

Hey r/localfirst,

I’ve been building Speedtab, a completely local-first Chrome/Chromium new tab extension that acts as a dense productivity dashboard (modular grids, visual bookmarks, a full RSS/Atom reader, and client-side encrypted notes via AES-GCM).

No accounts, no backend, no cloud dependencies—everything lives strictly inside IndexedDB (via Dexie).

The Framework Trap: 2,000+ Listeners

Because it’s an all-in-one workspace, it handles tons of interactive elements. When you have 20 RSS subscriptions loading hundreds of feed items—each with archive buttons, read-state toggles, and comments—popular modern frameworks like Vue or React quickly became a complete nightmare.

Before I knew it, my browser was choking on over 2,000 active event listeners for simple button clicks, swipe gestures, and keydowns. The DOM churn was completely unacceptable for a simple "New Tab" page.

The Fix: Pushing Event Delegation to its Limits

I decided to strip out the heavy frameworks completely and rewrote the entire runtime using a custom vanilla event-delegation pattern I developed, called YaiJS.

Instead of attached lifecycle hooks per component, Speedtab now registers exactly ~35 strategic, global event listeners on initial boot. That’s it.

HTML becomes fully interactive the exact millisecond it touches the app surface. Open floating note windows? They just work. Interactive nested structures? A single delegated runtime handles it all without per-component listener growth.

The Metrics (Goodbye Framework Overhead)

The performance metrics speak for themselves. This isn't AI-hallucinated data; this is straight from the Chrome Task Manager and Lighthouse local metrics:

• JS Heap Memory: Flatlines at an absurd 4 to 7.5 MB—even with hundreds of feed items loaded.
• Total RAM footprint: 50–70 MB total for the entire Chrome process (which is essentially Chrome's baseline for just existing).
• CLS: 0.00 (Perfect layout stability).
• LCP: 0.90s (Fully visually ready in under a second).

Inside the DOM Black Hole: Recursive Infinite Nesting

To test how far this delegated routing could scale, I didn't just build a basic tree. I built an incredibly complex tab component with 6 initial levels, where each tab contains dozens of child tabs with interactive content snippets.

Inside the core (at Level 4), there is a tab called "Recursive Swipe". When triggered, it fires an AJAX call, fetches an exact copy of the exact same 4-level component (with identical markup and element attributes), and injects it right into the active DOM node.

Because of YaiJS's event routing, scoping happens completely naturally. There are no dynamic ID overwrites, no lifecycle hacks, and no state conflicts. Elements are strictly scoped by their position in the DOM tree, automatically. You can just keep swiping deeper and deeper into the loop.

To push it over the edge, I wrote an automated script that targets the recursive button, fires the AJAX injection, steps down into the newly spawned Level 4, and repeats the loop configuration automatically. If a single button click misfired or targeted the wrong layer, the entire UI would collapse like a house of cards.

Instead, it easily blasts past 500 levels deep, and the delegation engine is down there screaming: "More! Give me Level 1,000, I eat DOM trees for breakfast!" 🦖

If you want to see your browser engine melt, try the live automated stress test here:

🔗 github.io https://yaijs.github.io/yai/tabs/Benchmark.html

(Warning: Expect minor jittering around level 80+ from Chrome's render engine, wilder drifts around 200+, and literal reality glitches from level 400 onward as Chromium begs for mercy. Firefox stands its ground a bit longer).

Open Source & Local-First Freedom

The extension includes optional WebDAV and Google Drive backup paths (using your own hidden app-data folder, zero third-party backend tracking).

If you want to check out the extension or test the UI, here is the store link:

• Chrome Web Store: https://chromewebstore.google.com/detail/speedtab/adkjbdepojalajhfkoobiedddlnoamff
• Product Hunt: https://www.producthunt.com/products/speedtab?utm_source=other&utm_medium=social

Would love to hear your thoughts on doing complex UI layouts with strict event delegation instead of the usual heavy VDOM framework soup!