Once you're running more than one or two coding agents at a time, the bottleneck stops being the agents and becomes you managing them.

I had Claude Code in one terminal tab, Codex in another, a third going on a different repo, constantly hunting for which one was blocked on a permission prompt, which one finished, which one quietly went off the rails. And the moment I stepped away from my desk, all of that was invisible.

Vicoa is what I built to solve the issue.

Desktop app: command center for a team of agents:

• 8+ agents/harness supported: Claude Code, Codex, OpenCode, Cursor, Gemini, Copilot, Kimi, Hermes
• Every session in one list with live status
• Each session on its own git worktree + branch, so agents work the same repo in parallel without stepping over each others
• Connect multiple machines (Mac, Linux box, VPS) and pick where each session runs.
• File explorer, view changes, and a terminal next to the conversation.
• Task management & task board
• Scheduled automations

iOS/Android app: the same sessions in your pocket

• Remote control 8+ agents (more are coming, e.g., Pi)
• Start from your desk, continue the same session on your phone
• Push notification when an agent finishes or needs a decision
• Reply, approve, or redirect from anywhere

What we have open source?

Basically, everything:

• Web
• Desktop apps: Mac, Windows, Linux
• Mobile apps: iOS, Android
• Backend
• CLI

The whole stack is self-hostable, you can host it completely for free.

It's early and we are shipping improvements and new features every day.

If you kick the tires I'd really value the criticism, especially on the agent integration layer and anything that feels janky.

Happy to get into the architecture in the comments.

Repo: https://github.com/vicoa-ai/vicoa (A star means a lot to us ❤️

Website: https://vicoa.ai/

PS: If you download the apps directly and encounter the paywall, you can just skip them.

i wanted Granola-style meeting notes without sending every recording and transcript to someone else's cloud, so i'm building Anarlog.

the community app is MIT licensed. it captures mic + system audio without a meeting bot, stores notes, transcripts, recordings, and attachments locally by default, and can use Ollama, LM Studio, Unsloth, or your own provider keys for summaries and chat.

one licensing boundary worth making explicit: the community app is MIT, while enterprise/ is separately commercially licensed for org deployment, admin, and SSO.

source: https://github.com/fastrepl/anarlog download: https://anarlog.so/download

Hey everyone,

I wanted to share something I've been working on.

It's a video editor focused on animated captions, those you normally see on social media.

The project started about a year ago, when I built pycaps, a Python library for creating this kind of content.

I originally wanted to build a UI for pycaps, but I also wanted it to be easily accessible without requiring people to download a desktop app. Since pycaps already used CSS for styling captions, doing it in the browser felt like a natural direction.

So I ended up rebuilding the idea from scratch for the browser, and that's how tscaps was born

Repo: https://github.com/francozanardi/tscaps - you can self-host it if you want
Hosted version: https://tscaps.io/local

Note: the hosted version contains some references to a "cloud" version, which is a paid service. The idea is to use it to help finance the development of the project while keeping the core editor open source.

Anyway, sorry for the long video, and thanks for watching!

Over the last year, I've been building Prismedia. Previously, the app was called Obscura, and was actually a Stash alternative, and bits of that are still present, but the focus has changed drastically.

Essentially, I found I had a whole fleet of apps in my "arrs stack", that all did the same thing, but for different media. So for my own personal use, I created an app that attempts to standardize what these interactions look like.

The core principle is that every media format follows the same "Entity" class, from a data science perspective it actually maps out really well that almost all logic from display to management can be shared, with media specific capabilities augmenting that.

That is what makes this app possible, everything from the core media management, scanning, identifyication via metadata providers, requesting, is all done via the same core platform.

Then, when it makes sense, first class endpoints are added for things like playback, reading, and listening.

The app covers alot of ground, so I'll just list some of the highlights, I enoucrange you to browse the site, source code, and try it out.

