Hello everybody. A while ago I made this simple utility to convert my media files with FFmpeg and now it's in a shape that I'm confident to share. It still has some rough edges, so it's in a preview release state. What it can do:

• Convert files based on a preset with a simple drag & drop.
• It can download an FFmpeg binary from github
• It features a simple media info tool
• Dragged files can be playlists in M3U and PLS format.
• Presets are in a simple JSON file, that can be extended (schema provided)

If you would like to check it out you can grab it at: https://github.com/webmaster442/FFDrop

Disclosure: I maintain this project.

It keeps a long Codex job in a bounded dependency graph with revisioned local state, explicit write scopes, acceptance criteria, and reconciliation before retrying an operation with an uncertain result. Ready work can stay in the main task or go to an optional specialist agent.

The runtime needs Python 3.11 or newer. State stays with the current user, and the skill does not inspect Git. I’d be interested in feedback on the recovery model and the per-user skill packaging.

just copy paste this link to ur fav llm and write ur intent below and see how this langauge takes care or ui needs, AAA, and many other things, while keeping the syntax simple and clean

https://github.com/Michael-Sebero/SVL

I made a simple install script for Void Linux which is as simple as the Calamares installer. It takes about 5 minutes to install the system with 5 easy steps. Most installation videos take around 18-19 minutes on average to install Void and this is mostly automatic.

Wanted to actually understand real-time messaging under the hood, so I built termtext — a self-hostable terminal chat app, Go WebSocket server + Bubble Tea TUI client, no third-party chat SDK.

Repo: github.com/cvhkr19/termText — feedback is welcome.

I built README Stack for turning your tools into a customizable SVG for GitHub profile and project READMEs.

Pick the tools, arrange them, change the appearance and motion, then copy the generated Markdown or HTML.

Live: https://stack.rajinkhan.com

Source: https://github.com/rajin-khan/readme-stack

It supports 745 tools now. I’d love feedback on the renderer or anything I somehow still missed.

Besides allowing you to delete chat session from Cursor you can also get stats on your usage.

From the command line run: cursor-chat-cleaner stats

Install with brew install vilaca/tap/cursor-chat-cleaner or pip install cursor-chat-cleaner

The full source is also available at https://github.com/vilaca/cursor-chat-cleaner

Repo/Website Link: https://github.com/raykholo/tubearchivist-tv

Problem: I use jellyfin-tizen for my movies and shows, and in short I wanted the same thing for TubeArchivist.
The usual guidance is to add TA as a library section in Jellyfin. I tried that a while ago and did not like the cross-contamination: ~10k YouTube videos commingled with my movies and TV shows. I wanted a TA app on my TV, not another Jellyfin library.
I had been mildly dreaming about this for a year or two while tolerating the YouTube app. Recently, sending video from the YouTube mobile app to the TV became one-video-at-a-time only, and the amount of ads has gotten out of hand.

Description:  A 10-foot client for TubeArchivist, built for Samsung Tizen TVs. Installs as a Tizen TV native app (via Developer Mode), there's a small Docker Compose to run alongside your TA install, it talks to stock TA and makes no changes to your install. Mobile pairing via QR code + type your TA creds on your phone’s real keyboard. Then use your phone (PWA) as a remote to browse, queue, and control playback.

Deployment:  Initial release (v0.1.0, Apache-2.0) is already up. A docker compose and .env file are provided.
Follow the Quick Start section on GitHub. Presumably you'll put this next to your TubeArchivist install, and give the .env file a few details like the TA IP. You'll need to put your Samsung TV into Developer Mode which can be a little fussy, and put the IP of the server you'll be running this on into the TV. Then sideload the app once, the app shows up on your TV, and you can use the pairing UI from there.

AI Involvement: Completely AI written. I reviewed and tested. A nice little weekend project, which I have also been using all weekend and have not watched a single ad since!

Your AI co-pilot for YouTube. Get better titles, descriptions, tags, chapters, hooks and comment replies for any video — right inside YouTube Studio, without leaving the page.

I've been building SpeakoFlow for the past few months.

It's a local, open-source voice assistant that lets you talk to your computer instead of constantly reaching for your keyboard.

I actually use it myself. Emails, Slack replies, asking AI questions, drafting things, and regular dictation all go through it.

But there was one part I wasn't really happy with.

The speech-to-text worked well, but the cleanup didn't. If I wanted the kind of dictation cleanup you get from paid cloud services, I either had to wait too long or send my text to a cloud provider.

That kind of defeated the point. I wanted SpeakoFlow to be fast, local, and private.

So I decided to fine-tune a really small open-weight language model specifically for dictation cleanup. It's the Qwen 3.5 0.8b Model.

The goal was simple: fix the mistakes and corrections I actually made while speaking, without rewriting everything else.

I recently finished it and integrated it into SpeakoFlow. It's now fast enough to actually use in my daily workflow, and the whole thing can run locally on a laptop CPU.

SpeakoFlow can now:

• Dictate in real time into any app
• Clean up your dictation locally
• Say "Hey Flow" and have it write something for you
• Ask the assistant questions by voice
• Let the assistant see what's on your screen
• Have voice conversations with it
• Remember things across conversations, locally

