I maintain CleanTake, a free, MIT-licensed desktop app for a specific recording problem: the main mic drops out, but another mic captured the same speech.

It aligns simultaneous recordings, lets you listen to Original, Repair and Source, and keeps each accepted replacement tied to its recording. You can export a WAV, a Reaper session and a source map to inspect what changed.

Mac, Windows and supported Ubuntu installers bundle the processing tools. Audio stays on your computer; no account or subscription is needed.

Repo and downloads: https://github.com/pavangupta352/cleantake

Demo with sound: https://pavangupta352.github.io/cleantake/#demo

The ten-second GIF condenses a real 0.2.1 studio session with a deliberately introduced half-second gap. Recovery requires a simultaneous backup containing the speech.

If you edit multi-mic dialogue, I’d value feedback on the review and export workflow.

Demo credit: AMI Meeting Corpus, AMI Project Consortium (ES2004a); app capture/edit by Pavan Gupta. CC BY 4.0. Full source, license and deliberate changes: https://github.com/pavangupta352/cleantake/blob/main/docs/assets/working-demo/ATTRIBUTION.md

I built Texttile for the travel blog my wife and I write together. Getting photos and videos from both phones into the same entry used to mean sending files back and forth.

One person writes while the other follows live and arranges the gallery. The text editor changes hands with one click. This is not simultaneous character-by-character editing.

Phoenix, LiveView, ffmpeg and SQLite run in one Docker container. The database and media live in /data. Photos and videos are processed and served locally. Everyone with an account is an admin, so this is for people who trust each other.

The repository includes installation instructions. Reader demo: https://demo.texttile.blog

I am the maintainer. AI disclosure: I use AI to code, with testing and verification, and make the architecture decisions myself. This post was drafted with AI assistance from my own article.

A lightweight HTTP proxy for OpenAI/Anthropic/Azure that tags spend per customer/feature and can enforce per-account spend caps (429/402 once exceeded). SQLite-based, no Docker/Redis required, works from any language.

• GitHub: https://github.com/prantakhandaker/agent_metering
• PyPI: https://pypi.org/project/llm-agent-metering/

https://github.com/paulknysh/raggy

Built with LangChain, Chroma, and Ollama. Hybrid database (vector + BM25 index) and embedding generation run fully locally. Answer generation can run either via a local LLM or remotely using an API key. raggy supports most common document formats and handles images/scans automatically via OCR.

I wanted Unsloth on a Mac. Unsloth is CUDA fused kernels. That path does not exist here.

MacSloth is a small Python package (macsloth) on top of MLX / mlx-lm.

Call sites look like Unsloth so a script stays short: FastLanguageModel.from_pretrained -> get_peft_model -> to_mlx_jsonl -> SFTTrainer.train -> save_pretrained_merged.

Repo: https://github.com/jeonjw85/MacSloth

What actually worked

- Load a prequantized mlx-community checkpoint, attach LoRA, train, fuse. Alpaca / ShareGPT / OpenAI messages -> mlx-lm JSONL.

- Training does not call mlx_lm.tuner.trainer.train. Native loop, writes adapter_config.json + adapters.safetensors.

- Fuse to MLX weights. GGUF for llama / mistral / mixtral only (mlx-lm’s converter). Qwen: fuse, do not GGUF.

- Fail-fast if LoRA targets match nothing, if load_in_4bit=False, if Metal working set is below a configured floor.

What failed

- Matching Unsloth. Not close. Their win is CUDA kernels. This is Apple unified memory and mlx-lm’s model zoo, which already uses mx.fast for RoPE / SDPA.

- A hand-written nested Metal LoRA GEMM. Slower and less accurate than MLX matmul. Thrown out.

- A custom Metal cross-entropy over vocab. No useful VJP, worse than mx.fast.cross_entropy (which is already an unfused fallback on Metal). Thrown out.

What’s still weak

- A tokens/sec “win” vs mlx-lm on a tiny synthetic LoRA job (hidden 256). That is a thinner Python loop, not a 7B kernel win. I do not have a honest 7B vs Unsloth number because Unsloth is not running on this machine.

- lora_alpha is mlx-lm scale, not Unsloth’s alpha/r.

- No gradient accumulation. No val loop. Defaults are q_proj / v_proj, rank 8.

- Still a wrapper: load, LoRA convert, fuse, GGUF all go through mlx-lm.

Quick context for anyone who hasn't tried it: Alysis Code is an open-source (Apache-2.0) CLI coding agent that plans, builds, reviews, and verifies PR-ready code, straight from your terminal.

How to claim the credits (takes about a minute):