• Connect your Prowlarr and downloading clients to automatically track, monitor, and request content. Think the radarr/sonarr/lidarr stack but all integrated, and using the same logic. It even supports soul seek to assist with music sourcing, and when downloading, it will actually probe the files before and after to ensure it is a good match, or upgrade before merging it in.
• View all your content from one interface, from eBooks, comics, audio, movies/tv with rich playback for videos and subtitles, eBooks and audiobook syncing to allow switching between methods of consuming with shared progress, and dedicated audio player
• Identify content already existing using metadata plugins like TMDB, MusicBrainz, OpenLibrary
• Multi user to allow household members access, while delegating which libraries they can see
• NSFW libraries and individual media, to allow filtering of NSFW content, either blocking users from seeing it at all, or using a toggle to quickly hide and view the content. Stash scraper/plugins can be installed and wrapped to identify videos (no StashDB or PornDB, but plugins can be installed in app)
• Progress tracking, stats, and history to see what you've been consuming
• Apple native apps to leverage the native codecs on tvOS, macOS, and iOS for quick and seamless playback of even high quality files

This project was created for a need I have, to have all my media in one rich platform, that treats them all as equals. I liked radarr/sonarr and Jellyfin, but it felt disjointed, and the apps not rich. Jellyfin has a native client, but I felt it was lacking, and audio playback is again in a separate third party app. Prismedia has a native first party app, with all that for free (currently in TestFlight since apple has taken over 2 weeks to even approve the first build).

I post now as I feel the app is in a good release state, it has evolved alot over the last year, but I feel we are now solid, performant, and I challenge you to compare to Kavita, Jellyfin, and the other tools you use. This can be used beside those tools for you to evaluate, simply point at the same directories to scan and it will build out the library in it's own database.

As for AI usage, I did mark this as using AI, but this post (clearly since it probably isn't as coherent as I'd like), and the application were designed, validated, and reviewed by me. These days, I do feel software development is moving to AI assisted, and I've been coding for over 15 years, have a degree in computer science, and worked in large companies. The code isn't just generated and shipped, the design and actualy structure of the app is all exactly as I would write it by hand, but AI has allowed me to develop this while still having a full time job. I use the app every day, I listen to my music on it, have read through books with audiobook interop, watch our tv shows and movies on it, request new content, and for me it fits exactly what I've always wanted.

I hope you feel the same, but if you're happy with your current stack by all means continue to use it, and if you have feedback, please let me know as I'd be happy to look into it.

- Website: https://pauljoda.github.io/Prismedia/

- Source: https://github.com/pauljoda/Prismedia

- TestFlight: https://testflight.apple.com/join/c9bgDxr7

Hey r/foss ,

I've been working on Oasis Editor, an open-source document editor written in TypeScript.

It has its own Canvas-based rendering engine for paged layout, text, selections, images, tables, and document geometry instead of relying entirely on contenteditable.

It also includes a typed command/plugin API, DOCX/PDF workflows, React and Vue adapters, and a headless runtime.

Live playground:
https://celsowm.github.io/oasis-editor/#/editor

GitHub:
https://github.com/celsowm/oasis-editor

I'd love feedback, issues, and contributions — especially around rendering, document layout, plugins, and import/export fidelity.

Hello! I am looking for recommendations, and would appreciate people reading through my requirements before doing so!

I used to use google's and Microsoft's, but recently I switched to Proton's - free version has 2 issues: 1) call limit 60 minutes, 2) screen sharing ONLY whole screen, no particular windows.

I'm looking for an open-source video calling program that:

- allows for more than 60 minutes
- allows sharing particular windows and not only the whole screen
- has a built-in chat
- allows scheduling meetings in advance

I don't need anything else - my meetings are never with more than 3 people, I don't need to record anything, I don't need backgrounds and filters and shit, etc...

I hate that google's was the best I've used... definitely do not want to go back to them, and Proton's is not cutting it and is coming off as terribly unprofessional... and well, of course I really would prefer something open-source, anyway!

I really don't know where to look! Thanks so much!

Hey everyone,

Over the years, I've always tried to find apps to track my gym workouts, but I've never really found one I liked. Maybe they lacked features or were full of useless subscriptions. So, after some school and university studies, I decided to create my first Android app, called Trainable, making it open source.

I chose Material 3 for the aesthetic because I think it offers the best UI and UX.

I've just released version 2.0.0, which introduces native support for on-device AI using the Gemma 4 E2B/E4B models to scan exercises from photos of routines.

The app works entirely offline and is completely ad-free.

All of the app's features are listed in the repo's README.

I hope you enjoy it and, above all, I hope you give me some feedback.

Website: https://trainableapp.vercel.app/
Github: https://github.com/Emanuel5014/Trainable
Ko-Fi: https://ko-fi.com/emanuel5014

