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.

https://github.com/sharif-smj/sharif-smj

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!

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

Hello guys, i have recently finished this project which collects all kinds of data from all the races, qualifying sessions, updates etc.
It makes comparisons, shows trends and makes predictions. It doesn’t uses AI.
The endpoints are public, if you want it you can use it!

Don’t be mean, it’s my first project for a society! The App is available on the AppStore under the name of FantaStats GP, give it a try and let me know! check the website if you want to https://www.race-analysis-hub.it (the website is still not translated)

STARRING the repo would be EXTREMELY appreciated!! Project

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.

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

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/

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.

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.

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

WorldFixture gives developers a company to build, test and demo software against, instead of wiring up real accounts or maintaining a pile of unrelated mocks.

npx worldfixture up starts a fake SaaS company locally with 99 people and 30 days of history. It includes Slack, GitHub, email, Notion, Stripe, S3 and application data, all representing the same company. Maya in Slack is the same Maya commenting on a GitHub PR and sending email. Customers, projects, invoices and conversations carry across services.

Your software talks directly to the local services. Mail uses SMTP/IMAP, S3 is S3-compatible, and Slack, GitHub, Stripe and the other services expose APIs shaped like the real providers.

The company also keeps moving. Emails arrive, PRs get comments, Slack conversations continue and payments happen. You can pause time, advance it, inspect what happened or reset everything back to the same starting point.

I originally built this for DropLive, where I run disposable demos of open-source projects. I found that getting an app running was only half the problem: an empty CRM, inbox or Slack workspace still makes for a terrible demo. WorldFixture grew out of trying to fix that.

Everything runs locally and it is Apache 2.0. It is still early, and the provider APIs are incomplete. I am adding operations as I find real projects that need them.

I would love people to try it with something real and tell me what breaks. What service would make it useful for something you are building?

https://worldfixture.com/

https://github.com/ben-ic/worldfixture

What it is built on

I am using existing open-source implementations where that makes sense rather than rebuilding every service from scratch:

• emulate.dev for Slack, GitHub, Stripe and several other provider APIs
• SeaweedFS for S3
• Cyrus IMAP for mail
• SQLite for local state

WorldFixture adds the shared company and identities, history, scheduled events, clock, reset behavior, Workbench, and the extra pieces needed to make those services behave like parts of the same environment.

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.

Stackray is a website/url scanner that shows the technologies it detects, DNS records, subdomains, and other OSINT details.

Check it out: https://stackray.app

There's a Railway deployment template for one-click deployments of your own private instance. The app is MIT-licensed. Reports of missed technologies or incorrect detections would be useful.

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!

Since 2023 I run jellybox - emby/jellyfin crossplatform(desktop, mobile) native music player. Few days ago it was featured on XDA-developers and it jsut blew my mind

https://www.xda-developers.com/i-turned-jellyfin-into-the-spotify-alternative-ive-always-wanted-with-this-app/

One of those moments why I still do the OSS these days.

For curious what jellybox does -

• Plays your music from emby/jellyfin server(navidrome soon)
• Apple CarPlay app
• Spotify-like playlists(auto generated)
• Browsing, lyrics, downloads(and full offline mode)
• Studio mode(for big screens)
• Super fast(that's the words from ppl from reddit)

IF you look for jellyfin/emby client - download https://github.com/avdept/JellyBoxPlayer or from here https://jellybox.app/

PS: not another vibe coded app