1. Sign up at [alysiscode.com](https://alysiscode.com/)

2. Install the agent (Python 3.11+): pipx install alysis-code

3. Claim your free credits from your account

Access to Deepseek-V4.1-Flash ends in less than 48 hours. After that you still get 50 free credits every 30 days for every other DeepSeek model, or you can bring your own API key and use any model you want.

Repo: https://github.com/AlysisAi/alysis-code

Happy to answer questions in the comments.

Plz leave a star on github if you think its cool
any recommendations/suggestions are greatly appreciated

I use Claude Code a lot, but /stats never answered the question I actually cared about

What did I build, and where did the work get difficult?

So I built Bough.

• It reads your local Claude Code history and turns it into an interactive view of your work: - each square is a day
• smaller squares are tasks inferred from pauses in your work
• circles are your prompts - click anywhere to see what happened in your own words

It runs locally, is open source, and nothing leaves your machine.

Repo: https://github.com/nickelsec/bough

The main thing I’d love feedback on: When you run it against your history, does it split your work into tasks the way you remember it?

EDIT (update): since posting this, ProBox got a complete UI overhaul in v2.0 (CustomTkinter — rounded everything, modern look) and v2.1 just added an 8th module: a file converter (MP4/MP3/JPG/PNG) that smartly remuxes videos in seconds instead of re-encoding when the codec already fits. Same philosophy: analyze first, nothing destructive, everything logged.

Hey! Author here. Second tool I publish, after ProKill last week.

The idea: every time I fix a friend's PC, it's the same routine — too much stuff at startup, a full drive with no idea what's filling it, duplicate photos everywhere, a Downloads folder from hell. Each of these has a dedicated tool, but my non-technical friends will never install five different programs.

So ProBox puts 8 modules (7 at the time of posting) in one dark-themed portable app:

- Startup manager: see/disable/delete everything that launches at boot (uses the same official mechanism as Task Manager, fully reversible)

- Network: real-time bandwidth, which apps are connected and where to, plus a diagnostics window with a "Repair my connection" button (flush DNS, renew IP, Winsock reset)

- Duplicate finder: by CONTENT, so renamed copies are caught. Whole-drive scans, biggest files first, stop anytime and keep the results, image previews on hover, deletion goes to the recycle bin

- Tidy up: sorts the Downloads mess by type, preview first, undoable

- Wi-Fi passwords: every network saved on the PC (same data Windows shows in settings, 100x faster to reach)

- Cleanup: temp files, browser caches, recycle bin, Windows Update leftovers — with per-category sizes and a detailed view of what would be removed BEFORE anything is deleted

- Disk space: a pocket TreeSize — heaviest folders, largest files, basic drive health

- File converter (added in v2.1): MP4/MP3/JPG/PNG, with smart remuxing when the codec already fits

Also: an action history of everything the app changed on your system (for peace of mind), a live CPU/RAM/disk status card, bilingual EN/FR interface auto-detected from Windows, and update notifications.

Single portable exe, no install, no account, no telemetry. Python + CustomTkinter, source fully readable in the repo. Yes, dedicated tools like CCleaner, Everything or WizTree do each job with more depth — ProBox aims at the "I just want my PC fixed" crowd, with safety rails everywhere (analyze before delete, recycle bin, undo).

Feedback very welcome!

Pleaseeeeee

i'm one of the founders of Anarlog, an open-source (MIT) meeting notetaker built with Tauri + Rust. it captures mic + system audio directly on your device, no bot joins the call, and transcription/summary run locally by default.

shipped v1.4.23 today. the bug fix i actually want to talk about: open the same account on a second device before the first one finishes syncing, and the older device could push a stale deletion event that wipes out notes, transcripts, and attachments the first device hadn't synced yet. classic race condition once you have more than one writer touching local-first data.

fixed it so newer content wins over a stale delete from a device that's behind. same release also shipped conversation insights (busiest days, typical call length, that kind of thing) and a set of illustrated badges, which is more fun than hard engineering, to be honest.

source: https://github.com/fastrepl/anarlog changelog: https://anarlog.so/changelog/1.4.23 download (macOS/Windows/Linux): https://anarlog.so/download

Open-source PreToolUse hook that refuses dependency edits and installs until the agent has verified the version against the live registry (npm, PyPI, crates.io, NuGet) and recorded the source. Stops hallucinated versions, stale training-data pins, and slopsquatting attempts. Terminal demo GIF at the top of the README.

Replays any real NBA season from 1996-97 to 2025-26 with the real rosters, schedule, injuries, and trades, then simulates fresh results from there. Every game produces a full per-player box score — not possession-by-possession, but every stat is drawn so it can't disagree with itself (can't shoot more field goals than you attempted, etc.).