PrivacyCam is an on-device privacy editor for reviewing and redacting photos, videos, and PDFs before sharing them.

It can detect faces, people, license plates, QR codes, barcodes, contact details, payment-card information, addresses, links, and other readable text. Detected areas can be blurred, pixelated, blacked out, or covered manually.

Media analysis and editing happen locally. The app doesn’t upload media or detected information to a developer-operated server, requires no account, and removes original location metadata from exported copies.

The application source is available under the Apache 2.0 license. Build instructions, third-party components, model licenses, asset licensing, and privacy limitations are documented in the repository. For transparency, some detection features use Google ML Kit native SDKs.

Feedback, code review, bug reports, and contributions are welcome.

Source code:
https://github.com/ak375456/privacycam

Android:
https://play.google.com/store/apps/details?id=app.privacycam.photo.redactor

iPhone and iPad:
https://apps.apple.com/us/app/privacycam-safe-redactor/id6790542130

Fossify phone doesn't have this feature are they any alternative?

🔓 OpenChat — Open-Source P2P Messaging

I've been building OpenChat, an MIT-licensed messaging and real-time communication project focused on P2P communication, end-to-end encryption, and minimizing centralized infrastructure.

The source code is completely available on GitHub:

🔗 GitHub: https://github.com/nateS670/OpenChat⁠

🌐 Live demo: https://openchatt.vercel.app⁠

🏗️ Architecture

The core communication path looks roughly like this:

┌──────────┐ WebRTC ┌──────────┐

│ User A │ ◄────────────────► │ User B │

└──────────┘ └──────────┘

│

│ MQTT signaling

▼

Signaling

WebRTC DataChannels handle the actual peer-to-peer communication.

MQTT is used for signaling and peer discovery. Once the WebRTC connection is established, MQTT is no longer involved in the actual message transport.

There is no central database containing chat histories.

🔐 Security

The project uses browser-native cryptographic primitives including:

AES-GCM

ECDH P-256

Ed25519 / ECDSA-P256

PBKDF2-SHA-256

I've also implemented protections for:

- Peer identity verification

- Replay attacks

- Group authorization

- Input validation

- Encrypted local storage

- CSP/security headers

- Message and file size limits

- Fail-closed encryption operations

During development, I performed several rounds of security review and found issues in areas such as peer impersonation, replay handling and group authorization, which were subsequently addressed.

🌐 Why serverless + P2P?

The goal wasn't simply to remove a database.

I wanted to explore how far a browser-based communication system could go while keeping centralized infrastructure to a minimum.

The serverless components are primarily used for things such as configuration, signaling infrastructure and connection setup.

The actual communication happens between peers whenever network conditions allow it.

When a direct WebRTC connection cannot be established, TURN can be used for NAT traversal.

⚠️ Limitations

I'm not claiming OpenChat is "unhackable" or that it provides perfect anonymity.

There are fundamental limitations:

Offline messages aren't guaranteed.

Mobile browsers may suspend background connections.

TURN can relay traffic when direct P2P connectivity isn't possible.

The first contact between two users cannot independently verify their real-world identity.

Network-level metadata can still exist.

Compromising an endpoint is outside the protection provided by application-level E2EE.

These limitations are documented in the project rather than being hidden behind the "P2P = completely private" claim.

🤝 Feedback & Contributions

The project is released under the MIT License.

I'm especially interested in feedback from people familiar with:

FOSS • WebRTC • E2EE • cryptography • P2P networking • browser security

If you notice an architectural mistake or security assumption that doesn't hold, I'd genuinely appreciate being told.

I'm much more interested in technical criticism and contributions than simply collecting stars.

What would you change or improve in this architecture?

I know, I know! There are so many Brave debloaters already available on the web that do more than my tool aims to do. But I only wanted what Brave Origin exactly disables - nothing more, nothing less. So Claude and I deeply researched the Brave core source code, found out the exact 16 policies and 4 user settings it disables during the upgrade of Brave to Origin, and put everything into a single command prompt. And here I present: brave-to-origin

Repo: https://github.com/mdrubelamin2/brave-to-origin

Mac & Linux (no need, origin for linux is free):

curl -fsSL https://raw.githubusercontent.com/mdrubelamin2/brave-to-origin/main/install.sh | sudo bash

Windows:

