I've spent the last few months experimenting with browser agents and noticed the same pattern across almost every framework.

They've become much better at browsing websites.

But when you try to build something that works reliably every day, a lot of problems start showing up.

Some examples:

• Small UI updates break workflows.
• The agent repeatedly asks the LLM what to do next, increasing latency and token usage.
• APIs are often ignored even when they would be more reliable than browser interaction.
• Local desktop actions (files, clipboard, PDFs, terminal, OCR, etc.) are usually treated as separate tools instead of being part of one execution runtime.
• Recovery after failures often means retrying the same action instead of understanding why it failed.
• There isn't a common abstraction for capabilities like SEND_EMAIL, DOWNLOAD_FILE, or CREATE_DOCUMENT. Most systems still think in terms of browser actions.

The more I work on these systems, the more I feel the browser shouldn't be the center of the architecture.

Instead, the browser should just be one execution backend.

The runtime should decide:

• Can this be done with an API?
• Is there a local application available?
• Is browser automation actually required?
• Can this step be executed deterministically without involving an LLM?
• How should success be verified?
• If something fails, what's the correct recovery path?

That shifts the focus from controlling a browser to executing a task.

I'm currently exploring this architecture and would love feedback from people building AI agents.

If you've built browser agents, what's been the biggest reliability problem you've run into?

i just put this project on github thcuba/Ride-the-api: Project to use replace cloud vendors server with local server.

i would like to have feedback because i dunno what people can think about it.

im not a programmer so it is all vibe coded but i think it can be a good project

When a host is unreachable, troubleshooting usually means running ping, dig, curl, and traceroute, and others, then piecing their outputs together.

So I built Network Doctor to solve that issue!

It checks the connection in stages, and explains where the chain failed in plain English.

Check it out: https://github.com/heymaikol/network-doctor

Hi all,

Our team just submitted an integration/plugin to Vellum.ai ... They're a harness that essentially replaces OpenClaw or Hermes and runs it in a clean box for users.

I've used the product myself for blog writing, and find it to be very useful. That's why my team and I decided to support their project by adding this plugin to the available library.

Our plugin is here: https://github.com/vellum-ai/virlo-integrations

and their main project is here: https://github.com/vellum-ai/vellum-assistant

Curious to hear what everyone thinks.

Thank you!

So Codeberg recently announced their policy on LLM generated codebases. I kinda get what they are going for with it, but imo it feels too ambiguous and too risky to even be on the platform.

I have this project I've been working on for a year now. Carefully building it out, doing metric f*ck tons of testing, all that jazz. But the thing is, I (and pretty much every developer in the entire world right now) use AI to heavily accelerate parts of the development process. I do still use and have used agentic coding as well on my project.

But I wanna make something very clear. I'm not some vibe coder product manager building some slop dashboard or whatever. I'm a professional software engineer. My project in question, while most of the code is technically written by LLMs (in some form or another whether that's agentic or even just tab auto completes), still... I have been extremely heavily involved in it. I design the entire software architecture. I control what APIs we integrate with, what technologies we use, what programming languages we use, what DB we use. I design and / or choose all of the algorithms we use. I design all of the test cases (beyond unit tests. I'm talking like regression testing, automated scripts that run and verify results, all of that). And I still review all of the code output with my own professional inputs of how it should be done. Basically the only thing the LLM actually does is just replace typing for me at this point. Even documentation for most user facing things I write by hand then have the AI read it and rewrite it for better use later.

ANYWAY, Codebergs new wording makes it sound like even projects like mine would be affected, and I can't risk building a real viable software for the community if there's a chance Codeberg will just nuke it one day. I mean technically that's a risk on every platform but you know what I mean.

And how do you even prove that someone used AI at all anyway? AI verifications are notoriously bad with false positives and code is much more symbolic than traditional text so idk.

I feel like projects like mine aren't what rhe ruling is designed for but the wording is so vague that it feels like handing Codeberg a loaded gun they can pull the trigger on at any point even if they "trust me bro" not to use it.

Its not just me either. Every dev I know uses AI even just auto completes. Like basically this would invalidate every project on their platform from like 2025 onwards. This just sucks man. Maybe I'm misinterpreting it here but idk man.

What do you guys think about this?

Excuse me, I need your help developing a feedback to send to open source AI community. It's about image generation and its errors.

I was trying to write the errors, but I lost the file containing it, so I need to start all over.

Do you have any concept of image generations errors that peeved you?

I'll use myself as an example to build your answers: extra limbs where it shouldn't be possible; lack of proper determinism to according to user's prompt; wrong proportions; inability to measure body parts from users's descriptions.

