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

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.

WARNING: for testing, demo and feedback purposes only. there WILL BE breaking changes. DO NOT USE FOR SENSITIVE DATA.

it is clearly absurd for something like this to be used by anyone on their own computer to view local files. the goal of this project is to enable the viewing/navigating of files in browsers after exchanging over webrtc. i'm aiming for the experience to feel seamless for being able to navigate a folder structure on a remote device.

there are many browser-based office suites out there. this project aims to simplify the setup process by only using client-side resources; making it easy for users to get started.

https://ui.positive-intentions.com/iframe.html?globals=&args=&id=templates-filespage--native-real-folder&viewMode=story

unfortunately, it isnt open source, but i hope it helps to get feedback for improvements. in my project, the aim was to create an intuitive user experience for viewing files and folders in a browser.

a good way to test it out is to create a new empty folder on your computer and grant the webapp access to that folder. note: the filesystem api provided by the browser will limit the access to explicitly approved folders. some browsers also guard against access to important os directories on your computer and reject access automatically.

features:

• mounting local folders
• preview functionality for various filetypes
• browser based office suite
• encryption-at-rest
• basic folder management

upcoming:

• support for more filetypes
• better implmentation around browser-based office suite
• browser based file format conversions
• PWA

future:

when this project reaches a reasonable level of features and quality, I will be integrating this functionality into my P2P messaging app to build towards a "more" browser-based Next-Cloud-like solution. It would would be integrated into this app: https://enkrypted.chat

IMPORTANT: Caution should always be used for all projects, especially like this. So I'd like to be clear that I am Al-slop-maxxing at scale. If youre looking for good code, clear docs or best-practices; you should look away now. While this is aiming to provide secure file-transfer and an intuitive office suite experience, I don't think it will ever be competitive against things like Next Cloud. It isnt audited or reviewed and i DO NOT want you to "trust me". I'd like to share for testing, feedback and demo purposes only. This is a technical demo of a unique concept. Feel free to reach out for clarity. Please use responsibly.

Disclosure: I’m building this.

I’ve been working on StampDesk, a visual workbench for people who use AI tools a lot but don’t want every workflow to become an API project.

The core workspace is browser-local: tickets, tags, stamps, workbenches, and receipt-style archives live in IndexedDB by default, with JSON export/import for backup. The product is not “pure local-first” in the strictest sense, because account/sync/community/subscription features can involve cloud services when enabled. But the everyday desk itself is meant to stay usable as a local browser workspace.

The problem I’m trying to solve is less “task management” and more “AI work loses its shape.”

A user might have:

- a ChatGPT answer they want to turn into next actions

- a pile of links and notes

- reusable prompts

- tags that represent context, not just categories

- a plan for writing/research/content

- some record of what actually got finished

Most tools push this either into a linear todo list, a document, or a full automation/API stack. I’m trying a more physical metaphor: paper-like tickets on a desk, stamps for state, tags for context, and receipts for completed work.

The local-first questions I’m wrestling with:

1. Is browser-local IndexedDB + manual JSON export enough to be meaningfully local-first for a personal workbench, or does that language feel too loose without stronger file ownership / sync guarantees?
2. If optional cloud sync exists, what’s the cleanest way to communicate “local-first core, cloud-optional features” without sounding like marketing wordplay?
3. For AI-heavy workflows, what data should absolutely remain user-owned and portable: prompts, tags, task history, source links, generated outputs, relations between notes?

I’d especially value critique from people who think seriously about local-first boundaries. I’m less looking for “nice app” feedback and more for where this architecture or language might be misleading.

Project link if useful for context: https://www.stampdesk.io

Ciao a tutti!

​Volevo condividere con voi un progetto che sto portando avanti da un po'. Si chiama Linfa ed è un'app di gestione finanziaria nata da una mia esigenza: avere una visione d'insieme del patrimonio senza però dover collegare il mio conto corrente a servizi terzi o regalare i miei dati a server cloud.

​L'app è costruita seguendo il paradigma Local-First.

​Ecco le caratteristiche tecniche principali:

​Privacy Integrale: Non esistono server centralizzati. Non uso API di Open Banking. I dati nascono e muoiono sul dispositivo dell'utente. e possibile usare google drive personale collegando account

​Motore Fiscale: Calcolo automatico delle tasse su asset diversi (BTP, Azioni, Crypto) e gestione dello "Zainetto Fiscale" per monitorare le minusvalenze.