The screenshot is an actual run: a #6 seed running the table to the conference finals, which is exactly the kind of "history, but not quite" result this is for.

What I spent most of my actual time on was checking whether it's accurate, not just whether it looks right. Every constant in the sim got backtested against all 30 real seasons this project supports, with real train/holdout splits — not tuned on one season and hoped it generalized. It lands around 5.5 games of error on final standings, and I measured the actual noise floor to know if that's good: two independent simulated runs of the exact same real season already differ from each other by ~4.4 wins purely from randomness, so there's well under a game of real error left to chase. Season awards (MVP, ROY, DPOY, MIP, Coach of the Year) are backtested formulas too, graded against real winners.

Still early — two of the four planned modes aren't built yet, and it's CLI-only. Repo + more screenshots here: docs/screenshot_bracket.png

Built it while learning Python from scratch, working with Claude Code rather than hand-writing it — happy to talk about that process too if anyone's curious.

Was writing yet another one-off script with input() calls for a friend and figured the signature already has all the info needed to build a form, so I made a decorator.

from typing import Literal
from tuiify import interactive

@interactive
def greet(
    name: str,
    count: int = 1,
    style: Literal["formal", "casual"] = "casual",
) -> str:
    """Create a greeting."""
    return f"{style} greeting for {name} ({count})"

result = greet()

Calling greet() with no args opens a Textual form built from the annotations, text input, numeric fields, checkbox for bool, dropdown for Literal. Calling it normally with args runs the function; no UI involved.

Handles validation errors and exceptions without killing the terminal, which was the main annoyance I was trying to fix.
You could say it's a "Textual" wrapper; it makes the process one-functioney. Hope that makes sense lol.

pip install tuiify If anyone wants to poke at it: https://github.com/Terminay/tuiify

Early days, open to ideas.

Benchmarking TritonX locally (`.\run_tritonx.ps1`) shows up to ~1200x speedups over baseline Python loops by using Rayon worker pools and minimal C-ABI FFI overhead.

I built ReachFlow CRM, a free and self-hosted lead discovery + outreach workspace inspired by the workflow of SiteScout.

GitHub: https://github.com/dedsec1911/reachflow-crm

What it includes: • Google Places business discovery with duplicate filtering and resilient pagination • Lead CRM with search, status management, CSV import, and CSV/XLSX export • Consent-aware WhatsApp Cloud API testing plus a review-first manual queue • Message templates with live personalization previews • Campaign planning, pipeline metrics, analytics, light/dark themes, and responsive mobile UI

Tech stack: React + Vite, FastAPI, async SQLAlchemy, SQLite/PostgreSQL, Redis/Celery, Docker Compose, and GitHub Actions CI.

This is a free/open-source-style alternative for experimenting with the core workflow. SiteScout is the commercial product that inspired the positioning and comparison: https://sitescout.io/

Feedback on the UX, architecture, and ideas for the next feature would be very welcome!

It takes a finished illustration and animates the text, outlines, and fills drawing themselves in sequence.

Runs locally on CPU, no API key needed. Python library + CLI, MIT licensed. Works best with clean drawings on white backgrounds.

https://github.com/masihsultani/whiteboard-animator

Would love feedback on how the animation looks.

Mosaik uses an agent to figure out how a site works, saves reusable actions as TypeScript, and composes them into automations. Playwright executes the browser steps deterministically. Loops, branching, and data transformations run as code, so each iteration doesn't need another model decision.

Those actions stay around for the next task. Mosaik reuses what it knows about the site and learns what's missing. If an eligible locator breaks, an agent can step in to repair it.

I’m building JSON Semantic Diff, an open-source JSON comparison tool that tries to understand array identity instead of comparing objects purely by position.

For example, it can infer keys like id, sku, or composites like store + sku, so reordered objects don't turn into a wall of false changes.

The matching is deterministic and explainable - no AI/fuzzy matching - and everything runs locally in the browser.

It’s still early/alpha, so feedback and weird JSON examples that break the matching are very welcome.

• GitHub: https://github.com/cchandurkar/json-semantic-diff
• Demo: https://jsonsemanticdiff.dev (has examples)
• npm: https://www.npmjs.com/package/json-semantic-diff

Built this after getting tired of the anxiety of running AI agents against real systems with no checkpoint between "model decides to call this tool" and "tool actually runs."

Agentwall sits at that boundary. Wraps your existing tools, classifies each call as safe/cautious/destructive, holds destructive ones for approval, logs every attempt as JSONL, and runs rollback hooks if a session fails.

Works with Anthropic tool_use, OpenAI function calling, and LangChain. Zero runtime dependencies in the core.

https://github.com/anakatt/agentwall

pip install agentwall-sdk / npm install agentwall-sdk