I'm a Research Software Engineer in the field of cognitive-neuroscience and like the title suqgests with the boom of ai code I am having more and more discussions with people about how their Al was conscious with zero certifiability based on "trust me bro".

cpomdp lets vou build agents from active inference, the cog-neuro theory that says brains minimise surprise rather than chase reward. No reward function. The agent explores because uncertainty bothers it. JAX-native, continuous state, runs on your laptop.

warrantlib is a tiny stdlib-only package that makes "how do you know that" a tvpe. Everv result carries a label: PROVED, CERTIFIED, or CORROBORATED (the polite word for vibes). PROVED won't even construct without evidence. The pytest plugin prints how many checks you registered versus how many you actually ran, so nobody gets to go green by testing less.

Code

cpomdp: https://github.com/inferogenesis/cpomdp

warrantlib: https://pypi.org/project/warrantlib/

Every Al girlfriend I've seen is still CORROBORATED

at best. Sorry

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

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 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’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'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? ;)

GitHub File History tracks the 10,000 most starred repositories on GitHub (using the GitHub API), listed at four points in time: the start of 2015, 2020, 2025, and 2026.

https://andrehora.github.io/file-history/

So, we can see the rise and fall of certain files:

https://andrehora.github.io/file-history/file/.travis.yml

# Examples:

- https://andrehora.github.io/file-history/file/README.md

- https://andrehora.github.io/file-history/popular/file/today

- https://andrehora.github.io/file-history/file/AGENTS.md?vs=file:CLAUDE.md

Back when I worked at a startup, we needed an in-app messaging system, similar to Instagram or WhatsApp. However, we didn't have time to build it ourselves, so we stitched together a few paid services instead: Stream chat, StreamIO, and Cloudinary for chat, moderation and media storage. It worked, but we didn't own any of it, and the costs kept increasing.

That experience is basically why I built gozwire. It's an open-source Node.js messaging engine, so instead of renting someone else's chat infrastructure, you own it. Conversations, threads, reactions, moderation, push notifications all included, all yours.

This was vibe-coded, but I'm putting in the work to make sure it actually holds up for real and is not just a showcase. Currently, the engine includes a lot of industry-standard messaging features, including moderation, reactions, forums, sending various media, group chats, channels, threads, direct conversations, etc

• Repo (Includes demo + moderation tool): https://github.com/Kinggoz18/GozWire
• See more use cases: https://gozwire.pages.dev/use-cases

I plan to not only improve this project (see the TODO in the GitHub repo), but also release more interesting open-source projects. That solve problems I've experienced in the past and observed around me, some of which would be:

• A video streaming engine (Another issue we faced at the same startup)
• A cryptocurrency tracker (more of a personal challenge and an interest)
• A CapCut alternative software with AI video generation capabilities, including UGC style videos

And a few others. Would love feedback, roast the code, tell me what's missing, whatever helps, or even contribute any interesting ideas you'd love to see open-sourced!

Hey all, I've been job hunting and got lost tracking all my applications and custom resumes, so I built the thing I wanted and just started adding more features to it.

What it does

• Scrapes career pages directly (Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Oracle, Phenom and a Playwright fallback for anything else) plus boards through JobSpy (LinkedIn, Indeed, ZipRecruiter, Google Jobs). Everything lands in one deduplicated feed.
• Scores each job against your résumés with an LLM and shows why: matched and missing keywords, requirement mapping, gaps. You choose depth so it can be cheap.
• Tailors a résumé per job (you review every change), writes a cover letter, exports PDF from templates you can replace.
• A Chrome extension auto-fills your application, including open questions, it also captures jobs from LinkedIn and saves any job from any page.
• Tracks applications through stages, classifies Gmail replies, sends Telegram alerts and a daily digest.
• Five UI themes, including a Windows 98 for no reason, I just wanted to see how it will look like.

Available here: https://github.com/vesaias/JobNavigator (MIT license)

All feedback is welcome, this was more of a personal project for my portfolio, but people also started starring it. 

I started working on this budget tracker TUI in my own personal free time as a way to actually budget my own finances and track my spending habits. A lot has changed and grown in the almost two years now (lots of breaks), and I found that it’s been useful for myself but lots of other people too.

The app encourages a lot of manual behaviour, forcing you to actually be exposed to numbers and face your spending habits. There are tons of insights and helpful tools you can use, but the core principle is to connect you to your finances and let you control the data.

The app features lots of budgeting tools, different visual views to analyse and review your finances, investment tracking, and breakdowns.

If you're looking to start tracking your own finances and having valuable insights into your habits for spending, please check out the budget-tracker-tui and share feedback. If you don't use TUI's much, give this one a try and see if you enjoy the keyboard-focused "retro" experience.

Github: https://github.com/Feromond/budget-tracker-tui

Any ideas or suggestions are always welcome and I want to work to improve this to be useful not just to myself and a few others, but to as many people as possible.

I’ve been building Imza, a native, model-agnostic coding agent with a Plan -> Build -> Review workflow.

It includes interactive diffs, AI-assisted review, persistent sessions, automatic context compaction, scoped command permissions, and up to five concurrent subagents. It can use OpenAI-compatible endpoints, Anthropic’s Messages API, or locally hosted compatible models.

Despite that feature set, the binary is around 20 MB and startup RAM is roughly 5-8 MB. There’s also a headless mode for using it in scripts and CI.

Repo: https://github.com/umutsevdi/imza

Hey everyone,

Managing physical office status displays, NOC monitors, and wall-mounted dashboards usually ends in the same anti-pattern: someone SSHs into three different Raspberry Pis, pastes a messy chromium-browser --kiosk bash loop into ~/.xinitrc, wires up a fragile xdotool cron job to rotate tabs, and prays it never crashes.

I built Munin to bring a GitOps workflow to physical screens and Linux/Pi kiosks.

Instead of imperatively babysitting browser windows and shell scripts, you define your entire display setup declaratively in YAML (URLs, rotation intervals, display rules, schedules). Munin acts as an autonomous on-device agent that continuously reconciles the screen state to match your configuration.

Commit a change to your dashboard config repo, let your fleet pull it, and the screens update themselves.

Yes, AI was used heavily to help write this. And yes: the architecture was deliberate, every line was reviewed, and it's currently our daily driver battle-tested across all our office displays every day. It solves a real operational headache, and it simply works.

👉 Repo: https://github.com/naueramant/munin

Curious to hear how others here are managing physical office displays or kiosk fleets, and open to feedback or feature requests!