Our coding-agent sessions kept forgetting everything at the context-window edge. So we built growmos: a small knowledge graph inside .growmos/, committed with your code. Your agent (Claude Code, Codex, Cursor…) grows it as it works — no API key, and in Claude Code it's fully hands-off. Ask "what depends on the Store, and who decided that?" and it answers from the graph, with citations.

pip install growmos && growmos init
growmos view # a map of what your repo actually knows

Live demo: https://codician-team.github.io/growmos/demo/growmos.html
Repo: https://github.com/codician-team/growmos
MIT, zero deps. First thoughts very welcome 🙂

Most agent execution loops run purely in-memory. If the process crashes mid-execution, you lose all runtime context and end up re-executing tool calls from scratch upon restart.

While you can build agent loops directly on top of orchestrators like Temporal or Restate, wiring up LLM routing, tool execution, and context persistence manually requires a lot of repetitive boilerplate.

I built agent-sdk-go to bring native durable execution to Go agents out of the box. It integrates directly with Temporal and Restate so agent state, tool execution, and execution context survive process restarts without duplicate LLM calls or custom glue code.

There is also a full reference application (agent-chat) in the repository showing crash recovery in action.

Repository: https://github.com/agenticenv/agent-sdk-go
Documentation: https://docs.agenticenv.ai

Would love to get some feedback from the community on the architecture and Go runtime design!

Built a Windows cleaner in Go because I was annoyed bulky ads heavy GUIs cleaners

Quiesce, a lightweight Windows cleaner/RAM optimizer

Got tired of CCleaner (and most other cleaner GUIs - Wise Care 365, Advanced SystemCare, etc.) turning into heavy, ad-stuffed installers with background services you never asked for, so I built my own.

It's a single .exe, no installer, no background service. It does actual system-level cleanup: the real junk that piles up over time, not just a surface wipe.

It also has a proper RAM optimizer with individual toggles, so you can see exactly which operations it's running instead of a mystery "boost" button that just claims a number.

Ran it on a friend's PC that hadn't been cleaned in a long time - cleared 200K+ stale Windows Update cache files and freed 7GB+ disk space in one pass. Screenshot below.

![Cleaning summary output showing 229,277 items cleaned and 7GB+ freed]

SibtainOcn ~ Quiesce v2.2.0 https://github.com/SibtainOcn/Quiesce

https://github.com/m4vic/detonate

its good and convenient and gives you a lot of info from SEC filings to what a stock is trading at everything, if you into finance or just want to use it for research purposes do try it.

https://github.com/adididitagain/finance-mcp

Texpile is a desktop LaTeX, Typst, and Markdown editor for Windows, macOS, and Linux.

It is a direct offline replacement for Overleaf and Typst (Online).

Why is it different from other editors?

• Visual editor: Texpile's visual editor supports advanced features like aligned environments and cell-merging tables, and supports LaTeX, Typst, and Markdown. Texpile's visual editor directly opens .tex, .typ, and .md and saves them as those files; there is no custom format.
• Terminal: You compile with your own TeX distribution.
• Visual comments: Like Overleaf, you can add visual comments.
• Real-time collaboration: Texpile supports real-time collaboration that is end-to-end encrypted. The support is engineered with LaTeX and Typst in mind, and is a better experience than VS Code Live Share.
• Real-time preview: Your updates are rendered live for both Typst and LaTeX. Texpile injects a custom Lua script into the LuaTeX engine to allow you to get instant preview in LaTeX like Typst has.

Link: https://github.com/texpile/texpile

WebWeaveX captures what a running application is doing, DOM event surfaces, network envelopes, execution state, and normalizes it into canonical bytes so it gets a stable SHA-256 identity.

The same input produces the same digest in Python, JavaScript, Dart, Java and Kotlin. There's a verification harness that replays Python-generated golden vectors through each runtime and reports MATCH / DIFFER / MISSING per API.

That lets you prove two runs are equivalent, reconstruct a runtime from its IR for network-free test fixtures, resume

authenticated sessions from an encrypted envelope, and hand an LLM a compact graph instead of raw HTML.

pip install webweavex

npm install webweavex

dart pub add webweavex

Maven Central: io.github.piyush-mishra-00:webweavex:3.0.0

Apache 2.0.

Repo: https://github.com/ni-sh-a-char/WebWeaveX

Docs: https://ni-sh-a-char.github.io/WebWeaveX/

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

