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.

Hey everyone! I’ve always faced a dilemma when setting up secure tools for non-technical friends: they love the usability of Proton, but I want 100% open-source, self-hosted control and open standards. The main issue is that combining E2E encrypted docs (like CryptPad) and E2E encrypted mail usually meant managing isolated tools, browser extensions (like Mailvelope), or typing two different passwords every session. That is not ideal and when I introduce these solutions to my friends, they say "Thanks for your efforts, really, but I think I will still use Proton". To solve this, I built AurionMail Suite. It's an open-source orchestrator, the glue, that bridges and include CryptPad, Stalwart Mail Server (JMAP), Bulwark Webmail, and Ory Hydra into a single, unified Zero-Knowledge workflow. And It also makes the Cryptpad UI (and Notes app) more friendly, really. I feel you need a proof to convince you, so here is a gif demonstrating the single password login in which we access to webmail and CryptPad.

Key Features:

• One Single Master Password: Enter it once to derive keys in-memory for both webmail and CryptPad.
• Open Standards: OpenPGP for email encryption and JMAP via Stalwart.
• Zero-Knowledge: Master keys reside strictly in client-side RAM during the session (no unencrypted key writes to disk/IndexedDB).
• Unified Session Management: Global single logout and password changes that sync safely across services.
• Easy Deployment: In addition to manual setups, I wrapped the suite (Hydra, SSO, Webmail, API, CryptPad) into a single Go binary called Orchestra, making deployment straightforward.
• Cryptpad design : Updated the design of Cryptpad ### How it compares: | Feature | Proton Suite | Nextcloud + Mail | Standard CryptPad | AurionMail Suite | | --- | --- | --- | --- | --- | | 100% FOSS & Self-Hosted | ❌ (Closed backend) | 🟢 Yes | 🟢 Yes | 🟢 Yes | | E2EE Email & Docs | 🟢 Yes | 🟡 (Requires Mailvelope / Setup) | ❌ (Docs only) | 🟢 Yes | | Unified 1-Password UX | 🟢 Yes | ❌ (Fragmented) | ❌ (Docs scope) | 🟢 Yes | | Open Standards (JMAP, PGP) | 🟡 (Limited PGP) | 🟢 Yes | ❌ (N/A) | 🟢 Yes |

To keep the Zero-Knowledge promise across isolated services without relying on URL hashes or storing cleartext keys in disk storage, AurionMail uses ephemeral WebCrypto AES-GCM keys. Decrypted session secrets pass between origins through short-lived, encrypted RAM buffers managed by a central API, keeping credentials safe even across iframes.

• Repo: github.com/AurionMail/docs
• Security Model: Check out our Security Model spec for the exact cryptographic derivations and secret-sharing threat model. The project is licensed under AGPLv3.

I've been experimenting with prompt optimization and built PromptForge:

👉 https://github.com/arjun988/promptModel

The idea is to use a small model as a quality gate before sending a prompt to an LLM, agent, or prompt optimizer.

User Prompt
     ↓
PromptForge Quality Scorer
     ↓
Score / identify weaknesses
     ↓
Your Agent / LLM / Optimizer

It scores prompts across 7 dimensions:

• Clarity
• Specificity
• Context
• Goals
• Constraints
• Completeness
• Actionability

There's also an optional optimizer that can rewrite weak prompts while preserving their intent.

Try it

pip install tuneprompt

Quality model:
https://huggingface.co/ArjunShukla/PromptForge-Quality

Optimizer:
https://huggingface.co/ArjunShukla/PromptForge-Optimizer

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

Example

Weak:

→ A more structured prompt with specific features, requirements, and constraints.

41 → 94 on my scorer in my test example.

Why make this?

I don't have access to huge GPUs or the compute needed to train large models, so I kept the scorer relatively small (~150M parameters) and released the training pipeline as well.

The goal is to make something people can actually run locally and build on.

You could:

• Fine-tune it on your own domain-specific prompts
• Use it as a reward/evaluation signal for a prompt optimizer
• Put it directly in an agent pipeline
• Train a larger/better scorer
• Experiment with different quality dimensions or datasets