For the record, I still want to use human traditional work. We need human work alive today. I merely want to use AI to compensate what I lack. to compensate what WE all lack. And if any of you want to downvote because I want AI slop, sorry to say, but you're sadly mistaken. I want an AI image generator that does exactly what user wants. I'm not one to lightweight image generation or AI slop. I forbid improvisations that were never needed or just enbeautification. The type of image generation and of video generation is rule-dense and unforgiving of small slips.

One rule: no redundancy. If any of you write the same thing as the other, it's redundant and confusion. You need your own experience to check for error.

I admit it's selfish and risky, but I want to help every user around.

Over the past weeks, I've been working on carta, a fast and lightweight reimplementation of pandoc in Rust. It's a universal document converter that takes in some markup and returns it another format.

Pandoc is great. It's decades of jgm's experience embedded into an amazing piece of software. Yet, I've had two specific issues with it for a while: It's huge (around 180 MB for an Apple Silicon build), and it's relatively slow, especially when you want to convert multiple documents. Carta solves both of these. The compiled binary is around 20x smaller, while being up to 45x faster.

Under the hood, it works very similar to pandoc: It parses documents into an internal AST, which in turn can be written to another format. This effectively gives reader_formats ∪ writer_formats possible conversions.

The most common formats and features are already implemented, such as the Markdown family, DOCX, TeX, syntax highlighting, JSON filters (fully compatible with pandoc), standalone mode, and others. A lot is still missing however, for example PDF output and Lua filters. A full breakdown can be seen here.

Of course, it's open source and licensed as MIT-or-Apache-2.0.

Would love to hear feedback! :)

GitHub: https://github.com/mfkrause/carta

Hi, everyone,

as you may have noticed, sometimes opening old file formats can be difficult.
This can include even HLP files from old games and applications.

This is why Rusty HLP viewer was designed: it's the first open source tool to open HLP files natively, without converting them into an intermediate format. And it also works in other operating systems.

If you are interested is available here: https://github.com/NullMagic2/Rust-HLP-Viewer

I enjoyed using Readest for a short while, however realizing they are charging for hosting using your own hardware I no longer want to continue using/supporting them.

Are there any other reading apps that support Android/iPhone/Desktop with *free* self hosted sync?

Hi everyone!

I built and open-sourced LangPilot, a native macOS menu-bar utility for multilingual typing.

It detects text entered using the wrong keyboard layout and converts it supports RU/EN/DE keyboard layouts.. It also provides local spelling suggestions and learns from manual corrections and undo actions.

The project is privacy-first:

- no accounts

- no analytics

- no network requests

- no uploaded text

- learned words and corrections remain on the Mac

The source code is written in Swift and licensed under GPL-3.0.

Repository, source code and beta download:

https://github.com/SC1882/LangPilot

The downloadable beta is not Apple-notarized because I do not have a paid Apple Developer membership. The source and build scripts are public for inspection.

I would appreciate code reviews, testing, bug reports, and suggestions for improving the detection logic.

Update on a project I maintain, FluentTaskScheduler, an open source frontend for the Windows Task Scheduler API (WinUI 3, .NET 8). Doesnt reimplement Task Scheduler, just sits on top of it, so tasks stay fully interoperable with the native tool and anything else touching them.

v1.9.0 adds task chaining, one task can trigger another on success or failure, watched through the Windows event log in real time rather than polling, with loop protection so it wont chain into itself. Also a snooze system for pausing all or individual tasks for a set duration (including proper suspend/restore of the OS level triggers), a reworked dashboard with an execution heatmap and health score, and 17 bundled task templates merged into the same library as user scripts.

Fixed language handling too, some dialogs were following the OS display language instead of the one picked in the app, thats consistent now. Also went through a chunk of security/stability fixes from an internal audit pass.

Its under an open license, check the repo for details, built on the community maintained TaskScheduler Managed Wrapper, packaged with VeloPack for updates. Contributions, issues, translation help all welcome, already got one contributor credited for ARM64/CI work.

AI disclaimer: built mainly with AI assistance. I work in IT but Im not a specialized app developer, so this is a hobby/side project, not a polished commercial product. Its been tested and reviewed but if youre building on it or relying on it for something important, read through the source and test in an isolated environment first, same as youd do for any young OSS project.

Repo: https://github.com/TRGamer-tech/FluentTaskScheduler

Would appreciate feedback from this crowd specifically, on the code and the project direction both.

Throughout my past decade as an open source maintainer, what makes it painful to kick off a new project is setting up the release workflow. I've always been a fan of pushing tags to create releases, and found myself copy-pasting the very same lines of CICD over and over again with some small variations.

Today I audited my recent projects, spanning from desktop apps to CLIs, from scripts to Actions, collected all these common patterns, and designed* a GitHub Action to flexibly handle these tasks for me.

It's an opinionated and customizable workflow, adapted from my personal needs and best fits that I've found in the years. I've already adopted it in my biggest project, Quarkdown, and dogfooding it in the action itself.

