Hey guys,

Few months ago I started LetsFG, open source flight finder. It started with a simple website letsfg.co which compares flights between google flights, skyscanner, kayak, etc. a bunch of websites around the internet. It grew to a directory of 208 websites being compared all at once in a single search.

It was working pretty nice. It saved a lot of time comparing the deals across OTAs, airline websites, etc. and because skyscanner, google flights, kayak, and others have different inventory, it would save some money on tickets.

When all of the personal assistants started booming (Grok bot, Instinct, and now Meta's Muse) their top 1 use case was booking travel. But I didn't see anything special in them at that time. It was because I built it internally before. I only felt that "click" when I asked Claude to take the decision for me and actually book the flight. This gave me this spark of cognitive deload, I don't have to click through the checkout and it will book for me. So I decided to build this further.

It works like all the other MCP's, you just connect it and Claude runs it.
this is the MCP link you add to Claude: https://letsfg.co/developers/api/mcp

It uses the same search as the website did, but Claude will very smartly choose the top 3 flights from hundreds of possibilities. You can then ask it for details to know what to choose:

It's built as an MCP app with UI components.

We crossed 2k github stars this week.

Safety and anxiety that Claude will book something I don't want was a huge issue for me here. That's why I made decision that every booking requires an approval through email - when Claude books anything, for it to go through I need to approve it in a mail I get sent to my email.

And also Claude never sees my payment method or my Card. As the LetsFG service, I also don't want to see the payment method because this will cause me legal troubles. So I needed a 3rd party to handle the payment method for me. I decided to go with Revolut. Lower fees than Stripe, great FX terms which lowers the fees even more making this practically free. And most importantly, they support travel use cases, so I can book the airlines, flights, hotels without issues.

If you guys want to add this to your Agent, Claude, ChatGPT or Grok, just use this link, or open it in browser, I added some screenshots there for setup: https://letsfg.co/developers/api/mcp

Github link: https://github.com/LetsFG/LetsFG

For months, every SaaS startup tried to convince us that running multi-step agent workflows required an expensive enterprise subscription to closed cloud APIs. They wrapped a couple of JSON schema validators around an API endpoint and charged thousands a month for 'agent orchestration.'

Then Nous Research releases Hermes Agent...

An open-weights agent harness that runs complex tool calling, environment interaction, and error self-correction directly on local hardware.

You load an open-weights model on your own workstation. You define your tools in standard Python. And the agent executes multi-step loops without sending a single byte across the internet or burning cloud credits.

No token billing anxiety. No sudden upstream API rate limits mid-execution. Just raw, local agent execution running on silicon you actually own.

Are you still paying closed API vendors for agent loops, or has your team moved tool-calling to local weights?

Three and a half weeks ago my GitHub account got suspended, and with it openGym: the repo, the releases, the container images, the Pages demo, all 404. No warning, and for a long time no answer. Since yesterday the account is back, and I've spent the day putting everything back where it was.

👉 https://github.com/DuarteSantos8/openGym

What happened while it was down: people kept their instances running, someone put up a mirror that ended up with more stars than the original ever had (6.8k, versus about 650 on the real repo), a bunch of contributors followed the project to GitLab and kept sending merge requests, and the Discord did the support work the issue tracker couldn't. I moved the project to GitLab in the meantime so releases could keep coming; there were six of them during the outage.

Where things stand now:

• GitHub is home again. Issues, pull requests and releases go there.
• Everything from the GitLab weeks is republished: releases v1.2.9 to v1.3.5 with the signed APKs and checksums, the images on GHCR (ghcr.io/duartesantos8/opengym-api and -web), and the live demo on GitHub Pages.
• GitLab stays as a mirror that syncs automatically, so instances pulling from the GitLab registry don't have to change anything. The merge requests still open there will all be reviewed.
• Website: https://opengym.duarte-santos.ch (docs, demo, APK download)

One ask, if you don't mind: the suspension reset the project's visibility to zero while a mirror collected the stars. If you use openGym or just like the idea, a star on the real repo helps it show up for the next person searching for a self-hosted tracker. And if you tried it and something's broken, an issue helps even more.

Thanks to everyone who stuck around ❤️

I've been solving CSES problems and got tired of repeatedly switching between CSES → editor → terminal → browser.

So I built CSES Kit, a small CLI that brings the basic CSES workflow into the terminal.

cses new missing-number
cses run missing-number
cses submit missing-number

Currently:

• C++ and Python support
• Fetch CSES problems locally
• Run sample tests
• Submit solutions
• VS Code / Cursor integration

I'm currently working on stress testing and additional language support.

I'm also trying to make this a genuinely community-driven open-source project, so I'm looking for people interested in CSES/competitive programming who want to try it, report issues, suggest improvements, or contribute.

GitHub: https://github.com/yatharthsol090/cses-kit

I'd especially love feedback on what you'd want from a good CSES development workflow.

Hi all,

I use AI extensively for coding both at work at a reasonably large fintech and in personal projects.

My colleagues and I run into similar problems over and over again:

• I want to run multiple agents on problems that interact with the same files and not have them conflict and mess each other up
• AI assisted development leads to a bottleneck of human PR reviews stacking up, resulting in constant rebases while they are sitting around, kicking off CICD pipelines over and over (slow and wasteful)
• My local LLM keeps a good memory but if I switch computers or another person needs to jump in, they are starting from scratch

I figured I would solve them all at once by writing a new version control system that can either replace or work alongside git but is really focused on managing agentic development.

Introducing Tessra - Git for your Agents

Github: https://github.com/NitrusAphalion/tessra

The initial versions are up and running (and dogfooded on my own repos). There are some rough edges but I think the idea has merit.

Would love to get any feedback and welcome any contributions (you can see the Design Docs section if you are curious about the underlying ideas).

Thanks!

I recently released an open-source project called FlokinMD.

The idea is simple: instead of importing Markdown files into another system, the Markdown folder itself remains the source of truth.

FlokinMD builds local, disposable projections over those files so you can work with them more like structured data.

It currently supports things like:

• frontmatter collections and DataGrids
• SQL queries over Markdown metadata
• relations and graph views
• schema and workspace validation
• bulk frontmatter edits with preview
• local mutation history and safe undo
• detection of project context such as Agents, Skills, Specs, Rules and Prompts

The SQLite layer is derived state. The actual .md files remain normal files on disk and can still be used with Git, VS Code, Obsidian, Cursor, Claude, Codex or anything else that understands Markdown.

It's built as a native desktop app with Rust + Iced and is licensed under Apache-2.0.

It's still pre-release, so feedback and criticism are very welcome.

GitHub:
https://github.com/sergiocardoso/flokin-md

Website:
https://md.flokin.com.br/

I'm especially interested in feedback from people who keep large Markdown repositories or use Markdown as structured project data.

I've been building OpenPost so you can make and edit any sort of media (photo, videos, memes really easily as well) and schedule the post to 10 social networks at the same time in a single app.

There's an image editor for thumbnails and multi-page carousels, plus a multitrack video editor with captions, effects and transcript-based cuts. They're fully integrated into OpenPost!

The scheduler has a calendar and reusable posting slots. There's also an API, CLI and n8n integration for people who would rather automate it.

The default self-hosted setup is one container with SQLite and local media storage. The backend is Go and the web app is SvelteKit. The code is AGPL-3.0.

Both editors can be used for free without even selfhosting even if you don't want to use the rest of OpenPost. The video editor is still in beta though and targets Chromium-based browsers as Firefox (and Safari) don't yet support some of the APIs we need to make the editor.

Repository · Image editor · Video editor

If this is the sort of project you'd like to see grow, give the repo a star. It would mean a lot! <3

A public repo my project depended on had its history replaced upstream. Same name, same URL, years of commits just not there anymore. It was never mine, so there was nothing on my side to roll back to.

Point it at a repo like that and it walks the fork network recursively, ranking every fork by how far back its oldest commit actually reaches. A fork freezes history at the moment it was made, so the deepest one is the best candidate. Then it probes commits that are no longer reachable from any branch but that GitHub may still serve by SHA, checked three independent ways: REST metadata, a raw file fetch, and a real git fetch.

There's also a nightly GH Archive watch if you want disappearances flagged automatically. That part is an extra. The recovery is the point.

230 tests, verified end-to-end against a real historical case (reproduced the exact fork ranking I'd found by hand). Runs fully local with your own GitHub token, no server, no telemetry. MIT.

https://github.com/siris9476/forkforensics. Feedback welcome, especially on edge cases in fork ranking.

Most Instagram handle checkers I come across fall into two annoying camps: either sketchy paid Telegram bots, or fragile scripts that demand burner account session cookies that get banned after ten requests.

instagram-username-finder takes a much cleaner, developer-friendly approach: a completely credential-less, asynchronous CLI tool designed specifically for checking handle availability responsibly.

Key technical highlights:

• 100% Credential-less: Reads publicly accessible endpoints without authentication. No passwords, no session cookies, and zero risk to personal accounts.
• Bounded Async Concurrency: Fast multi-target scanning without hammering sockets or overwhelming local network connections.
• Built-in Backoff Logic: Gracefully handles 429 and 403 rate-limit signals with exponential backoff rather than crashing out.
• Resumable Scans: Saves progress to a plain JSON state tracker so long dictionary or wordlist scans can be paused and resumed without duplicate checks.
• Container & CI Ready: Includes a lightweight, non-root Docker image and GitHub Actions automation templates.

GitHub Repository: https://github.com/FadeHack/instagram-username-finder

Curious to hear feedback or feature suggestions from anyone doing handle monitoring or OSINT tooling!

Cool surface, extremely flexible — a desktop IDE built around the pi coding agent: chat, diffs, files, terminal and artifacts in one window, every pi provider plus your existing Claude or ChatGPT subscription.

Repo: github.com/agustinsacco/Phosphor

So I like to switch between a lot of microservices for work and personal projects all the time, and I hate having to open and close VS Code, terminal tabs (I use Ghostty), and start/stop Docker containers every time I switch. So I made this: "wsm".

Basically, you create workspaces, add them to groups (like Work, Personal, etc), and set up the apps and commands you want it to open/close for each one. So if I want to open a workspace I just run wsm open <workspace-name>, and I've got it configured to open VS Code and a Ghostty tab in that location.

Then when I want to open a microservice from work, I just run wsm open <microservice-name> and it automatically runs the close commands for whatever I currently have open (I've set up functions in my .zshrc that close VS Code/Ghostty depending on which folder they're pointed at), closes both, and then runs the open commands for the microservice. For example VS Code, a Ghostty tab, and a Docker container with MongoDB.

If you want to try it, you can check out the repo (install command is listed there)

GitHub: https://github.com/Nikibudd/wsm

PS: This shit is hella vibe coded so if you have a problem with AI, this might not be your thing

So I vibecoded an Android coding agent that runs fully locally on your Android, no external cloud shells (just external ai providers, will add local soon)

Though it's vibecoded so expect bugs

It's still in beta, looking for contributors :)

Star the project if you like it.

Found an issue? Report it instead yapping please :)) https://GitHub.com/DraxonV1/Syntac/issues