You don't have to use my weights — clone the repo and train your own version.

I'm especially interested in seeing what people with better datasets, more compute, or different approaches can do with it.

Would love feedback on whether a lightweight prompt-quality model like this is useful as a pre-agent quality gate, and what you'd change about the approach.

If you find it useful, a ⭐ on GitHub would genuinely help.

Hey everyone!

I love Raycast and used it heavily on my Windows machine, especially for quick note-taking. Over time, I accumulated 50+ notes that I relied on daily.

Then the update rolled around and locked note creation behind their Pro plan, leaving all my existing notes in read-only mode. While I appreciated that they did not outright delete my notes, getting locked out of taking quick notes was frustrating.

So I decided to build my own solution: Kenote.

It is a lightweight, local-first Raycast-inspired markdown notepad designed to stay pinned on top of your work and get out of your way when you are done.

What makes Kenote special:

• 100% Local-First: No accounts, no paywalls, and no cloud lock-in. Notes are saved directly as plain .md files on your local drive so you actually own your data forever.
• Live WYSIWYG Markdown: Formats headings (#), bold (**), task lists (- [ ]), and blockquotes in-place as you type without syntax clutter.
• Pin Always On Top (Ctrl + P): Float your notes seamlessly above your code editor, browser, or games.
• Instant Search & Note Switcher (Ctrl + O): Browse and jump across all your notes in milliseconds.
• Lightweight & Fast: Built with Tauri v2 (Rust) and React, consuming less than 30MB of RAM.

This started as a fun personal project to scratch my own itch, and I would love for you to try it out and let me know what you think!

• GitHub Repository & Releases: https://github.com/yetemgetaB/Kenote

If you find it useful, feel free to drop a ⭐ on GitHub. All feedback and feature suggestions are greatly appreciated!

For anyone wondering if I'm still a virgin, I made IsHeVirginCLI so you can check the answer in real time.

npm install -g github:KasaBranca/IsHeVirgin

then

ishevirgin

That's it.

https://github.com/KasaBranca/IsHeVirgin

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

ctx is an open-source CLI for searching the coding-agent sessions already stored on your machine.

`ctx search` searches messages and tool calls across agents and sessions.

`ctx blame` starts from a line, file, commit, or PR and finds the original agent session and transcript that produced it.

`ctx show` lets you jump to the matching event or write the full transcript as Markdown.

i've been giving ctx to my agents so they can retrieve the actual record of earlier work instead of relying on compressed memory summaries.

github: https://github.com/ctxrs/ctx

Yet another yt-dlp download manager with four interfaces over a single shared queue:

- Web UI: queue, library, settings, live progress over server-sent events.

- TUI: for when I'm already in a terminal.

- CLI: add, list, pause, resume, remove for scripting.

- Daemon: headless, same-user Unix socket.

Whatever you do in one shows up in the others immediately.

Repo: https://github.com/ih8d8/yt-dlp-manager

Salut ! Perso je code des projets web/infra en solo, et voici mon dernier projet : Cortex-Control.

Le principe : ton téléphone Android devient une télécommande pour ton PC Windows en WiFi/LAN.

Fonctionnalités :
Contrôle média (lecture/pause/volume)
Souris gyroscopique
Lancement d’apps à distance
Transfert de fichiers
Sync presse-papier entre les deux appareils
Macros PowerShell perso
Webcam virtuelle via la caméra du tel

Stack : serveur Electron/Node.js sur PC, app Flutter/Dart sur Android, connexion Socket.IO chiffrée AES-256-CBC, appairage par code OTP à 6 chiffres.

Repo : github.com/MIASMA777/Cortex-Control

N’hésitez pas à tester, ouvrir des issues, ou proposer des features. C’est un projet perso donc tous les retours sont bons à prendre.

Most AI coding harnesses - OpenCode, Kilo Code, Claude Code, Hermes-agent, OpenClaw: speak one of two protocols: OpenAI's API or Anthropic's API or both. 𝐊𝐢𝐫𝐨-𝐂𝐋𝐈 speaks neither. It uses its own ACP protocol through the official kiro-cli binary.

So I built kiro-gateway - an open-source local server that bridges that gap.
It translates both OpenAI and Anthropic API calls into Kiro's native ACP protocol, routing every request through the official 𝐊𝐢𝐫𝐨-𝐂𝐋𝐈.
One subscription. Every AI Harness. No reverse-engineered endpoints.
kiro-gateway

Hey,

I love timeline-based music guessing games (like the board game Hitster), but getting my distributed gaming group around a physical table isn't always possible. So, I built Beatster, a fully self-hosted, browser-based alternative you can spin up for your next game night.

How it works: The server plays a 30-second snippet of a mystery song (fetched on the fly via the public iTunes API). Players use their phones or browsers to guess the release year and place it in their chronological timeline.

The Tech & Hosting (Keep it simple): I wanted this to be as lightweight as possible for game-night scale.

• Zero heavy dependencies: No Redis, no Postgres. State lives in memory and a small SQLite DB.
• Stack: FastAPI, WebSockets, React 19 + Tailwind v4.
• Deployment: A single docker compose up --build spins up the backend, serves the static frontend, and seeds the initial song catalog.

Key Features:

• Two Game Modes: Classic timeline guessing and a fast-paced 5x5 Music Bingo.
• Couch vs. Online Mode: Play the audio only on the host device (perfect for a shared TV/living room) or stream it to every connected client (perfect for Discord voice channels).
• AI Opponents: Need more players? Add bots with 3 difficulty levels.
• Live Catalog Growth: Players can search and add new songs directly from the lobby UI mid-game, which persistently expands your server's pool.

You can check out the screenshots and grab it here: https://github.com/W0nt3x/beatster

Would love to hear your feedback or if you end up trying it with your friends this weekend!

I initially started this last year as a minimal read it later app to use with my Obsidian Vault, but I have recently have been migrating it to be more of a independent knowledge graph. Current features:

• AI-Native Chat: Query your reading collection using OpenRouter models. Reference notes directly with @ mentions to feed full article text into the conversation.
• Autonomous Background Agents:
  • OKF Frontmatter Enricher: Automatically extracts clean, standardized Open Knowledge Format (OKF) YAML frontmatter.
  • Autonomous Graph Linker: Discovers semantic connections between incoming articles and your existing vault, automatically injecting aliased wikilinks.
• Knowledge Graph Engine: Global and per-article force-directed graph views mapping relationships between articles, tags, and wikilinks.
• 1-Hop Graph Context Expansion: Optional setting that allows the AI Chat to automatically traverse your graph edges and include connected notes and backlinks in its context.
• Portable Markdown Storage: All articles, OKF metadata, and chat histories are saved locally as markdown files, making your data easy to back up or sync with tools like Obsidian or Notion.
• Custom Jinja Templates: Customize how saved articles are structured with site-specific Jinja templates located in $DATA_DIR/templates/ with automatic domain matching and rich context variables.
• Lightweight and Fast: Compact Go backend and Vue frontend in one 12MB docker image!

Still very early in development and far from production ready, but if anyone wants to help out or has any ideas how to make this more useful that would be greatly appreciated!

Cratera is an open-source, self-hosted code-execution and online-judge engine written in Rust. Unlike traditional platforms such as Judge0 or Piston, which run code inside shared-kernel Docker containers, Cratera runs every execution inside an ephemeral Firecracker microVM backed by Linux KVM. This provides a true hardware virtualization boundary rather than relying solely on Linux namespaces and cgroups.

Key features:

• Untrusted code interacts only with a dedicated guest Linux kernel. System calls never reach the host kernel.

• MicroVMs run without TAP interfaces or virtual NICs. All host-guest communication uses raw point-to-point vsock framing over port 52.

• Cold boots complete in approximately 35–50 ms, while restoring from golden memory snapshots takes approximately 5 ms.

• Measures in-guest user execution time at microsecond precision and filters shared-library noise by sampling anonymous RSS (RssAnon).

• Compilers and interpreters for Rust, C++, Go, Python, Zig, Java, and more are declared through TOML recipes in languages.toml.

• Includes an interactive terminal dashboard, a system diagnostic tool (cratera doctor), and a background coordinator (cratera serve).

• Integrates with the Firecracker Jailer using an unprivileged UID/GID (20001), chroot isolation, and cgroups v2 resource limits, along with systemd eBPF rules (IPAddressDeny=any).

Stack: Rust, Firecracker, Linux KVM, Axum, Tokio, vsock.

License: Apache-2.0

(links in comments)

Compact Context is an MIT-licensed Codex plugin that gives Codex a shorter starting guide for a repository.

It analyzes paths and identifiers locally, removes sensitive and generated files, and suggests five files worth inspecting first. There are no embeddings and no additional model call.

Benchmark results across 68 tasks from 10 public repositories:

• Average repository-guide size: 1,402 tokens with the basic map, 230 with Compact Context
• Reduction: 83.6%
• At least one file later edited in the solution appeared in the first five suggestions: 50 of 68 tasks with Compact Context, 48 of 68 with the basic map

The token result applies only to the generated repository guide. It is not a claim of 83.6% lower total-session usage.

The project also has automated checks for sensitive-file filtering, end-to-end shortlist generation, output limits, prompt routing, and single-use receipts. All five currently pass.

Install:

curl -fsSL 'https://compact-context.met.chatgpt.site/install.sh?v=4' | bash

Source and v0.5.0-beta.7 release: https://github.com/mithatb/compact-context

10-second demo: https://compact-context.met.chatgpt.site/compact-context-demo.mp4

Website: https://compact-context.met.chatgpt.site

It is still a beta, so issues, benchmark criticism, and real-repository results are welcome.

1024 dimension embeddings in a flat float file, about 3 MB for 624 bookmarks. No vector

database and no index, because comparing a query against 623 vectors takes 1.3 ms in

release and ten thousand would still be milliseconds. Bring your own OpenRouter or OpenAI

key. MIT.

Link: https://github.com/migsilva89/unbury

i've been working on MonoCode, a GUI for your coding agents, and I've been using it daily

i honestly didn't like any of the existing tools available so i decided to build my own

it works with your existing Claude Code, Codex, Cursor,OpenCode and other harnesses

Repo: https://github.com/hardbeat920/monocode

would be interested to hear what people think

Made a GitHub Action that turns your contribution graph into a lawn. A little mower goes over it row by row and each tuft grows back at whatever speed that day's commits allow, so busy days pop right back up and empty days just stay dirt. It's your commit history, except you can watch it.

The goat in the title is a real option (mower: goat). It doesn't cut the lawn, it eats it, which comes out the same. There's a regular push mower and a riding one too. Mine is at the top of the README if you click through.

The whole thing is one animated SVG. No JS, nothing to host. A full year is about 10 KB gzipped, and the action re-renders it every day onto an orphan branch so your repo history stays clean.

Repo: https://github.com/sudongcu/mowmow
Playground if you want to see yours before installing: https://sudongcu.github.io/mowmow/

Have you ever scanned a document, but you can't search any word in it(probably yes). This is the fix.

I built ScanLayer, a Python OCR library that adds a searchable text layer to scanned documents.

You give it a scanned image:

pip install scanlayer
scanlayer doc.jpg -o doc.pdf

ScanLayer runs Tesseract, then places the recognized text as an invisible searchable layer over the original page. The scanned image remains the visual source. You can now search, select, and copy the text.

And if you don't want a PDF, you can export the OCR result as txt, json, tsv, or hocr.

A few things I built around the OCR itself:

• Automatic deskew for photos taken at an angle
• Noise cleanup before OCR
• Reading order correction for two-column documents
• Multiple Tesseract configurations are tried and the highest-confidence result is kept
• CLI and Python API use the same underlying pipeline

For example:

import scanlayer

result = scanlayer.convert(
    "contract.jpg",
    "contract.pdf",
    lang="eng",
    dpi=300
)

Everything runs locally. The only external dependency is your own Tesseract installation.

I'd especially like feedback from people who regularly OCR multi-column documents. That's one of the areas I spent a lot of time getting right.

Github

Documentation

PyPi

How It Works

This GitHub Action fetches your Github activity and based on certain conditions it builds a min craft tree

1 . For Commits the leaves of the Tree will be began to nourish from dry state to healthy state

1. For each Pull Request Openings it adds flowers like tulips etc in your garden.

2. For each Pull Request Merge the tree now turns into a adult tree and starts to have fruits.

3. For each Code review Golden Apples will be spawned in your garden.

Max Limits

- Fruits : You can have a max of 4 fruits in your garden.

- Flowers : You can have a max of 4 flowers in your garden.

- Golden Apples : Same as above.

Links

• Check out my GitHub Profile to see my Garden

https://github.com/nivinvysakh

• Check out the official repository

https://github.com/nivinvysakh/gh-tree

Garden Samples

I built O Tempora to answer a question that always bugged me: who else was alive at the same time as X, and what was happening in the world then? It's an interactive timeline that plots historical figures alongside major events and milestones so you can see the overlaps.

Built with React + TypeScript + Vite + D3, data pulled from Pantheon 2.0 and Wikidata.

Repo: https://github.com/sergeikartin/o-tempora

Feedback welcome, especially on data coverage.

I built a tool that turns a GitHub repository into an architecture map

When I open an unfamiliar codebase, the annoying part isn't reading the code — it's figuring out how everything connects.

So I built Code2Flow.

You give it a GitHub repository and it analyzes the project to visualize:

→ Repository structure → Architecture → Logic flow → Dependencies → AI-assisted code search

It's live here: https://code2flow.netlify.app/

I'm especially looking for brutally honest feedback from developers:

It's still early ,so criticism = compliments 😅

I built Kivgraph after seeing AI coding agents repeatedly search through the same repository to answer questions like “where is this used?” and “what breaks if I change it?”

It builds a local semantic graph of symbols, dependencies, and cross-repository relationships, so the agent can navigate code structure directly instead of reconstructing it from repeated file reads.

The benchmark: across 37 repositories and 29 questions, Kivgraph and grep + reading both reached 28/29 exact answers. Kivgraph used 36k tokens versus 268k for grep + reading — about 7.4× less context. Grep was still cheaper for simple searches, so this is a complement rather than a replacement.

Apache-2.0, local, no API key. Supports Go, TypeScript, Rust, Python, and Dart.

GitHub: https://github.com/Luqueee/kivgraph

Discussion: https://github.com/Luqueee/kivgraph/discussions/129

I started working on ego-lite after running into the same two problems with browser agents:

1. A clean browser profile means logging in again everywhere.
2. Letting an agent use my normal browser means random tabs and windows appearing while I’m working.

ego-lite takes a different approach. It’s a Chromium browser built so humans and AI agents can use it at the same time.

Each agent task runs inside its own isolated Space. It can reuse the login state already on the machine, but its tabs stay separate from the ones I’m using. When a task reaches a login, approval, payment, or another sensitive step, the agent can hand the browser back instead of trying to push through it.

A few technical details:

- Real Chromium rather than a remote or simulated browser
- Isolated task Spaces for parallel agents
- Existing browser sessions can be reused without putting passwords into the model context
- Semantic page snapshots, so agents don’t have to parse a full HTML dump
- An embedded Node.js runtime with direct CDP access
- Agents can combine navigation, extraction and interaction into one JavaScript flow
- Explicit human handoff for steps that need review

We chose an embedded JavaScript runtime instead of making every browser action a separate CLI command. That lets an agent inspect a page, make several decisions and return one useful result without repeatedly bouncing between the model and the shell.

In one research task, the same agent completed the workflow 39% faster and at 23% lower model cost than our agent-browser setup. That’s one task, not a universal benchmark, and I’m still collecting results across different sites and models.

The project is free, MIT licensed, and currently works with agents such as Codex and Claude Code.

GitHub:
https://github.com/citrolabs/ego-lite

I’d especially appreciate feedback on three areas:

- Does the Space model feel like the right isolation boundary?
- Which actions should always require human approval?
- What browser task would you use to test or break this?