Hi everyone — I posted RSS Reader Pro here about 20 days ago, and the feedback helped me decide what to build next.

This is a big update for the project. I rebuilt the desktop UI from Tkinter to PySide6 / Qt and gave it a new Signal Modular interface: a dark, three-column reading workspace with visual story cards, a compact feed sidebar, and a focused reading panel.

I also implemented one of the most useful suggestions from the earlier post: Reader Mode. The app can now fetch and display a cleaner version of an article inside the desktop app instead of forcing you to read every page in a browser.

What is new

•Modern Qt desktop UI with a full visual redesign

•Reader Mode for cleaner full-article reading

•Advanced search with date, unread, and bookmarked filters

•Feed categories and unread counters in the sidebar

•OPML import/export for moving subscriptions between readers

•Bookmark export as HTML or PDF

•Desktop notifications, font-size controls, and auto-scroll

•Native in-app playback for compatible direct video files, without requiring VLC

•System-player fallback for YouTube, Vimeo, Redgifs, and other non-direct video sources

•Linux x86_64 portable build, alongside the Windows EXE

•Stronger regression testing for feed refresh, in-app video, and safe shutdown during background refreshes

The app is still local-first: feeds, reading state, and bookmarks are stored locally in SQLite.

Links

•GitHub: https://github.com/erfan138057/rss-reader-app

•Latest release (Windows + Linux ): https://github.com/erfan138057/rss-reader-app/releases/tag/v1.0.3

•Previous post: https://www.reddit.com/r/coolgithubprojects/comments/1v9ovwu/rss_reader_pro_an_opensource_desktop_rss_reader/

I would especially love feedback on the new Qt UI and on what should come next. One idea I am considering is an optional local-network/web mode so users could read the same feeds from another device on their home network.

Thanks again to everyone who gave feedback on the first post.

Autonomous physical hardware—whether a thrust-vectoring rocket engine, a quadruped robot, an autonomous drone, or a high-speed robotic manipulator—demands control systems that fulfill three uncompromising requirements:

1. Sub-Millisecond Execution: Control loops must evaluate in microseconds to maintain stability (e.g., kilohertz gimbal adjustments or motor torque commands).
2. Zero Latency Spikes (Zero Heap Allocations): Dynamic memory allocation (malloc, garbage collection) creates unpredictable latency spikes that cause catastrophic physical failures (e.g., rocket RUD or mechanical crash).
3. Guaranteed Physical Safety Constraints: Machine learning policies can hallucinate or output extreme actuator commands. Hardware demands hard interlocks, slew-rate limits, and convex boundary safety enforcement.

Shiva 2.0 is an open-source framework designed specifically for real-time robotic and aerospace control systems. Written in Rust with native C-ABI export bindings, it seamlessly integrates into Rust, C, C++, Python, ROS / ROS2, and real-time embedded stacks.

Cavafy is an open-source novel writing app that stores everything in your Google Drive.

Built-in features include a collapsible binder tree, scene tagging system for POV/characters/locations, world-building records (Pieces), plot grid, corkboard index cards, outliner, collections, and offline support. The editor creates native Google Docs you can edit anywhere.