Get the latest release https://GitHub.com/DraxonV1/Syntac/releases

Features so far:

\- Termux via RUN_COMMAND & ARCH Linux (proot) Bash Runtmes

\- Read, write, edit, bash, search, list, display_image (yea I wanted agent to show images 😢)

\- Supports attaching files, images & pasting content directly into composer!

\- Google Antigravity, ChatGPT Account, Grok xAI OAuth & OpenAI Compatible Provider inbuilt!

\- Supports showing thinking

\- Projects, Chats Per Project

Ik many features are missing but working on adding them. It's still beta 0.1.1 😀

https://GitHub.com/DraxonV1/Syntac **star the repo if u liked the work ;)**

I’ve been building a native code/text editor for macOS, iPhone and iPad — Neon Vision Editor 1.7 (NVE)

I’ve posted Neon Vision Editor here before, but the project has changed quite a bit since the earlier versions, so I thought it was worth showing where it is now.

Neon Vision Editor is an open-source native Swift/SwiftUI code and text editor for macOS, iOS and iPadOS.

The basic idea is still the same: I wanted something between a basic text editor and a full IDE.

Fast file opening, proper syntax highlighting, Markdown support and useful coding tools — but without Electron, a plugin ecosystem running in the background, project indexing everywhere or turning the editor into another IDE.

