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

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

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.

V2Kit is a lightweight and extensible Python toolkit for working with V2Ray proxy configurations and subscriptions. It provides a clean API for common operations such as protocol detection, configuration validation, config relabeling, and subscription encoding/decoding. The project is designed with simplicity, predictability, and composability in mind, making it suitable for automation scripts, proxy pipelines, networking tools, and future extensions around V2Ray ecosystem utilities.

We've been working on Keydris for the last few months and just opened it up.

I wanted to share it here before we take it anywhere bigger.

The thing that bothered me was this.

We keep giving agents credentials and access to more systems.

But if an agent can run:

git status

why should that automatically mean it can also run:

git push --force origin main

The credentials might allow both. I don't necessarily want the agent to be allowed to do both.

That's basically where Keydris started.

Before an action runs, we check whether that action is actually inside the authority given to the agent.

We're in Developer Preview now. We have paths for Claude Code, Codex, MCP, GitHub, Slack and local commands.

GitHub:

https://github.com/keydrisLabs⁠

If you try it and something is confusing tell me.

And if your reaction is “OAuth or IAM already solves this”, tell me how you would do it. I'm interested in that too.

If you work on an HPC cluster, you probably know the watch squeue routine: scan the columns for your job, open another terminal to check its logs, then repeat.

I got tired of doing that, so I built sqwatch, a small terminal UI that turns the SLURM queue into a live dashboard.

It includes:

• A live, auto-refreshing job table with color-coded states.
• Filters for user, job name, state, partition, QoS, and node. Cluster values are loaded automatically, and your filters persist between sessions.
• Real-time stdout and stderr tailing, submission-script viewing with bat syntax highlighting when available, and custom panels for other output files produced by a job.
• Multi-job selection and batch cancellation.
• Clipboard support through OSC 52, including over SSH and inside tmux without X11.

sqwatch is written in Rust using ratatui. It calls the standard SLURM commands, including squeue, scontrol, sinfo, and scancel, so it does not require anything special to be installed or configured on the cluster. If those commands work, sqwatch should work too.

I have just released version 0.2.0, which is the first version I feel comfortable recommending to others. It fixes several rough edges from the initial release.

Install it with:

cargo install sqwatch

Repository: github.com/fedonman/sqwatch

Please, give it a ⭐if you like it.

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

I built aimake — an incremental build system for AI/ML pipelines, basically make for AI apps.

GitHub: https://github.com/arjun988/aimake

The idea is simple:

Dataset → Preprocess → Embeddings → Index → Prompt → Eval → Report

aimake builds a dependency graph, fingerprints inputs by content rather than timestamps, and only rebuilds steps whose inputs actually changed.

So if you change your prompt:

Before:
Dataset       ✓
Preprocess    ✓
Embeddings    ✓
Index         ✓
Prompt        ✗ changed
Eval          ✗
Report        ✗

After:
2 rebuilt · 5 reused

aimake plan     # see what would rebuild
aimake build    # only stale steps run
aimake explain  # see why a step needs rebuilding

It's not Airflow (orchestration) and it's not DVC (data versioning alone).

It's make for AI pipelines: dependency graph + content fingerprints + incremental builds + caching.

Shipped so far

• Content-hash fingerprints instead of mtime-based caching
• Incremental + parallel builds
• plan / build / explain CLI
• Experiment comparison + hyperparameter search
• S3 cache + Hugging Face / DVC / Docker / Ollama / W&B plugins

You can try it with:

pip install aimake

The main reason I built this is that AI pipelines are expensive to rerun. Changing a prompt shouldn't mean recomputing your dataset, embeddings, vector index, etc.

If you build RAG , evaluation or any AI pipelines, I'd love feedback: what's the most painful step you wish was cached?

And if you think the idea is useful, a ⭐ on GitHub would really help.

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

The project is open source under the MIT License.

Prebuilt downloads for macOS, Windows, and Linux are available on GitHub:

https://github.com/chen-985211/cleancode

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.

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.

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.

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.

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!

Hi everyone!

Four months ago, I released StemDeck, a project I originally built to help my kid learn bass and drums.

Finding good bassless and drumless tracks for practice was surprisingly difficult, so I created a small app that could separate songs into stems. The first version allowed you to add a local song or paste a YouTube or SoundCloud link, separate it, and use a basic mixer.

Since then, StemDeck has grown from version 0.5.0 to the 0.15.x generation and has reached more than 3.4K GitHub stars and 30,000 downloads.

That response has been incredible, especially for a small family project with no company, funding, advertising, or paid promotion behind it. Feedback, bug reports, feature suggestions, and contributions from musicians and the open-source community have helped turn StemDeck into something much bigger than I expected.

StemDeck remains completely free, open source, private, and designed to run locally on your computer.

