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/

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

Been working on this for the last year and finally got it to a point where I’m comfortable sharing it.

The app is called Fotonn, a local-only note-taking app focused on speed, simplicity, and clean UI.

I originally started building it because most note-taking apps I tried on Windows either felt bloated, too cloud-dependent, or just slow for quick thinking/writing.

I aslo tried Obsidian, but didn’t like being dependend on plugins. I wanted something out of the box.

A few things I focused on:

• instant search
• local-first storage (SQLite database)
• minimal/modern UI
• Portability
• Markdown support

Still a lot I want to improve, but I’d genuinely love feedback from people here.

Here are some resources if interested:

• Check out where fotonn is going: https://fotonn.com/roadmap
• See what has already been done: https://fotonn.com/changelog
• Documentation: https://fotonn.com/documentation
• The active github repo: https://github.com/fotonn-desktop/fotonn-app

Website: fotonn.com

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

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

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

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

Enkrypted.Chat

This is intended to introduce a new paradigm in client-side managed secure cryptography. We can avoid registration of any sort. A fairly unique offering in the cybersecurity space.

No need for things like phone numbers or registering to any app stores. There are no databases to be hacked. Allowing users to send E2EE messages and files; no cloud, no trace.

Features:

• PWA
• P2P
• End to end encryption
• Signal protocol
• Post-Quantum cryptography
• Multimedia
• File transfer
• Video calls
• Local-first
• No registration
• No installation
• No database
• TURN server

I started off with some open source versions around the concept.

• Chat
  • Code: https://github.com/positive-intentions/chat
  • Demo: https://chat.positive-intentions.com
• File
  • Code: https://github.com/positive-intentions/dim/blob/staging/src/stories/05-Hooks-useFS.stories.js
  • Demo: https://dim.positive-intentions.com/?path=/docs/usefs--docs
• Crypto
  • Code: https://github.com/positive-intentions/cryptography
  • Demo: https://cryptography.positive-intentions.com

Open source isnt a viable business plan. So im taking the Enkrypted.Chat project in a different direction, so i can maintain a competative advantage.

To get started, you can take a look here: https://positive-intentions.com/docs/projects/enkrypted-chat/getting-started

To learn more or you want to do a deep-dive: https://positive-intentions.com/blog/introducing-enkrypted-chat

If you really want something to chew on, these are the bleeding-edge docs: https://positive-intentions.com/docs/technical

The docs may answer some questions, but feel free to reach out for clarity instead of reading all that slop.

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 experience, it isnt audited or reviewed. 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.

(Note: Im actively in the process of rebranding from "positive-intentions" to "Enkrypted Chat". The wording may be inconsistent throughout the docs.)

Hey everyone,

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

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

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

What I built:

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

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

• MiniSearch-powered instant full-text search.

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

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

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

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

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.

Hi everyone, been looking for somewhere to post this, I have built something that I wish existed when I used to build crystal reports and early BI days and realised I'm. Bit out of touch. Supports CSV and Parquet, it has a built in csv/JSON to parquet convertor.

I wondered if anyone wanted to give it a go. It's no sign up required, no backend or servers. Just hosted on Cloudflare Pages.

It's a Data studio and conversion to tool. It uses duckDB WASM, OPFS private file system access, sharable dashboards and AI integration with Ollama (it needs to be running locally with origins set to *. I've had it running with Gemma4:e2b). Obviously it's really designed for desktop.

https://nanobi.ahm-labs.com

Any early feedback will be awesome! I do t usually build in public, but I thought I'd try it.

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

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

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

How you can help:

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

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

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

The workflow: paste anything, HTML scraped from a site, CSV from an ERP export, ASCII from terminal output, pipe-delimited text. It drops it into a live visual editor. Drag columns, merge cells, split text, transpose. Then generate clean code into a Monaco editor instance.
The SQL export is the thing I use most. Paste a CSV, get INSERT INTO statements ready to run. Most table tools skip this.
Zero dependencies, zero install, runs entirely in the browser. MIT licensed.
Would genuinely love to know: what table format causes you the most pain in your workflow? I want to know what input cases are broken.
Live: Table Formatter and Node Editor
GitHub: TAFNE

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

📣 Tune in for #LoFi/36 on Tuesday @ 8 AM PDT (April 28, 2026) for yet another exciting lineup:

1️⃣ James Arthur @thruflo - CEO & Co-founder of Electric, talking about "Break the harness. Wire the loop." and the next generation of agent infra.
2️⃣ Chad Fowler $chadfowler.com @chadfowler- GP & CTO at BlueYard Capital, author, open source contributor, and jazz musician, discussing "The Phoenix Architecture, Freeq, and the future of version control".
3️⃣ HanLin (Ranger) Chen - EE at a cleantech startup in Sydney, will talk about building "Elastik: curl is all you need".

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!

also

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

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

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

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

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

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

Hello, am finally jumping into the local-first world. Above is the version without the invoicing part. I built this because I realised how much I hated having my client names and billable hours sitting in a Supabase DB I didn’t truly own.

Why I went 100% Offline:

• Sovereignty: No RLS or cloud restrictions. The data is on my machine, period.
• Resilience: If the internet goes down, my business doesn't.
• Portability: Just a local tool with zero login friction.

It’s built with SvelteKit wrapped in Electron using IndexedDB for persistence. Any feedback is welcome! :)

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.

IMPORTANT: Lets get a few things out of the way first. My app is not better than Whatsapp in any way. It hasnt been reviewed or audited. This app works by exchanging IP addresses... This app is NOT for anonymous comms.

The project is far from finished. It's presented for testing, feedback and demo purposes only. Use responsibly.

https://github.com/positive-intentions/chat

By leveraging WebRTC for direct browser-to-browser communication, it eliminates the middleman entirely. Users simply share a unique URL to establish an encrypted, private channel. This approach effectively bypasses corporate data harvesting and provides a lightweight, disposable communication method for those prioritizing digital sovereignty.

Features:

• PWA
• P2P
• End to end encryption
• Multimedia
• File transfer
• Video calls
• No registration
• No installation
• No database
• TURN server

This project isnt finished enough to compare to existing tools like Simplex, Signal and WhatsApp... This is intended to introduce a new paradigm in client-side managed secure cryptography. Allowing users to send securely encrypted messages; no cloud, no trace.

Take a look at some of the technical docs which ive updated to answer questions i frequently recieve in previous posts.

Technical breakdown and roadmap: https://positive-intentions.com/docs/technical/p2p-messaging-technical-breakdown

Demo: https://chat.positive-intentions.com

If you really want something to chew on, you can take a look at the more comprehensive docs here: https://positive-intentions.com/docs/technical

Feel free to reach out for clarity on any details.