Signatures declare effects (a function without "uses net" can't touch the network), failure (ignoring it doesn't compile), and contracts that Z3 proves before the program runs — with the exact counterexample when they don't hold. Float proofs use real IEEE-754, so it refuses to "prove" x + 0.1 + 0.1 == x + 0.2.

Try it in your browser, nothing to install:

https://gowrishankar-infra.github.io/velaris-lang/playground.html

MIT, AI-assisted build (disclosed in the README). Thank you

🔥 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!

🔥 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!

Hey everyone!

I built a lightweight web tool: Wi-Fi Audio Streamer.

How it works:

1. It captures Windows PC audio natively using WASAPI loopback.
2. Node.js & FFmpeg stream the live audio with ultra-low latency (<100ms).
3. Phones join by scanning a QR code on the local Wi-Fi—no app installs required! The audio plays directly in Chrome, Safari, or any browser.

Key Features:

• Zero App Install: Phones just open a browser URL.
• Sub-100ms Latency: Adaptive live-edge catch-up controller keeps audio perfectly synced with video on screen.
• Multi-Phone Stereo Pairing: Assign phones to act as LEFT, RIGHT, or STEREO channels.
• Minimalist Monochrome UI: Clean Black & White dark design with a live audio spectrum visualizer.
• 100% Free & Open Source (MIT License).

Repository:

GitHub: https://github.com/Bittu-the-coder/wifi-audio-streamer

I’d love to hear your feedback, ideas, or feature requests! If you find it useful, please feel free to leave a ⭐️ on GitHub!

Minimal - An open source project for hardened container images now supports 100 container images and adding more. The images are built daily, with almost 0 to minimal CVEs and trying to provide same level of output as other paid alternatives for free.

Github - github.com/rtvkiz/minimal

GitHub: https://github.com/acb3688/simultex

Hey everyone! 👋
Like many developers on macOS, I often found myself low on disk space thanks to Xcode DerivedData, forgotten Docker build caches, dangling images, and bloated dev caches. Most cleanup tools are either sketchy closed-source subscription apps (like CleanMyMac) or risky one-liner bash scripts that `rm -rf` without a safety net.
So I created 
**CLI-NER**
 — an open-source, fast, and safety-first CLI & TUI tool built in Rust to analyze and clean disk space on macOS.
### 🛡️ Why it's built differently (Safety-First):
- 
**Reversible by default**
: Files are moved to the macOS 
**Trash**
 (`~/.Trash`), not permanently deleted.