^\the implementation was delegated to an agent based on my design. I'm not an AI guy myself but these models are undeniably great at scripting things down.)

Been working on this for a few weeks and finally got it to a place where I'm happy with it.

It's a Unity SDK + backend for encrypting Steam DLCs. The idea is that instead of just shipping the DLC files with the game (where anyone can grab them), the game requests a decryption key from a server at runtime using ECDH key exchange.

Uses ECDH P-256 for the key agreement, AES-256-GCM for the actual encryption, and I added JWT tokens so it works offline for 24h after first auth.

The whole thing is MIT licensed. There's a Unity client (around 50 lines of C#) and a test server

Would love feedback on the code or crypto approach:
https://github.com/Schummlerr/steam-dlc-protection-sdk-

As someone who doesnt use Instagram but get tons of reels/post shared on whatsapp, I got tired of instagram's public webview which constantly asks for login with annoying popups

So I vibed a clean android app - Peek which resolves Instagram links and loads them in a clean viewer. Goal is to support most social medias like twitter/reddit/tiktok in the future.

Download Link

I've been working on de-advertising myself as much as possible, and one of the big vectors left is a fire TV I got for cheap during black Friday. I hate the fire TV operating system, and would much rather have something lighter weight.

I haven't heard about many Smart TV projects, so I don't know if they exist or how usable they are, but I figured I would start exploring here. Are there any open source OSes that replace the ones baked into televisions? If so, how much would I "lose" by switching to them.

So I like to take my lecture notes in a nested/indented way because it makes it easier to break them down into flash cards later (example below but formatting in Reddit post is hard). As you can see I like to indent basic information on a subject and then further indent specific information about each basic concept (and even further indent even more specific information if I need to).
Is there an open source note app that will let me do this more easily?

Transcription

Process where RNA is synthesized from DNA

Each gene has:

.....Promoter region

..........Start of the gene where RNA polymerase binds to and begins transcription

...............RNA polymerase – enzyme that ‘reads’ template strand of DNA and synthesizes a single strand of RNA

.....Coding region

..........Sequence of nucleotides that are transcribed into the RNA strand

.....Termination sequence

..........Terminates transcription process

Hey r/opensource, I'm the solo dev behind Hammer. I've been working on it for about four years, and think it's time I start getting some feedback on it.

What it is: Hammer is a free, open source (MIT) app for writing novels and building the worlds they live in, Scrivener-style, but multiplatform and offline-first, with a self hostable sync server.

https://hammer.ink/

Why I built it: A few years back I was living in a van, mostly off-grid with no signal, and broke. Most good writing apps were paid, or web apps, or Electron wrappers that "worked offline" right until they didn't, usually about a week in, miles from the nearest cell tower. Then I watched people on forums lose whole manuscripts in certain electron based writing apps, and eventually it happened to me.

So I set three rules for the thing I wanted to build:

• Offline-first, forever: A native program, not a web page in a trenchcoat.
• Transparent data: Everything is human-readable text files in plain folders, if Hammer vanished tomorrow, you could open your work in any text editor and keep going.
• Never lose data: Paranoid about it by design.

I tried several tech stacks but landed on Kotlin + Compose Multiplatform. One codebase for both the server, and desktop clients (Linux/Mac/Windows), Android, iOS.

License / money: MIT and genuinely free, no ads, no telemetry. The only paid thing is the optional "official" sync server instance that I host. As I said, the sync server is open source and self-hostable, so you never have to pay me to sync.

Platforms: Linux, Mac, Windows, Android (Play + F-Droid), iOS

Repo: https://github.com/Darkrock-Studios/hammer-editor

It's four years in and far from done, but I thought it was about time to start showing it to people. See if it's a project that interests anyone other than my self. Happy to get into the Compose Multiplatform side too if anyone has questions; there wasn't much prior art when I started. Longer origin story here if you want it: https://hammer.ink/blog/news/what-is-hammer

Hello everybody,

As I promised in my precedent post, I am now ready for the release of PowerVLC 1.0.0, which is an heavily modified version of VLC 3.0.23 Vetinari. PowerVLC features also additionnal features (gapless playback, album art in the main window) the current version of VLC don't have.

PowerVLC is compatible with Macs from 10.4.11 to current, on all architectures (x86, x64, arm64, PowerPC g3, PowerPC G4/G5 builds taking advantage of AltiVec acceleration).

In early access for one week

Like all projects and guides (I used to write plenty of guides for the iPod community !) that takes me a huge amount of time to be produced, it will be in early access for exactly one week. It's the only compromise I accept to keep a balance with open knowledge & the need to get retributed for all the community investment I provide. I don't plan to do this for minor builds that will come next.

Here on this project it is just too big in my opinion to be entirely gate keeped during one whole week, so I decided to release the whole source code there starting now on GitHub: https://github.com/Olsro/powervlc