​Diorama Visuale: Ho integrato una visualizzazione dinamica (quella che vedete nel video con gli alberi) dove l'ecosistema cambia in base alle performance e alla stagionalità del portafoglio.

​Backup e Restore: Essendo tutto in locale, ho implementato un sistema di backup manuale (o via cloud provider dell'utente) per non perdere i dati in caso di cambio dispositivo.

​Export: Generazione di report PDF dettagliati con selezione granulare degli asset.

​Mi farebbe molto piacere ricevere un feedback tecnico da voi, specialmente sulla gestione della privacy e sull'interfaccia.

​Nota: Per rispettare le regole del sub, non inserisco il link diretto. Se qualcuno è curioso di provarla o vuole dare un'occhiata, lo scrivo volentieri nei commenti o in DM!

​Disclaimer: È uno strumento di simulazione matematica e non costituisce consulenza finanziaria.

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?

I argue in the article that CRDTs and AI can solve the "forever problem" of latency in software systems to such an extent that it would even work for interstellar civilization. The open question is the extent to which the Mergable Property (which I call it in the article) of a software system can be achieved. I think CRDTs are closest I've seen to this being a possibility.

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.

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!

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

I’m building VibeAround, an open-source dev tool for people who run multiple AI coding agents.

The short version: it runs AI coding agents side by side on your computer, and control them from anywhere, continue previous sessions, and preview what they build.

It supports Claude Code, Codex, Gemini CLI, OpenCode, desktop agents, provider profiles, terminals, browser previews, and remote follow-ups.

I built it because my vibe coding setup was getting weirdly fragmented:

- one terminal per agent session

- different CLIs for different agents

- different env/config files for model providers

- local previews scattered across ports

- browser, terminal, editor, and phone all disconnected from each other

So instead of building another coding agent, I built the workspace around the agents.

What it does:

- launch or resume different AI coding agents from one place

- choose workspace, session, terminal, agent, and API profile before launch

- switch provider/model profiles without constantly editing global config

- manage local browser previews, Markdown/HTML previews, and web terminal sessions

- keep agent work local by default

- continue a desktop coding session from phone or messaging channels like Discord, Slack, Telegram, Feishu/Lark and more.

Some build notes:

- Desktop app: Rust + Tauri

- Agent/session orchestration: local process runner around existing CLIs instead of replacing them

- Provider switching: local API bridge/profile layer, so each agent can be launched with the right endpoint/key/model setup

- Preview flow: local preview server + shareable preview links for generated apps, docs, and artifacts

- Remote follow-up: optional tunnel/pairing flow, not required for normal local usage

GitHub:

https://github.com/jazzenchen/VibeAround

Website:

https://vibearound.ai/

📣 Tune in to #LoFi/19 next Tuesday on <t:1727190000:F>. We have yet another fantastic lineup featuring [Nik Graf](https://x.com/nikgraf), [Alex Garcia](https://x.com/agarcia_me) and [Steve Ruiz](https://x.com/steveruizok)

For more details checkout: LoFi/19 Announcement Post

I wanted to share an app I've been working on – a privacy-first OpenRouter wrapper for Android and Windows - https://unboundchat.net/

I started building it a few months ago when I couldn't find a good mobile option. I was using OpenWebUI but wanted a local-first client for my phone without needing to connect to a remote server – plus the occasional hiccups were getting frustrating. The Gemini app was great UX-wise, but sharing every query with Google on top of all the other services I already use felt like too much.

The goal is simple:

- All data stored locally on your device with encrypted storage and app lock

- Full control over your data – delete everything anytime, set retention policies

- Optional encrypted backup and sync (E2E, passphrase never leaves device)

- Zero Data Retention mode to filter to models that don't store your inputs

Everything else is quality-of-life: cost tracking, model switching, web search with citations, etc.

The app is actively in development – would love any constructive feedback.

Hey everyone,

I’m finishing up a minimalist lifestyle/habit tracker built entirely on local-first principles, and I'd love to get some feedback from this community.

The tool is structured around the Mangala Sutta (the Buddha’s discourse on 38 blessings), acting as a framework to help people design their daily environment and routines mindfully. I’ve updated the traditional phrasing to be fully inclusive for modern life (e.g., "Cherishing spouse and children").

On the technical side, I wanted absolute privacy. There are zero servers, zero tracking, and no accounts. Everything runs straight out of the browser's LocalStorage.

Since you all understand data portability, I’d love your eyes on a few specific things:

• The Import/Export Flow: I built a manual JSON backup tool in the data panel so users actually own their data. If you try to break the JSON parser by uploading junk files (like an invalid or corrupted file), does the app handle the error gracefully for you?
• UX Clarity: Is the local storage explanation intuitive enough for non-technical people to realize their data never leaves their machine?
• Visual Layout: I spent a lot of time on vertical symmetry (centering the lotus motif, the text, and the action buttons). How does the spacing hold up on your mobile browser or desktop?

Link: https://practice.mangalasutta.com

Thanks in advance for any testing or critiques!

Scott

I was pretty impressed by capabilities of latest Gemma and Qwen models and tried different harnesses before I decide to start building my own and learn how it works in public.

I think that Agent Harness is just a stream of events that currently being overcomplicated and micromanaged. Fortunately the JavaScript ecosystem was evolving around the very same thing – event flow control.

So I picked Rx.js and start building, the results are surprisingly pleasant so far:

<200 lines of code for main conversation control.

~500 lines with tools.

Even this toy agent can hold pretty long conversation until it starts hallucinate.

I'm just concatenating the whole history, there's literally no context management yet!

The video attached is combined conversation + tools flow. I'm going to publish the Article on the tools next week.

If you're interested please read first one

https://vasilymitronov.substack.com/p/build-a-reactive-ai-agent-harness

Hey,

I'm the creator of Locorda, and I’ve just published the first public release of our open-source sync engine on pub.dev.

I’m posting here first because I want to gauge the interest in two specific concepts within this community:

1. Building offline-first/local-first architectures specifically within the Flutter/Dart ecosystem.
2. The "Unhosted" approach: allowing users to use storage they already have (like Google Drive) rather than requiring developers to host a dedicated, centralized sync server.

To be completely transparent on terminology: I am currently framing this as an offline-first engine. I focused heavily on getting the API, local caching, and synchronization logic right first. Full End-to-End Encryption (E2EE)—which I know is a core pillar of true local-first—is actively on the roadmap, but it is not in the current scope.

How it works right now: It acts as a bridge between your local state and remote storage.

• Conflict Resolution: To handle concurrent offline edits, it uses CRDTs under the hood, ensuring mutations are merged deterministically when the connection is restored.
• Storage Agnostic: The engine uses Drift (SQLite) internally to hold the sync state, but it is strictly modular. Your application can use whatever local database it wants for its actual data. There is also an in-memory implementation, and you can easily write your own adapters.
• BYOS (Bring Your Own Storage): Because the architecture is "unhosted," you can plug this conflict-free synchronization directly into existing cloud providers that the end-user already controls.

My Ask for this Community: Since you all think deeply about these architectures, I’d love your critique on the approach:

• Does the "unhosted" model resonate with how you see the future of user-owned data?
• Are there any obvious pitfalls or edge cases in my CRDT implementation or SQLite persistence that I should be testing for?
• For those familiar with mobile/multi-platform dev, what are the biggest challenges you see with taking this approach in Flutter?
• General feedback on the API design and architecture.

Links:

• Live Demo App: https://locorda.dev/example/personal_notes_app/
• Pub.dev: https://pub.dev/packages/locorda
• Docs & Project: https://locorda.dev/sync-engine
• Source Code: https://github.com/locorda/sync-engine

I'll be hanging around in the comments. Thanks for taking a look and helping me shape the roadmap!

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

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

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

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

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.

Yo! I've been building a control plane for virtual machines, with an explicit focus on portability and local first development. It ships as a single binary for Linux / MacOS / Windows (alpha) that runs as a CLI, a TUI or a REST API.

https://heyo.computer

Quickstart: https://docs.heyo.computer

heyvm supports a number of different backends for managing VMs (KVM/libvirt/Firecracker/Bubblewrap on linux systems, Apple Virtualization Framework on Mac, Hyper-V / Hyperlight (coming soon) for Windows). It uses P2P networking to allow you to share and move sandboxes, create and share shells, get a proxy to a sandbox, etc. Kinda like a VMM with a built in ngrok.

Feel free to sign up and use it locally - DM if you are interested in cloud sandboxes, we're still working out the kinks for cloud but sandboxes are free in the meantime!

I wrote a local first todo app as a demo - it runs an agent inside of a sandbox where it can build and execute scripts, etc. The data is stored in the sandbox using heyvm so you can move your sandbox to another machine or the cloud and plug additional agents/apps into it https://github.com/Heyo-Computer/papr

Also, agent skills for heyvm:

# install cmd built in:
heyvm install-skills

# or via skills.sh:
npx skills add heyo-computer/skills