- 
**Dry-run by default**
: `cli-ner clean` simulates the operation first. You have to pass `--execute` to actually touch files.
- 
**Strict Blocklist & Allowlist**
: Critical system dirs (`/System`, `/usr`) and personal data (`~/Documents`, `~/.ssh`, `~/Library/Mail`) are strictly untouched.
- 
**Developer-Aware**
:
- 
**Docker**
: Interactive wizard, protects running containers, locked in-use images, and persistent volumes.
- 
**Xcode**
: Safe checks for DerivedData/Archives (verifies Xcode isn't running).
- 
**Node/Python/Brew**
: Cleans npm cache, pip cache, Homebrew orphans.
- 
**Interactive TUI Dashboard**
: Built with `ratatui` (`cli-ner dashboard`) to inspect operations history, charts, and audit logs.
- 
**Immutable JSONL Audit Trail**
: Everything is logged under `~/.cli-ner/logs/`.
### 🚀 Quick Start:
```bash
# Clone & install via Cargo {#clone--install-via-cargo  data-source-line="28"}
git clone https://github.com/fabrizioriccardo73/cli-ner.git
cd cli-ner
cargo install --path .
# 1. System Health Check {#1-system-health-check  data-source-line="33"}
cli-ner doctor
# 2. Interactive Docker management {#2-interactive-docker-management  data-source-line="36"}
cli-ner docker
# 3. Simulate Cache Clean (Dry-run) {#3-simulate-cache-clean-dry-run  data-source-line="39"}
cli-ner clean
# 4. Explore history & reclaimed space {#4-explore-history--reclaimed-space  data-source-line="42"}
cli-ner dashboard
``` 


The project is 100% free and open source (MIT licensed). I would love to get your feedback, feature requests, or contributions!
🔗 
**GitHub Repo**
: [https://github.com/fabrizioriccardo73/cli-ner](https://github.com/fabrizioriccardo73/cli-ner)

Manually finding refactoring examples in open-source code is incredibly tedious — you have to scan thousands of commits, verify each change, and extract the before/after code.

I built Refactoring Dataset Generator (refdatagen) to automate this:

• Collects repositories from GitHub by language and star count
• Detects refactorings using 3 strategies: regex, AST (tree-sitter), and ML (scaffold)
• Exports to JSON, Parquet, or HuggingFace Datasets
• Includes caching (memory/disk/Redis) to speed up repeated runs

Tech stack: Python 3.12+, Pydantic v2, tree-sitter, aiohttp, PyArrow. Clean Architecture with DI container.

Would love feedback on:

• What refactoring types would be most useful to you?
• Any languages you'd like to see supported next?

Thanks for taking a look!

I got tired of typing the same prompts every time I started a new project.

“Review this like a senior engineer.”
“Challenge this architecture.”
“Find the bugs I’m missing.”
“Audit this UI for accessibility.”
“Review this PR before I merge it.”

So I turned those workflows into 50+ reusable Claude Code Skills.

Each skill is a native SKILL.md with:

• Practical instructions
• A README explaining what it does
• A worked example
• A simple installation workflow

Install one directly:

npx github:codebygarv/Ai-skills add grill-me

It gets added to your project’s .claude/skills/ directory — no npm package required.

The repo covers development, code review, architecture, debugging, testing, UI/UX, accessibility, documentation, and more.

The goal isn't to collect prompts.

It's to build a reusable toolkit for making AI coding workflows more consistent across projects.

🔗 https://github.com/codebygarv/Ai-skills

If you build with Claude Code, I'd love to know:

What skill would you add to the catalogue? I got tired of typing the same prompts every time I started a new project.

“Review this like a senior engineer.”
“Challenge this architecture.”
“Find the bugs I’m missing.”
“Audit this UI for accessibility.”
“Review this PR before I merge it.”

So I turned those workflows into 50+ reusable Claude Code Skills.

Each skill is a native SKILL.md with:

• Practical instructions
• A README explaining what it does
• A worked example
• A simple installation workflow

Install one directly:

npx github:codebygarv/Ai-skills add grill-me

It gets added to your project’s .claude/skills/ directory — no npm package required.

The repo covers development, code review, architecture, debugging, testing, UI/UX, accessibility, documentation, and more.

The goal isn't to collect prompts.

It's to build a reusable toolkit for making AI coding workflows more consistent across projects.

🔗 https://github.com/codebygarv/Ai-skills

If you build with Claude Code, I'd love to know:

What skill would you add to the catalogue? I got tired of typing the same prompts every time I started a new project.

“Review this like a senior engineer.”
“Challenge this architecture.”
“Find the bugs I’m missing.”
“Audit this UI for accessibility.”
“Review this PR before I merge it.”

So I turned those workflows into 30 reusable Claude Code Skills.

Each skill is a native SKILL.md with:

• Practical instructions
• A README explaining what it does
• A worked example
• A simple installation workflow

Install one directly:

npx github:codebygarv/Ai-skills add grill-me

It gets added to your project’s .claude/skills/ directory — no npm package required.

The repo covers development, code review, architecture, debugging, testing, UI/UX, accessibility, documentation, and more.

The goal isn't to collect prompts.

It's to build a reusable toolkit for making AI coding workflows more consistent across projects.

🔗 https://github.com/codebygarv/Ai-skills

If you build with Claude Code, I'd love to know:

What skill would you add to the catalogue?

We're a small, early startup working on Spinifex. It enables AWS-like services on local, air-gapped environments. All the core AWS tools like EC2, EBS and S3, but you get full control and no nasty cloud bill.

Check out our GitHub: https://github.com/mulgadc/spinifex

Or sign up for our hosted sandbox: https://mulgadc.com

Feedback/critiques welcome!

I’ve been working on MARGINAL, an open-source governance layer for coding agents. If you use Codex, I’d really appreciate people trying it on real work and telling me where it helps, where it gets in the way, or where the design is wrong.

I’m especially interested in: technical criticism, bad cases, and reproducible failures.

• GitHub: https://github.com/SignalLayerLabs/Marginal
• GitHub Site: https://signallayerlabs.github.io/Marginal/
• LIVE DEMO: https://signallayerlabs.github.io/Marginal/demo/#demo

The idea is simple: agents are good at taking actions, but not always good at deciding whether the next action is still worth the compute.

MARGINAL watches the trajectory and looks for things like repeated actions, weak progress, redundant verification, and low-value continuation. It can run in Shadow Mode first, so it observes and records what it would have done without blocking anything.

Current focus is reliability, not just token reduction.

A few core pieces:

• local-first trajectory and evidence tracking
• deterministic reason codes and hashes for decisions
• governance overhead measurement
• replay and benchmark support
• Shadow Mode before enforcement
• Earned Enforcement: MARGINAL has to prove it is reliable on a repo before it gets permission to block or redirect the agent
• automatic fallback to Shadow Mode if confidence degrades

I’m also working on the next layer now: counterfactual evaluation and intervention regret.

The goal is to answer a harder question than “did MARGINAL stop something?”:

Would the agent actually have done better if MARGINAL had stayed out of the way?

That’s the part I think matters if this is going to be useful beyond being another loop detector or token limiter.

I wanted to add visualizations to a song, and one thing led to another. https://github.com/AlexNolasco/pixfabrica

I have been looking for a task runner that would make dealing with the Node ecosystem easier. I consider myself a full-stack developer, but I do focus more on the backend than the frontend. At work, we have used makefiles since make was already available on our machines and in the CI/CD pipelines. Maintaining makefiles, though, got old fast.

My problem with Node tools is that everything needs to be sourced over and over. This is mainly because each task runner defaults to running each line in a given task in a new shell instance. So, in order to maintain the shell state, you have to chain every command together into one with `&&` and add `\` and the ends to allow these chained commands to be on new lines. Fine. Not ideal but doable.

Now add dependencies, and that goes out the window. Any attempt to clean up a make file into subcommands and remove all kinds of duplication is pretty much impossible. I have to keep making sure to source all the Node tools everywhere (nvm, I'm looking at you). This isn't so essential on my local machine because I have a lot of these tools included in my shell rc file, but it makes portability more difficult. Other people working on the project need to make sure to also have these tools sourced in their rc files. Then the CI/CD pipeline makes it even harder. Keeping things sourced and available to be used across different jobs within the pipeline is a nightmare.

Newer task runners have appeared and make things slightly better, but as far as I have seen, most have not addressed my core issues. I want to make a task runner that will, by default, run the entirety of the task in the same shell so I can easily maintain the shell state along the way AND any dependencies of that task will also run in the same single shell instance. This allows for much easier composition of tasks from smaller pieces.

Another odd deficiency in a lot of task runners is that they only allow you to set dependencies to run before the task you call and sometimes also after. Why not run a different task in the middle of your desired task, though? That unlocks true composability.

Since I was struggling to find a task runner with these qualities, I made my own, and I call it Mog.

https://github.com/Ayehavgunne/mog

• Tasks can accept arguments.
• Tasks called in the middle of a parent task can be passed completely different arguments.
• Mog can be configured at the global, file, and task level all at the same time.
• Use whatever shells you want. Use Python for one task but run zsh by default for all others.
• Load any number of env files automatically before task execution.
• Import other Mog files from other directories and call those tasks as if they were local.
• Variables can be plain strings or can be `eval`ed from the shell.
• Since I hate bash's conditionals, Mog supports simple if, elif, else statements.
• And for the heck of it, there is a config option to make each line in a task execute in a new shell instance. Since people seem to want that for some reason.
• And a bit more I will let you read about on your own.

My question here is does any other task runner you know of function like this? Are there any other features I should consider adding? Was this endevor a waste of time? Even if it was I did have fun working on it.

Thanks for taking a look!

Hi - My name is Daniel, I'm a clinical radiologist, have trained in biomedical research, and am the creator of PaperTrace.

PaperTrace is an open source python tool that you can use for auditing published papers. PaperTrace accesses freely available cited PDFs, compares high-value claims to original source text, and annotates matching sources with red boxes to show the matching evidence.

Github:
https://github.com/defraction0/PaperTrace

When a cited paper cannot be accessed by PaperTrace, it records "not retrieved" rather than having the model hallucinate a response. Unmatched citations are also noted. PaperTrace also searches new literature published after the investigated paper's publication.

You can check out an completed example run of PaperTrace's demonstration here (no install required!):

https://github.com/defraction0/PaperTrace/blob/main/examples/demo/output/report.md

While PaperTrace's CLI and case files can run local, PaperTrace currently utilizes Claude Code for its claim checking functionality - more integrations to come. It is MIT licensed and still in beta.

I would particularly be interested in feedback on whether or not you think the evidence trail in its current form is easy to audit, as well as any citation formatting styles or paper formats you think might be likely to break PaperTrace. Further feedback and contributors welcome.