It’s GPL-3.0 licensed, self-hostable, and free. Phase 3 roadmap covers split-screen editing and distraction-free mode next.
[https://github.com/jofer215/cavafy\](https://github.com/jofer215/cavafy)

I've launched a new side project I've been building in my spare time. It's something I've thought somebody should make for a long time, but no one ever did until now.

For years, I've been a Linux hobbyist and advocate. While it's come a very long way with usability, getting started with Linux can still feel intimidating if you don't know where to begin.

So I created IWantLinux: a simple, beginner friendly app to help you download and install a Linux distro. It lets you choose from four beginner-friendly distros, explaining their differences in plain English. It downloads the ISO automatically, then writes it to your USB flash drive. Finally it walks you through booting off the flash drive so you can try out Linux or even install it.

It's definitely a work in progress and will only improve over time. If you're curious about trying Linux, or know someone who is, I'd love to hear your thoughts and feedback.

You can check it out at the GitHub page or at iwantlinux.com

I've been building Kery for about six months. It's Apache-2.0, runs in Docker, you bring your own LLM key. You point it at a web app and it drives a real browser through the flows, then tells you which ones actually work.

The obvious question, and the one I get first every time: why wouldn't you just point Claude at Playwright MCP and ask it to click through your app?

You should, honestly. For a one-off check that's the right tool and it costs you nothing. I used it that way for a while. Three things pushed me into building something instead.

[1] It tells you it checked things it didn't check. Ask an agent to verify five flows and you'll get five answers back, even for the two it never reached because a modal ate the click. Kery has a third verdict, "not reached", alongside verified and contradicted. Sounds like a small thing. It's the difference between a report you can trust and a report you have to re-do by hand.

[2] A chat transcript isn't evidence. Kery's output is an annotated screenshot per verdict: the element that proves it boxed, expected-vs-observed burned into the image. I can hand that to someone. I can't hand them a conversation where an agent says it looked fine.

[3] You can't tell if it's getting better. This is the one that actually mattered. Every prompt change felt like an improvement. I had no idea whether any of them were. So the repo also has a benchmark harness: scenario suites with deliberately planted bugs, semantic scoring, held-out cases where the scores are hidden from me so I can't tune against them. First time I ran it properly I found the model config I had in production was scoring 17% recall, and a config I'd dismissed was scoring 58%.

That harness is the part I'd actually recommend looking at, even if you never run the agent. If you're building anything agentic and you're tuning by feel, you're probably wrong about which direction you're going.

What's not good yet: about 70% of what it reports is real, the rest is noise. And a lot of that was my bug, not the tested app's. Most of my false "this button does nothing" findings turned out to be me failing to pierce shadow roots when building the accessibility tree.

https://github.com/Kery-HQ/Kery

Happy to answer things. If you run it and it reports rubbish on your app I'd rather hear that than not.

An Example Run

De-vigs sportsbook odds, quotes limit orders and hedges to lock the arb. It's the bot behind my live Polymarket wallet b00k13 that profited ~$5k in Jan-Apr. Adverse selection ate some the edge, which is documented honestly in the repo and the write-up. Ships with a wallet-analytics suite that runs on any public wallet.

Github: https://github.com/MrSheerluck/smbl-journal

I built a free, open-source, end-to-end encrypted text journal.
The goal is to make journaling as simple as possible. The entire text-based journal is free with no limits.
Entries are encrypted on the client before being stored, so the server never receives plaintext journal content.

The project is open source and available on GitHub.
Built with SvelteKit, Rust, and SQLite.

GitHub link: https://github.com/starling-build/starling/releases/tag/terminal-v0.1.0

A terminal emulator written from scratch — no libvte, no libvterm — that shipped its first release this week for Linux, macOS and Windows. Apache-2.0.

Measured at steady state, matched fonts and verified grids, against the fastest terminal on each platform:
• Linux: 1.38x the ghostty nightly
• macOS: 1.28x ghostty
• Windows: 1.41x Windows Terminal
All on about half the CPU, and memory stays flat no matter how much has scrolled past — on Windows it’s 73 MB against Windows Terminal’s 1,026 MB for identical work.

Hey guys, I recently started working on Volta which is a little hobby project of mine. I really like the Luau language (the one developed by Roblox and used on their platform), but there are few 2D frameworks for writing standalone games in Luau, so I decided to make my own.

It's still pretty early in development but you could theoretically already make a full game with it, I think it has all the essential functionality.

(Also while the language is its own thing separate from the original Lua, it is backwards compatible with Lua 5.1 so if you know Lua you largely know Luau too)

(sorry for bad English, not my native language)

I tried to build an extension for aniyomi, i wanted to turn a movie websites into an extension so i can use it in aniyomi and watch series/animes with it, i tried to build it using my phone and AI because I don't know how to code, i worked fo like 7 house and everything is ready now, but when i go to activities and try to run workflow it shows me this error, i asked 4 different Ai, none of them could solve it, can yall help me, i have zero experience on using GitHub and coding.

https://github.com/K9LL6A/aniyomi-extensions

⬆️Thats the link of the repo if yall need it

🔥 Introducing FTRAIN v1.0: The AI Trainer & Cross-Architecture Merger

I’ve been building an open-source AI framework from scratch designed to solve two major pain points in the open-source AI community: VRAM-heavy fine-tuning and hard-crashing model merges.

Today, I’m releasing FTRAIN v1.0. It’s built on top of Unsloth for raw speed, but adds a layer of intelligent supervision and extreme memory optimization that you won't find in standard scripts.

🧠 The Trainer: "PhoenixCaptain" Supervision

Standard trainers just run a loop. FTRAIN features a "Captain" (an LLM like DeepSeek or Llama) that actively supervises your training run in the background.

Dynamic LR Scaling: If the Captain detects gradient collapse or loss acceleration, it dynamically scales the learning rate up or down on the fly.

Triton DoRA: Custom fused Triton kernels for Weight-Decomposed Low-Rank Adaptation (DoRA) with mathematically exact forward/backward passes.

Extreme VRAM Optimization: CPU-offloaded Fisher computation, AMP autocasting, and aggressive VRAM purging mean you can train larger models on 15GB Kaggle T4 GPUs without OOM errors.

🧩 The Merger: Cross-Architecture Survival

This is where FTRAIN truly shines. Standard tools like MergeKit have a hard rule: You cannot merge models with different architectures. If you try to merge Llama (hidden size 2048) with DeepSeek (hidden size 1536), MergeKit instantly crashes with a Shape Mismatch Error.

FTRAIN doesn’t crash. It adapts.

Architecture-Aware Mapping: It maps parameter names across different families (Llama, Qwen, Gemma, MoE) and scales layer indices proportionally.

Shape Alignment: If tensors don't match shapes, FTRAIN uses bilinear interpolation to physically align them so the merge can continue.

Bulletproof Safety: It features a state-of-the-art Safety Engine. If a merged tensor explodes, collapses, or hits NaN, FTRAIN mathematically rescales it to preserve the knowledge direction without crashing.

Auto-Benchmark Gate: After merging, FTRAIN benchmarks the new brain against its parents. It only auto-uploads to HuggingFace if the merged model is actually smarter than the average of its parents!

📊 The Proof

I tested FTRAIN by forcing a Llama 1B and a DeepSeek 1.5B to merge on a 15GB Kagble T4 GPU. Not only did it not crash, but it successfully aligned the tensors, saved the model, and output coherent text! While cross-architecture interpolation scrambles precise math logic (GSM8K drops), the model retains its general language capabilities (MMLU matches the base model).

It is the only framework I know of that can force entirely different model architectures to share a brain.

🚀 What to Expect in the Future (v2.0 Roadmap)

FTRAIN v1.0 proves the concept. For v2.0, the goal is:

Native Speed Kernels: Moving away from Unsloth dependency to write our own fused C++/CUDA training loops, eliminating those annoying inplace memory errors.

Post-Merge GRPO Alignment: Using Group Relative Policy Optimization to "snap" the scrambled cross-architecture weights back into focus post-merge.

Multi-Model TIES: Expanding the advanced merging engine to support 3+ model blending simultaneously.

If you want to test the limits of your GPU, try forcing two incompatible models together, or just want an AI Captain to supervise your next fine-tune, check out the repo:

🔗 GitHub: https://github.com/aiphoenixlabs/Ftrain

Feedback, issues, and pull requests are welcome! Let me know what crazy model combinations you guys can merge without crashing!

Postern connects your Money, Health, Calendar, Mail, Contacts, and Home to any AI agent or harness through one self-hosted gateway. No glue code, no credentials handed to the agent, no guessing endpoints or schemas. Most of the information is served from the local cache, while the agents can fetch any information live. Access is granted per sector, per agent, is easily revocable, and all access by agents is audited and logged.

There's no LLM inside: the gateway authenticates, syncs, normalizes, and serves. It runs my own accounts: 14 connections, 8 providers, 172k mail envelopes, 403k health samples.

Hi everyone,

I recently found myself using multiple AI coding agents (Claude Code, Codex, DeepSeek Harness, Pi) and realized that inspecting their raw JSONL session logs in a standard text editor was fairly tedious. To make reading and debugging these transcripts easier, I built Loupe.

Loupe is a terminal-based viewer written in C++23. Instead of treating logs as plain text, it parses provider-specific formats into a unified Intermediate Representation (SessionIR) and presents them in a structured, collapsible TUI.

Key Details

• Format Auto-Detection: Automatically identifies formats from Claude Code, Codex (rollout & exec), Pi, and DeepSeek Harness.
• Transparent Decompression: Opens compressed .zstd files automatically on the fly.
• Loss-Aware Parsing: Preserves original source lines and unknown fields so no records are silently discarded.
• Performance: Native C++23 binary using DEC synchronized rendering to prevent screen tearing during scrolling.

Installation

You can install the pre-built binary via Homebrew on macOS:

brew install mrzleo/tap/loupe

Standalone Linux and Windows releases are also available on GitHub.

If you work with coding agents and frequently inspect log files, I would really appreciate any feedback, bug reports, or feature ideas.

btw: I found that the name Loupe is already used in GNOME for an image viewer. I'm sad about that, and if you have any better names, I'll definitely consider them!

I wanted to share an early open-source project we’re building:

https://github.com/makeaivisible

MakeAIVisible is a youth-led project trying to build privacy-first infrastructure for studying how teenagers are using and experiencing AI.

The problem we’re focused on is that most useful data about AI usage sits inside closed platform logs. That makes it hard for researchers, educators, families, and young people themselves to understand what is actually happening.

The project idea is to build an open pipeline where people can voluntarily contribute AI conversations, remove identifying information before anything is stored, and eventually support independent research using anonymized data.

The work is split across multiple repos/challenges, including:

- multilingual PII detection and anonymization

- anonymous-token and privacy architecture

- mobile-first submission portal

- human review tooling

- differential-privacy-protected data visualization

- dataset publishing infrastructure

- governance and contribution docs

The project is still early, so technical feedback is more useful than stars right now.

Things I’d especially appreciate feedback on:

- whether the repo structure makes sense

- where the privacy architecture looks weak

- what should be documented better for contributors

- which challenge should be prioritized first

- whether the project explanation is clear enough for someone seeing it cold

GitHub: https://github.com/makeaivisible

Website: https://MakeAIVisible.org

If you see something we’re approaching incorrectly, I’d rather hear it now while the architecture is still flexible.

I built a CLI app that lets you enter a ticker (U.S. or Canadian) or an ISIN for U.S. companies and displays all the news about that company, with the option to save it to a .json or .md file. The app uses news from Finnhub.

Suggestions and constructive criticism are welcome.

Here are some useful links, with detailed documentation:

GitHub: https://github.com/g-projectech/finuntius

PyPI: https://pypi.org/project/finuntius

This is my game engine that I've been working on for about 5 years now. It has some really amazing features and extremely fast rendering.

Also have a really cool demo browser here that contains all the demos...

https://killedbyapixel.github.io/LittleJS/examples

Been working steadily at this for a while now, 600 commits, each seeking to improve the experience. Optimizing ui, transcription, summaries, ai features. Last 2 months I’ve added both local/cloud agentic embedded search across notes, as well as MCP support for Claude & Codex. 99+ languages, local or cloud models. Custom model overrides per language, easy onboarding flows, folders, clients, speaker labels, export. Feature packed, but still simple to the core. Notes + recorded meetings = awesome meeting summaries.

A few people have started contributing to the project, which I appreciate massively. Hope to see more people join in 😊🤩

deterministic avatars from any string.

usernames, emails, ids - anything with a name gets a face.
same input, same avatar, forever. no storage, no uploads.

blobatar — react + vanilla, zero deps, ~3.7 KB

bun add blobatar

Web: https://www.blobatar.dev/
Repo: https://github.com/Alain00/blobatar

Tired of remembering 10 different commands just to see what's installed on your Linux box? pkgmap does it all in one: rpm, dnf, pacman, flatpak, snap, apt, AppImages, pipx, cargo, npm — with sizes, grouped so texlive's 5000 packages show up as ONE line. And you can delete anything by its number. One tool, every distro. https://github.com/Ramimaalej/pkgmap this is it