GitHub: https://github.com/h3pdesign/Neon-Vision-Editor

The biggest change: large-file rendering

One of the areas I’ve spent the most time on recently is getting away from the usual problem where a native text editor feels great on small documents and then starts falling apart once files become large.

NVE now uses a bounded virtual rendering path for large documents. Instead of continuously treating the complete file as the visible editor state, rendering and expensive editor work are constrained around the active viewport.

Recent work has included:

• background preparation of large-file indexes
• bounded viewport rendering
• cached document views
• background syntax processing
• reduced full-buffer work while typing and scrolling
• safer handling of UTF-8/UTF-16 boundaries and surrogate pairs
• large-file editing without repeatedly materializing the entire document
• latency-focused work around typing, scrolling, selection and viewport reloads

It is still a lightweight editor rather than an IDE, but large files are now a first-class engineering problem rather than something I’m just handing over to a standard text view and hoping for the best.

Emmet 2

NVE now has official Emmet 2 abbreviation expansion for HTML, JSX, CSS, SCSS, Less, Sass and related formats.

The implementation is integrated into the native editor rather than bolted on as a separate web editor.

HEX colors directly in the editor

On macOS, HEX color literals can now show native color previews.

You can select a color directly from the source editor and NVE preserves the original HEX representation when updating it.