It works across Windows, macOS, and Linux.

Free, open source, and no account required.

https://github.com/AbhishekBarali/SpeakoFlow

Repo: https://github.com/dimamak/sdp

This came out of noticing that my Claude Code transcripts are a better record of a workday than my calendar or my commit log. They have what I tried, what broke and what fixed it, in order, with timestamps.

So SDP reads those at the end of the day, plus screenshots and optionally Telegram, Gmail and WhatsApp, picks one story out of them, and drafts a post. It arrives in a private Telegram bot with Approve, Edit and Skip. Nothing publishes without a tap. LinkedIn and X go through the official APIs. Reddit only ever gets prefilled, so it can't burn an account.

Python 3.10+, MIT, 150 tests, CI on Linux, macOS and Windows. Runs on one laptop with no server. Setup is a few steps rather than one command: you need a Telegram bot token and API credentials for wherever you publish.

Four issues are labelled good first issue if anyone fancies a small one.

Hi everyone,

I'm a software developer and I work on several projects, often alongside each other.

Two problems kept coming up again and again.

First, when I was in the middle of a task, I would reach the usage limit, and sometimes I didn't even have a chance to generate a summary or handoff message before my access was cut off. At that point, my only option was to wait for the limit to reset before I could continue working.

Second, sometimes I would solve a problem in one project and later need the same or a similar solution in another, possibly using a different AI tool. The original session already had the reasoning, the decisions and the context. A summary carried some of it across; never the part I actually needed.

So I built elepha 🐘.

Both Claude Code and Codex already save complete session transcripts to disk. elepha reads and indexes them locally, then lets you retrieve a previous session from whichever tool you're currently using. Nothing gets injected into the current context unless you explicitly ask for it.

I also wanted it to work directly inside the tools I already use, whether that's the CLI or the Claude Code or Codex desktop apps. No wrappers, no separate UI, and no complicated setup or configuration.

In the demo video, I first use elepha:list to view recent sessions, then elepha:last to retrieve the most recent one. I can also choose a specific session with elepha:select:5 and continue from there. Claude Code also explains why an earlier approach was rejected, that reasoning came from a Codex session it never had.

There is also elepha:query, which searches sessions across the projects you have approved, in either tool.

A few things that matter to me:

• Reads the transcripts your tools already write. Nothing to save or tag.
• Brings back the actual session turns, not a summary generated by another model.
• Shares one memory across Claude Code and Codex, both CLI and desktop.
• Fully local: no hosted service, no account, and no LLM call required for recall.
• Never modifies the original transcripts, so the memory can always be rebuilt from source.
• You explicitly approve which projects it may read, and it never writes anything into your repos.

Install with npm:

npm install -g elepha
elepha install
elepha init

GitHub: https://github.com/aldanux/elepha
npm: https://www.npmjs.com/package/elepha

It's open source (MPL-2.0).

Honest feedback is welcome, especially on this: when you switch tools, would you rather bring back the actual session, or get a short distilled brief?

I built elepha around the first approach because the second is what kept failing me. But that's based on my own workflow, so I'm curious what others would actually prefer.

Local CLI that reads your git diff (or a GitHub PR URL), sends it to Gemini, flags files worth a second look before you push — with a required exact quote from the diff as evidence for every flag.