What StemDeck can do

Disclaimer that Table built with AI support

Private and genuinely free

Everything runs locally on your own computer. Your music is not uploaded to StemDeck servers.

There are:

• No accounts
• No advertisements ( there is a beautiful recomendation list though, of people/artists that impacted my life as a musician )
• No subscriptions or paid tiers
• No usage limits or credits
• No telemetry

StemDeck does not accept money, sponsorships, or corporate funding from the people of we recommend list. There are no plans to introduce a subscription or paid tier. ever, never.

StemDeck will always remain free and open source.

A quick reality check

I also want to be honest about what StemDeck is.

It is still alpha software. Separation quality varies between recordings, and processing can be slow without a supported GPU. It is not intended to replace a professional DAW or pretend that open-source separation can outperform every commercial service.

The goal is simpler: to give musicians a practical and private tool for learning songs, practising parts, transcribing music, creating backing tracks, and experimenting with recordings.

Seeing people use something that began as a way to help my kid practise has been incredibly meaningful. As a bass player myself, contributing something useful to other musicians and the open-source community genuinely makes me happy.

You can download the latest release or inspect the source code here:

https://github.com/stemdeckapp/stemdeck

I would love to hear what you think. Bug reports, suggestions, pull requests, translations, and general feedback are all welcome. ❤️

EDIT and important disclosure regarding AI USAGE:

I also want to be transparent about the development process. Claude Code and other AI-assisted tools have been used while building StemDeck.

This does not mean the project was generated without technical direction or review. The architecture and product decisions are deliberate, the code is reviewed, and the project includes automated backend and browser testing. I welcome specific technical criticism, bug reports, and examples of places where the current design is causing real problems.

I am a seasoned musician with more than 25 years of experience in the IT industry. As I like to joke, I am the maestro conducting the orchestra. The tools may help play some of the parts, but I remain responsible for the composition, direction, review, testing, and final result.

Put another way, I know how to cook. AI assistance simply helps me cook faster. As a working family man, I would never have had enough time to build and release something this ambitious while it could still be useful for helping my kid learn music.

StemDeck should be judged by what it does, how it is engineered, and how well it serves its users. Constructive technical feedback and contributions are always welcome.

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.

Hi everyone,

I have created a Git-backed Markdown note-taking app.

I built this app out of my real needs. I was taking notes on my laptop and needed to sync them with my other devices, like my phone and my Android e-ink tablet. Usually, you either have to pay for a service to make that work, or you have to hand all your data over to Google, Microsoft, or another big corporation. With this approach, you truly own your data—you can sync it to your own VPS, GitHub, GitLab, or any other Git provider. (An option to encrypt all your notes is coming later, so you can store them more comfortably on public platforms like GitHub).

The app is works across all major platforms: Linux, macOS, Android, iOS, and Windows. (macOS and iOS releases are not available just yet, as I don't currently have access to a Mac device to compile them 😒 ).

The project is still a work in progress, and many new features and bug fixes are coming soon.

Supporting the project would really help for future development! ⭐

Repo link: https://github.com/jotalac/git-writer

Titre : [Demande d'avis UX/Design] Landing page de présentation pour CityTimelineMod (CS2)

Texte du post :

J'ai mis en ligne une landing page de présentation pour le projet CityTimelineMod (un mod d'overlays géospatiaux GeoJSON pour Cities: Skylines II). J'aimerais obtenir des retours objectifs uniquement sur la page web elle-même (design visuel, lisibilité, structure et ergonomie) :

Lien du site : https://skyline-atlas-explorer.lovable.app/

La page s'articule autour des sections suivantes :

Overview : Présentation du concept d'overlays et des bundles RealMap.

LargeMap (exp.) : Explication du cadrage étendu à 57 344 km.

Calques : Détail des 4 calques géographiques (routes, eau, zonage, rail).

Architecture technique : Pipeline de traitement, de l'ingestion GeoJSON au rendu in-game.

Statut du projet : Tableau de transparence (implémenté / expérimental / non garanti).

Points sur lesquels vos retours m'intéressent :

Direction artistique & UI : Le thème sombre, les éléments graphiques et la typographie sont-ils visuellement équilibrés et agréables ?

Clarté de la structure : L'enchaînement des sections permet-il de comprendre immédiatement de quoi parle la page, même sans connaître le mod ?

Lisibilité & Ergonomie (UX) : La navigation par ancres est-elle fluide ? Avez-vous constaté des bugs d'affichage ou de disposition (desktop ou mobile) ?

Mise en valeur de l'information : La séparation visuelle entre les éléments stables et les fonctionnalités expérimentales est-elle évidente ?

Merci d'avance pour vos critiques constructives sur la page !

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.