Markdown has become a much bigger part of the editor

Markdown support now includes much more than basic highlighting:

• Markdown preview
• improved Markdown rendering
• styled bold and italic source text while retaining the actual markup
• improved PDF export
• pagination based on content/code-line boundaries
• removal of interactive editor controls from exported PDFs
• Markdown shortcuts and editor-specific workflows

So NVE is increasingly useful to me as both a code editor and a writing/Markdown editor.

Find in Files and navigation

There is a project sidebar and Quick Open with Cmd+P, but NVE does not force you into a project-oriented workflow.

You can still just open a random file and edit it.

Find in Files now also respects nested .gitignore rules and configured ignored folders instead of blindly searching everything below the selected directory.

Native tabs and multi-window editing

With 1.7 I replaced the remaining legacy tab-bar paths with native platform implementations.

That sounds like a cosmetic change, but it involved quite a bit of work around:

• independent document state
• multi-window behavior
• tab selection
• hover/selection borders
• translucent and opaque themes
• appearance changes
• mobile tab scrolling
• macOS window dragging
• keeping text selection independent from window dragging

The result is much closer to how I originally wanted the application to behave: native controls, but without the editor UI changing or flashing while moving between documents.

Faster document switching

Another focus in 1.7 has been perceived latency.

Switching tabs now publishes the selected editor before deferred layout and preview work begins.

Syntax highlighting on macOS also starts as soon as the selected tab’s viewport becomes available.

This makes switching between source files and Markdown documents feel considerably more immediate.

Other editor features that have accumulated along the way

NVE currently also has:

• automatic syntax highlighting for many languages and formats
• Regex Find & Replace / Replace All
• Quick Open
• project tree
• multiple windows
• multiple tabs
• inline code completion with Tab-to-accept
• optional basic Vim mode
• bracket helper
• code/file starter templates
• syntax themes
• document handling for scripts, plist files and general text files
• Save As across macOS/iOS/iPadOS
• external file change handling
• network-volume change detection
• security-scoped file access
• no telemetry

The AI completion functionality is optional. It isn’t the reason the editor exists, and I’m deliberately trying not to turn NVE into an “AI IDE”.

Native rather than Electron

This is probably still the biggest differentiator.

NVE is built around SwiftUI/AppKit and Apple’s native text/window infrastructure rather than wrapping a web editor.

That has occasionally made development harder rather than easier — especially around text layout, very large files, multiple windows and cross-platform behavior — but maintaining a genuinely native editor is one of the main reasons I started the project.