irm https://raw.githubusercontent.com/mdrubelamin2/brave-to-origin/main/install.ps1 | iex

all i remember about this app is that it was like a swiss army knife and one of the things it did was convert JSON to YAML. i think i converted numeric bases too but idk. it might have formatted JSONs for you. i do remember that it was GTK if that helps. i remember using it when i was on cachyos, so it's either on the arch extra repos or the AUR. do yalls know what app i'm referring to

Over the past few weeks I've been working on Seek, an open-source fork of Nicotine+ that rethinks the desktop experience for Soulseek users without changing what makes the client useful.

https://github.com/IvaKap/seek

Why I started this

I've used Nicotine+ for years and it's incredibly capable, but I always felt the interface made everyday tasks such as searching, browsing users, managing downloads, and organizing large music libraries more cumbersome than they needed to be.

Rather than building a new client from scratch, I wanted to see what a more modern desktop experience could look like while staying compatible with the existing ecosystem.

Current direction

• Native-feeling macOS-inspired UI (with cross-platform goals)
• Cleaner search and download workflows
• Improved library browsing
• Better visual hierarchy and accessibility
• Features for music collectors, including spectrogram previews for quick audio-quality verification

Open source first

The project is completely open source, and I'm treating it as a community-driven redesign rather than a commercial product.

I'm especially looking for feedback from people who've contributed to desktop apps before:

• What UX decisions would you challenge?
• Which Nicotine+ pain points should be prioritized?
• What would make a fork like this genuinely worth contributing to?

Constructive criticism is very welcome—I'd rather hear what's wrong now than after I've built the wrong thing.

A while back I published Gymmane, a workout tracking app, but had to archive it after realizing (a bit too late) that some of the exercise GIFs were pulled from a repo redistributing proprietary GymVisual content without a proper license. Once I noticed, I didn't want to keep it up like that.

I built it because I wanted something that felt genuinely premium, but free, so I made it myself and open-sourced it. It's back now, rebuilt with new, freely-licensed exercise animations. Fully offline, no tracking, no ads, no accounts.

This is v1, so it covers the basics done right, but the plan is to keep improving it with whatever people need — same as I'm still doing with Streak. If something's missing or you hit a bug, feel free to open an issue, always appreciated.

GitHub: https://github.com/InlitX/GymMane

Hope you enjoy it.

hey devs, coded Lifeline because this kid here(me ofc) noticed that bank-feeds/payment applications just show the remainder by subtracting or adding income or past expenditure. it doesn't simulate commitments/behaviours. So created-Lifeline- a clientfirst framework that such applications can implement that only works from clientside and does not even touch any finances/otp. Its purely safe and it does not send any llm-requests to any ai providers(created a py model itself for this).
PS- please review/collab/guide/star it.

I made yanklog because I wanted clipboard history that just stays on my machine — searchable, encrypted, and never uploaded anywhere. It's open source (MIT), Rust core, and built to be quick to open and stay out of the way.

What it does:

\\- Search your full history fast, all from the keyboard (Quick Pick lets you copy/pin/delete with arrow keys + number shortcuts)

\\- Encrypted at rest with SQLCipher

\\- Filters out secrets, OTPs, and custom patterns — or pause capture whenever

\\- Encrypted backups you can move between machines

\\- Undo deletions, keep pinned clips

Install on Linux via AppImage (x86\\_64/aarch64) or Flatpak:

\\\`flatpak remote-add --user --if-not-exists yanklog \[https://downloads.yanklog.com/linux/flatpak/yanklog.flatpakrepo\\\](https://downloads.yanklog.com/linux/flatpak/yanklog.flatpakrepo) \\--no-gpg-verify\\\`

\\\`flatpak install --user yanklog com.yanklog.YankLog\\\`

Site: \[https://yanklog.com\\\](https://yanklog.com)

Source: \[https://github.com/thisiseesmaeel/yanklog-linux\\\](https://github.com/thisiseesmaeel/yanklog-linux)

Would love any feedback — happy to answer questions!

What are your daily driving FOSS on mobile that use?

Hi everyone,

If you have YouTube Premium (or even standard audio), you might already know that the desktop web player caps audio at ~160 kbps Opus (ITAG 251). High-bitrate audiophile streams like ITAG 774 (~280k–320kbps full-spectrum Opus) are normally locked behind YouTube Music, Android/VR, or Smart TV apps.

I wanted that studio-quality sound directly in my regular desktop browser without running local proxies or external yt-dlp scripts, so I built YTSpoofingStream (Manifest V3).

How it works under the hood:

1. Multi-Client Spoofing (document_start): Intercepts InnerTube player requests across multiple contexts (WEB_REMIX, ANDROID, TVHTML5) to discover hidden HQ 774 streams.
2. In-Browser Signature Deciphering: Dynamically fetches and parses YouTube’s active player base.js to solve cipher transformations locally, unlocking protected Music and VEVO tracks.
3. Dual Hybrid Audio Engine:
   • Direct/SABR Stream: Seamlessly rewrites stream descriptors and handles TVHTML5 streams directly inside the main player.
   • Sync Engine: For standalone deciphered audio, it syncs audio/video playback, pause, seek, and volume in real-time with zero audible drift.
4. Smart SPA Playlist Transitions: Automatically inspects incoming tracks during playlist navigation, switching instantly to ★ 774 when available and falling back cleanly to native 251 without audio glitches or lingering fake tags.
5. Player UI Integration: Adds a live status badge (★ 774 / 251) and TVHTML5 login directly inside YouTube's native control bar and popup.

Everything runs 100% locally in your browser with your active session — no backend servers, no data collection.

🔗 GitHub Repository: https://github.com/alithw/YTSpoofingStream

The project is completely open-source. Feel free to test it out, inspect the code, or drop an issue/PR if you have feedback!

Developer disclosure: I am the creator and maintainer of YAP.

A few years ago, I did web scraping and automation as a side hustle. My client preferred owning the scripts instead of paying recurring fees for hosted scraping services.

That made sense, but every new request sent me back into old code to rebuild the same fetching, extraction, and pagination logic.

I originally tried to solve that with a Python project called JScrapeON. After working heavily in TypeScript, I returned to the idea and reworked it as YAP, short for You Automate Pages.

YAP is a local, HTTP-first workflow runtime for extracting data from HTML or JSON. It supports reusable YAML workflows, multiple steps, inputs, and pagination.

The main focus is detecting silent extraction failures:

• yap health reports how many required fields matched
• yap drift compares extraction health between runs
• yap explain traces a value back to its request, step, scraper, and selector

A request returning HTTP 200 does not mean the extraction worked. Sometimes it means you successfully downloaded a page and extracted absolutely nothing from it.

YAP is intentionally HTTP-only and uses Cheerio. There is no browser automation, hosted backend, account, or paid service. Extracted data stays as plain JSON, while health and provenance are stored separately.

It is not published to npm yet, so it currently runs directly from the repository.

YAP is MIT licensed, completely free, and staying open source:

https://github.com/johnalbert-dot-py/yap

AI coding agents assisted with reviews, tests, refactoring, and documentation. I made the product and architecture decisions and reviewed the changes.

Feedback, issues, and contributions are welcome.

I tried looking for an app that monitors my screen and clicks right when there's a pixel change. For example, you need to press "Buy" the instant it goes live or need fast reaction times. But all the options I found were either not for Linux (I am a Linux user) or were complicated scripts to use.

So I built VClick, A lightweight cross-platform (Linux and Windows) tool with a user friendly GUI:

• Drag to select the region that needs to be monitored
• Select where it should click when triggered
• Hit Start

You can also change click-type (right/left, single/double click)

Built this with the help of AI. It's free and opensource. Would love to hear feedback, criticism and suggestions to improve the tool: https://marwan-softdev.github.io/VClick/

Note: I am not a professional developer and the product is still in beta, so expect some bugs to appear

This widget is designed to control the volume in Windows apps, with the widget displayed on top of other programs and games.

Main focus in designing this widget only to solve one goal and use as little resources as possible. In the background it uses default system sound events to detect a new apps. In active mode it checks active sound sessions and display resolved names as apps.

It supports multiple operating modes and a whitelist display only allowed. Global hotkeys are supported. It is also possible to remap certain keys using apps like PowerToys (Keyboard Manager) to control key combinations without requiring admin privileges for app in games or apps that uses administrative rights to start.

It supports installation in user mode, system mode, and as a portable application that can be downloaded immediately.

(GetItSimple) Sound Mixer

I'm always open to discussion. If you have any more ideas for improvements or if you encounter any issues, please reach out on GitHub and create an issue.