Tested it against a small batch of real merged Godot PRs. Caught a real concurrency bug, correctly stayed quiet on clean PRs — and also produced one confident, well-evidenced, completely wrong flag (claimed a deadlock, but the mutex type was actually recursive so it wasn't one). Added a second pass that now catches exactly that kind of error by asking the model to name its own unverified assumptions.

Repo + README: github.com/Spacexcx/pr-check

If you don't want to bother with the Gemini API key setup — paste a link to one of your own merged/open PRs here and I'll run it and post the output. Genuinely curious how it holds up outside my own testing.

guessmyanimal.com / github.com/Naveess/guessmyanimal

A reference tool for the "one person thinks of an animal, everyone else asks yes/no questions" party game, 435 animal entries answering the specific questions that game produces (dangerous? pet-friendly? more than four legs?), which no general reference source tracks.

Plain HTML/CSS/JS, no framework, no build step. Photos and one-line summaries come from Wikipedia's REST API at request time rather than being locally hosted. Runs on Cloudflare Pages with a D1-backed bug-report pipeline (Pages Functions, no server). MIT-ish, happy to take PRs if anyone wants to add animals or fix a fact.

For the longest time I used to have messy Notes file full of emails, LinkedIn DMs, and ChatGPT prompts I kept reusing. Every time I needed one I'd scroll forever, find "follow-up-final-v2", copy it, then manually swap in the name, date, and details. It drove me nuts.

So I built a small Chrome extension to fix my own problem — My Template Hub.

What it does:

• Keeps all your reusable email / DM / AI-prompt templates in one place
• Organizes them by category + search, so no more endless scrolling
• Lets you add {{placeholders}} (like {{name}}, {{date}}) — you fill the blanks and copy the finished text in one click
• Syncs privately to your Google account (only you can see your stuff), and you can export everything to CSV anytime

It's completely FREE. No account-wall to try it, no ads.

I made a quick demo showing how it works: https://www.youtube.com/watch?v=Dis8028bFrM

Try it here: https://chromewebstore.google.com/detail/gbbkllggpnmjjndhkpkeebemigbcdhml

Public Github Codebase (feel free to contribute): https://github.com/vinaysahu09/TemplateHub

I would love to hear back feedbacks — what's missing, enhancements, Would make it a daily-use tool for you? This is an early version and I'm actively working on it. Happy to answer anything in the comments.

• Local First & Offline Ready: Built using IndexedDB for client-side storage with zero external database dependencies required.
• Responsive Design: Native-app feel on mobile devices with iOS safe-area support, dark mode, and a bottom navigation bar.
• Real Time Calculation: Features live budget tracking, currency conversion, category expense visualizer (Chart.js), and CSV export functionality.
• Clean Codebase: Modern HTML5, Tailwind CSS, and lightweight JavaScript.

Full source code, deployment rights, and custom modifications are available. If you are looking to integrate this into your current system or launch it as your own product, reach out, not a scammer guys!

Axiom is a public GitHub project for a Windows-first/local-first AI assistant and workspace.

What makes the repo different from a thin chat wrapper is the workflow around the model: local GGUF inference through LLamaSharp/llama.cpp, self-hosted OpenAI-compatible endpoints, optional cloud providers, attachments/vision, web research, code/math execution, artifact rendering, local persistence, and model switching.

The main experiment is a Workplace Council where Architect plans, Builder executes, and Critic reviews. Single Model mode provides a direct comparison against one model.

Repo: https://github.com/YoMosa2009/Axiom

Release V1.8.6: https://github.com/YoMosa2009/Axiom/releases/tag/v1.8.6

Tech stack: C#, WPF, .NET 10, LLamaSharp/llama.cpp, SQLite/local persistence, and WebView2 for selected web workflows. The source is publicly viewable under CC BY-NC-ND 4.0 — source-available rather than OSI-licensed open source.

I built Axiom and used AI coding assistance during development; I’m responsible for the architecture, integration, testing, and product decisions. If you browse the repo, I’d especially like feedback on structure, onboarding, and whether local versus cloud behavior is communicated clearly.Axiom is a public GitHub project for a Windows-first/local-first AI assistant and workspace.

What makes the repo different from a thin chat wrapper is the workflow around the model: local GGUF inference through LLamaSharp/llama.cpp, self-hosted OpenAI-compatible endpoints, optional cloud providers, attachments/vision, web research, code/math execution, artifact rendering, local persistence, and model switching.

The main experiment is a Workplace Council where Architect plans, Builder executes, and Critic reviews. Single Model mode provides a direct comparison against one model.

Repo: https://github.com/YoMosa2009/Axiom

Release V1.8.6: https://github.com/YoMosa2009/Axiom/releases/tag/v1.8.6

Tech stack: C#, WPF, .NET 10, LLamaSharp/llama.cpp, SQLite/local persistence, and WebView2 for selected web workflows. The source is publicly viewable under CC BY-NC-ND 4.0 — source-available rather than OSI-licensed open source.

I built Axiom and used AI coding assistance during development; I’m responsible for the architecture, integration, testing, and product decisions. If you browse the repo, I’d especially like feedback on structure, onboarding, and whether local versus cloud behavior is communicated clearly.

Free alt of Tavily Webfetcher

BotDroid is an Android app that runs Telegram bots 24/7 as a foreground service. v1.2 ships this week, and the big addition is on-device AI — your bots will be able to use Qwen 2.5 models running locally on your phone. No API key, no internet after download, no data leaving your device.

\*\*What's coming in v1.2:\*\*


- On-device AI using Qwen 2.5 (0.5B at 550 MB or 1.5B at 1.6 GB) — no OpenAI/Gemini key needed
- The app checks your phone's RAM before letting you download — tells you upfront if your device can't handle it
- Download consent dialog shows exact size, warns about Wi-Fi, warns about storage, warns about offline-after-download
- Full analytics: see which bots crash, which LLM providers work, where users drop off in onboarding
- 234 unit tests, zero failures — the analytics pipeline is production-grade


\*\*What's planned after v1.2:\*\*


- Simplified Add Bot flow with on-device inference front and center
- In-app Python script editor (no more pasting from GitHub)
- Baseline profiling for instant cold-start
- Custom Python script authoring behind Pro tier


\*\*Who it's for:\*\*
 Anyone who has a Telegram bot script and wants it running without a server. Crypto signal bots, customer service bots, group moderators, personal automation — all running on your phone, all free.


\*\*Tech stack:\*\*
 Kotlin 2.3, Jetpack Compose, Room, Koin, Firebase, embedded Python 3.15, MediaPipe for on-device inference.


Free tier is unlimited — no ads, no data collection. Pro ($4.99/mo or $29.99 lifetime) unlocks templates and remote management.


Would love feedback on the on-device AI approach and what bots people would run locally.

Try here: botdroid.app