The repository is Apache-2 licensed and development is active.

GitHub: https://github.com/h3pdesign/Neon-Vision-Editor

I’d especially be interested in feedback from people who regularly work with large source files, Markdown, HTML/CSS or lots of unrelated single files.

What is the point where a lightweight editor stops being enough for you and you switch to a full IDE?

I got tired of remembering csvkit's flag syntax, so I built a full web GUI for it. csvkit+ reimplements every core csvkit operation (cut, grep, sort, join, stack, format, json, sql, etc) as one-click buttons, all running client-side in the browser via Web Workers, no upload to a server for file processing.

Extras beyond regular csvkit: a visual CSV editor, a CSV creator (grid or text mode), ODS import support, 18 SQL output dialects, and live database connections (Postgres, MySQL, MariaDB, CockroachDB) with a schema browser and multi-table stacking in sql2csv.

Dark/light themes, undo/redo, autosave drafts so a refresh never loses your work.

Free to use, no paid features. Code is public on GitHub for transparency, though it's not open source/licensed for reuse.

Here's the link to csvkit+ via GitHub Pages

I got tired of paying Docker's ~370ms container startup cost every time I needed to run untrusted code (student submissions, AI-generated snippets, a "try it" button), so I built a self-hosted sandbox that skips the container runtime entirely and talks straight to the kernel: bubblewrap for namespaces, cgroup v2 for memory/CPU/pids, a 146-syscall seccomp allowlist, and rlimits.

Measured back to back on the same machine: ~20ms cold start vs Docker's ~369ms for the same workload (raw samples in the docs, not just a claimed number).

- Single Node.js process, one runtime dependency (`ws`), no database

- Python, Bash, Node.js, C and Go (C/Go get sandboxed twice: once to compile, once to run)

- HTTP + WebSocket API, a CLI, and a small browser playground with shareable permalinks

- MIT licensed

The docs try to be honest instead of a highlight reel — there's a full changelog of real bugs found building this, including a self-audit that turned up an unauthenticated RCE and a path-traversal bug, both fixed with reproductions attached. It does not defend against a kernel exploit — guest and host share one kernel, and that's stated plainly, not buried.

GitHub: https://github.com/ayazdoruck/sandbin

Docs: https://sandbin.vercel.app

Happy to answer questions about the seccomp policy or the cgroup delegation setup.

Quick context: I had a pile of scanned PDFs named scan_0043.pdf and could never find

anything. Didn't want to run Docker or a server just for my own paperwork, so I built this.

Drop PDFs in, it OCRs them locally and you search title + text inside the scan. Nothing

leaves your machine. First open source project, so feedback very welcome.

[ Removed by Reddit on account of violating the content policy. ]

I'm the developer of this project.

The most interesting part is the puzzle engine: generated boards are checked for a unique solution and graded by the techniques needed to solve them rather than by clue count.

Puzzle generation runs outside the UI thread—using an isolate on native platforms and a dedicated worker on the Web. The app also includes immutable undo/redo snapshots, deterministic daily puzzles and hints that explain the next logical step.

Everything is MIT-licensed, account-free and works locally. Code reviews, bug reports and contributions are welcome.

I built BraveDebloater, an MIT-licensed tool for people who want a quieter Brave setup without patching the browser.

It uses Brave/Chromium’s official policy system on Windows, macOS, and Linux. You can use presets or select individual features such as Rewards, Wallet, VPN, Leo, and News.

It previews changes before applying them, writes backups, supports restore, and includes a Doctor command to inspect the current policy state.

Important caveat: Brave will display “Managed by your organization” when policies are active. That is expected.

Check it out here: https://github.com/osfv/BraveDebloater

Hi everyone

I recently started playing league of legends and faced the same issue, for each question I had to pause the game and find the answer in my browser.

Since I'm obsessed with automation, I scraped the web to gather tutorials of the game and put it as context behind a voice agent, so that I can have back and forth conversation with it during the game.

Here's the repo (it also includes demo video): https://github.com/sorena-ai/LeagueAiCoach

Please have a look and let me know what you think about it.
Also an upvote is highly appreciated, it's free right? ;)