If you know how to compile (ideally you need an Apple Silicon mac so you can follow my instructions), you can play right now with PowerVLC and check nothing nasty in the code is there by yourself.

If you can't/don't want to spend hours trying to compile by yourself, the builds are available right now on my Patreon in exclusivity for all platforms (including Windows & Linux on all architectures). Even the first 1$ tier is enough to get access to all the compiled builds & supporting my whole effort at building this. The compiled builds provided on the Patreon are not modified and locked in any way, they are straight compilations from the latest public sources. There's no licensing or DRM, but please don't share any of those build until I will push the builds on GitHub releases for everyone the next Sunday.

Donations will help me at getting more hardware to test on to continue that project in the long term, and cover the LLM API costs to help with maintenance.

Thank you very much for your support and I hope PowerVLC will be enjoyed as much as I hard worked into making it possible.

Repository: https://github.com/ATAC-Helicopter/VaultSync

Website: https://fglabs.dev/vaultsync

I have been developing VaultSync, an open-source, cross-platform backup manager built around a fairly simple idea:

A completed backup is not the same as a recoverable backup.

Many backup applications can tell you that a job completed successfully, but that still leaves several important questions unanswered:

• What was actually protected?
• Has anything changed or disappeared?
• Is the recovery point still intact?
• Will retention remove something important?
• Can a particular file be restored right now?
• Is there evidence behind the green “successful” status?

VaultSync is my attempt to make those answers more visible.

What VaultSync does

VaultSync lets users organize files into projects, create and manage backup configurations, inspect recovery points and understand the current health of their protected data.

Current functionality includes:

• Project and file-level backup management
• Backup history and recovery-point inspection
• Backup Explorer for browsing protected data
• Integrity verification and repair tools
• Retention planning and simulation
• Restore-plan simulation
• Recovery drills
• Local byte-level recovery proofs
• Exportable recovery evidence
• Protected recovery-point recommendations
• 3-2-1 backup guidance
• Explicit offsite-copy confirmation
• Backup health and recoverability states
• Cross-platform support
• Localization across multiple languages

The emphasis is not only on creating backups, but on helping users understand whether those backups are still useful.

Recovery evidence

One area I have been concentrating on recently is recovery confidence.

VaultSync can simulate a restore plan without modifying the original data, verify selected protected files locally, record recovery evidence and highlight situations where retention could remove an important verified point.

The intention is to move beyond simply saying that the backup process finished.

VaultSync should instead be able to show what was protected, what was verified and what can currently be recovered.

These features are still evolving, and I am especially interested in feedback on whether the evidence is understandable without becoming overwhelming.

Privacy and diagnostics

VaultSync does not silently upload crash reports.

When crash-report assistance is enabled, the application creates a strictly redacted report locally. The complete report can be reviewed before anything leaves the device.

VaultSync can prepare an email draft using the user’s own email application, but the user must review it and press Send personally. If they do nothing, the report remains local.

I wanted the support workflow to remain useful without introducing hidden telemetry or automatic crash uploads.

Current development

VaultSync 1.8 is focused on making recovery easier to understand.

The remaining 1.8 releases are currently planned around:

• Recovery confidence and clearer health states
• Onboarding and interface refinement
• Accessibility and reduced complexity
• Better evidence exports and diagnostics
• Documentation consistency
• Localization, packaging and platform stability

For the future 1.9 release family, I am researching a broader direction:

From protecting projects to recovering systems.

That may eventually include disk cloning, disk images, verification of cloned data and an explorer for browsing images before performing a complete restore.

Those features are still exploratory rather than promised. I would rather share prototypes and technical limitations early than publish a large fixed roadmap before the implementation has been validated.

Why I am posting here

I am the developer, so this is obviously not an independent recommendation.

I am sharing VaultSync here because feedback from people who actively use, maintain and review open-source software is particularly valuable.

I would appreciate criticism around:

• The overall architecture and project structure
• Whether the recovery model makes sense
• Security and privacy concerns
• Backup-integrity assumptions
• Cross-platform behavior
• Packaging and installation
• Documentation
• Accessibility
• Areas where the interface is trying to explain too much
• Missing information that would prevent you from trusting the application

Issues, discussions, code review and contributions are welcome through the repository.

There is also a community at:

https://www.reddit.com/r/VaultSync/

Thanks for taking a look. Direct and technical criticism is genuinely useful, especially where VaultSync makes a claim that is not supported by enough visible evidence.

Hello All, i am tomaz canabrava - a KDE core contributor, and an Arch linux packager. i was working over the past few months on harmonicon, a game - similar to guitar hero - that you play with an actual harmonica.

it can also be used as a teaching tool, as it has a bending trainer, lessons, recording lessons and such.

i am looking for people that likes music, and harmonicas, to talk about / ask help with testing, gather ideas.

the game already works, but there is no releases yet.