I've been spending some late nights building an app, Mizan (ميزان) which means "scale" in Arabic, to help me and my son with drum and piano practice. The app brings transcription, sheet music, instrument visualizations, and practice exercises together. It analyzes music using open-weight models (HT-Demucs and MuScriptor).

You can start with a YouTube link, import a MIDI or MusicXML file, or work through the built-in lessons without transcribing anything.

Here’s what it does:

• Transcription and audio separation. Turn a recording into draft instrument parts and isolated audio stems.
• Local or cloud processing. Run transcription on your machine, or use a GPU worker in your own Azure, Google Cloud, or AWS account.
• Interactive notation. Follow synchronized sheet music, guitar and bass tablature, and chord charts during playback.
• Instrument views. Animated piano, guitar, bass, and drums, with hand and fingering guides. Piano has both perspective and overhead views.
• Practice controls. Slow down playback, loop sections, jump between bars, and use a metronome and count-in. Toggle note names, fingering, and drum sticking.
• A mixer for practicing parts. Solo or mute individual tracks, adjust their volume, and switch between the original recording, separated stems, and synthesized notes.
• Built-in lessons for drums, piano, guitar, and bass. These include progressive exercises, genre-based studies, and original artist-inspired exercises. There are drum rudiments, coordination exercises, grooves and fills, plus scales, piano chord progressions, and instrument-specific technique studies. Lessons include practice guidance and starting and target tempos, with backing accompaniment where provided.
• Music discovery. Search YouTube and public MIDI sources from the app, or browse popular music.
• Library organization. Keep songs and scores in folders, revisit saved analyses, and rerun transcription with a different model.
• MIDI and MusicXML import and export. Bring in existing scores or take your results into another music tool.

The transcription isn’t perfect. It can miss notes or get parts wrong, so I think of it as a starting point for figuring out a song rather than a finished arrangement. You can also skip transcription entirely and use it to practice existing scores or the included lessons.

It’s open source and Windows-only for now. There are demo videos in the README if you want to see it in action.

• GitHub + demos: https://github.com/sabbour/mizan
• Download: https://github.com/sabbour/mizan/releases/latest

**Repo:** https://github.com/jjairocj/home-channel-hls (MIT)

---

## 🇬🇧 English

Hi everyone! I've been building **Home Channel HLS**, a self-hosted playout engine that turns a folder of your own videos into a **continuous 24/7 linear TV channel**. It feels like old-school cable TV: there's a schedule, shows start on the hour and half-hour, and there are bumpers and breaks between them. You don't pick from a menu, you just tune in.

**Why I built it:** nostalgia is part of it, but the real goal is a calmer relationship with screens. Yes, it's still a screen, but it works differently from a feed. There's no algorithm, no autoplay rabbit hole, no endless catalog to scroll through, and no subscription. Something is on, you watch it or you turn it off. A fixed schedule gives your time a shape again: shows start and end, and "what's on at 8" replaces 40 minutes of deciding what to watch. It's an attempt to push back against doomscrolling and the constant overstimulation we've gotten used to, using media you already own.

**Some context on the repo:** the public repo was created just yesterday, but the project isn't new. It started as a private, local project just for me, and I've been working on it for over a year. After talking it over with some friends, I decided to open it up so anyone can use it. I took the chance to separate it from my private setup and improve the development practices (docs, tests, Docker). That's why the public history starts with a single commit.

**What it does**

- **Continuous HLS stream** (`/live/channel.m3u8`) with fast start, playable in the browser, VLC, Kodi, TiviMate, and Smart TV / Android TV IPTV apps. It also exposes an M3U playlist.

- **Clock-aligned slots:** shows snap to `:00` and `:30`, so the schedule doesn't drift over the day.

- **Interstitial composer:** fills the gaps between episodes with "You're watching…" bumpers, non-repeating spots, station idents, and "Coming up next…" previews.

- **Next-up graphics + voiceover:** SVG billboards rendered on the fly, announced with TTS (local edge-tts or ElevenLabs).

- **Weekly grid with rules:** drag-and-drop planner, automatic daily episode progression, weekend marathons, a printable PDF schedule, and **XMLTV EPG** export (`/epg.xml`).

- **Hardware encoding:** NVENC, VAAPI/QuickSync, VideoToolbox, or `libx264` CPU fallback.

- **Web "Master Control":** monitor stream health, override what's on air, manage the transcode queue, and see viewer stats.

- **FM-style radio mode:** an audio-only HLS station with a retro 90s Hi-Fi tuner UI (analog dial, RDS display) and an automated DJ. The DJ's intros are written by a **local LLM via Ollama** (with templates as a fallback when Ollama isn't configured) and voiced with edge-tts. Rotation avoids playing the same artist twice in a row, and a jingle plays every few songs.

- UI in English and Spanish, and you can add a language by dropping in a JSON file.

**Stack:** Node.js 22, Express, FFmpeg, PostgreSQL (with a local JSON fallback), Docker Compose. HLS segments are written to a tmpfs RAM disk to avoid SSD wear.

**Tests:** 111 unit tests (`node --test`) covering clock and slot math, break composition and anti-repetition, episode progression, EPG generation, radio rotation, and auth/rate-limiting. End-to-end tests of the FFmpeg/HLS pipeline are on the roadmap.

**Quick start**

git clone https://github.com/jjairocj/home-channel-hls.git

cd home-channel-hls && cp .env.example .env

docker compose up -d

Then open `http://localhost:3000` for the player and `/admin` for Master Control.

**Scope note:** it's meant for media you have the rights to: personal recordings, public domain, Creative Commons (the demo uses Blender open movies). There are no scrapers.

**On AI use (transparency):** this project was co-developed with AI coding assistants. My role was mainly requirements analysis, defining the architecture, and choosing the tech stack. I also wrote code, but AI wrote a large share of it, including the FFmpeg pipelines and the automated tests, and it solved several problems I was stuck on or didn't know how to approach. I reviewed the result and defined what the tests should check. The 111 tests are readable and runnable (`npm test`), so you can judge the core logic for yourself.

**Make it yours:** the whole point is for people to use it and adapt it to their own needs: a kids' channel with curated content, a channel of family videos, a 24/7 local radio station, whatever you have in mind. Whether you customize it by hand or with an AI assistant is up to you. That's why the repo ships an `AGENTS.md`, an architecture manual that works for humans and assistants alike. It's MIT-licensed, so feel free to fork it and take it in any direction you like.

This is the first public release, and I'd really appreciate feedback on the architecture, the docs, or features you'd like to see. Issues and PRs are welcome!

---

## 🇪🇸 Español

¡Hola a todos! Les comparto **Home Channel HLS**, un motor de *playout* autoalojado que convierte una carpeta con tus propios videos en un **canal de TV lineal 24/7**. La idea es la experiencia de la televisión de antes: hay una programación, los programas empiezan en punto o y media, y entre ellos salen cortinillas y tandas. No eliges de un catálogo, simplemente sintonizas.

**Por qué lo hice:** la nostalgia es parte, pero el objetivo real es una relación más tranquila con las pantallas. Sí, sigue siendo una pantalla, pero funciona distinto a un feed. No hay algoritmo, ni reproducción automática que te arrastre, ni un catálogo infinito por el que deslizar, ni suscripción. Hay algo al aire: lo ves o apagas. Una programación fija le devuelve forma al tiempo: los programas empiezan y terminan, y "qué dan a las 8" reemplaza 40 minutos decidiendo qué ver. Es un intento de hacerle frente al *doomscrolling* y a la sobreestimulación constante a la que nos acostumbramos, usando contenido que ya tienes.

**Un poco de contexto sobre el repo:** el repositorio público se creó apenas ayer, pero el proyecto no es nuevo. Empezó como un proyecto privado y local, solo para mí, y llevo más de un año trabajando en él. Después de conversarlo con algunos amigos, decidí abrirlo para que cualquiera lo use. Aproveché para separarlo de mi configuración privada y mejorar las prácticas de desarrollo (documentación, tests, Docker). Por eso el historial público empieza con un solo commit.

**Qué hace**

- **Stream HLS continuo** (`/live/channel.m3u8`) de arranque rápido, que funciona en el navegador, VLC, Kodi, TiviMate y apps IPTV de Smart TV / Android TV. También genera una playlist M3U.

- **Franjas alineadas al reloj:** los programas arrancan en `:00` y `:30`, así que la parrilla no se desfasa durante el día.

- **Compositor de tandas:** rellena los espacios entre episodios con cortinillas tipo "Estás viendo…", comerciales que no se repiten, identificadores del canal y avances de "A continuación…".

- **Gráficos y voz dinámicos:** carteles SVG generados al vuelo y anunciados con TTS (edge-tts local o ElevenLabs).

- **Parrilla semanal por reglas:** planificador drag-and-drop, avance automático de episodios diarios, maratones de fin de semana, programación imprimible en PDF y exportación **EPG XMLTV** (`/epg.xml`).

- **Aceleración por hardware:** NVENC, VAAPI/QuickSync, VideoToolbox, o `libx264` por CPU como respaldo.

- **"Master Control" web:** monitoreas la salud del stream, cambias lo que está al aire, gestionas la cola de transcodificación y ves estadísticas de audiencia.

- **Modo radio estilo FM:** emisora HLS de solo audio con un sintonizador retro Hi-Fi de los 90 (dial analógico, display RDS) y un locutor automático. Sus presentaciones las escribe un **LLM local vía Ollama** (con plantillas de respaldo si Ollama no está configurado) y edge-tts les pone la voz. La rotación evita repetir el mismo artista dos veces seguidas, y suena un jingle cada pocas canciones.

- Interfaz en español e inglés, y puedes agregar un idioma solo con un archivo JSON.

**Stack:** Node.js 22, Express, FFmpeg, PostgreSQL (con respaldo local en JSON), Docker Compose. Los segmentos HLS se escriben en un disco RAM (tmpfs) para no desgastar el SSD.

**Pruebas:** 111 tests unitarios (`node --test`) que cubren la matemática de reloj y franjas, la composición de tandas y la anti-repetición, el avance de episodios, la generación del EPG, la rotación de la radio y la autenticación con límite de intentos. Las pruebas end-to-end del pipeline FFmpeg/HLS están en el roadmap.

**Inicio rápido:** los mismos 3 comandos de arriba, y luego abres `http://localhost:3000` (reproductor) y `/admin` (Master Control).

**Alcance:** está pensado para contenido sobre el que tienes derechos: grabaciones propias, dominio público, Creative Commons (el demo usa películas abiertas de Blender). No incluye scrapers.

**Sobre el uso de IA (transparencia):** este proyecto fue co-desarrollado con asistentes de programación con IA. Mi rol fue principalmente el análisis y la definición de requerimientos, la arquitectura y la elección de tecnologías. También escribí código, pero buena parte la escribió la IA, incluidos los pipelines de FFmpeg y las pruebas automatizadas, y resolvió varios problemas en los que estaba atascado o que no sabía cómo abordar. Revisé el resultado y definí qué debían validar las pruebas. Los 111 tests se pueden leer y ejecutar (`npm test`), así que cualquiera puede juzgar la lógica central por sí mismo.

**Hazlo tuyo:** la idea es que la gente lo use y lo adapte a lo que necesite: un canal infantil con contenido curado, un canal con los videos de la familia, una radio local 24/7, lo que se te ocurra. Si lo personalizas a mano o con un asistente de IA, es decisión tuya. Por eso el repo incluye un `AGENTS.md`, un manual de arquitectura que sirve tanto a personas como a asistentes. Tiene licencia MIT, así que eres libre de hacer forks y llevarlo en la dirección que quieras.

Es la primera versión pública. Me encantaría recibir feedback sobre la arquitectura, la documentación o funciones que les gustaría ver. ¡Issues y PRs bienvenidos!

I've been building OpenTubeX, a YouTube client for Windows, macOS, Linux and Android, with experimental iOS builds. You can watch without ads or a Google account, and your subscriptions, playlists and history stay on your device unless you turn on sync.

Most of the code is written by Claude Code and Codex. My part is deciding what goes in, testing it, and sending it back when it's wrong. Every change also has to pass an end-to-end test suite before it gets merged.

Some of the things it does:

• Subscribe to channels without an account and group them into profiles
• Choose per channel whether videos, Shorts, live streams or posts show up in your feed
• SponsorBlock and DeArrow
• Per-channel playback speed and quality, custom shortcuts, skip silence
• Tabs, a queue, and a mini-player that keeps playing while you browse
• Themes and a configurable Home page
• Optional sync between devices, end-to-end encrypted on a compatible server
• Plays from other sites yt-dlp supports too

It's still in beta. You can get it as a Flatpak, Snap, the AUR, WinGet, Homebrew and more, or on Android through our own F-Droid repo or Obtainium.

• Source code: https://github.com/OpenTubeX/OpenTubeX
• Downloads: https://opentubex.org/downloads/

Happy to answer questions, including how building it with agents has gone.

I maintain WorkStep, an open-source workspace for individual developers and small teams using coding agents. It lets you connect planning, implementation, testing and review steps, pass outputs between them, and wait for a person at configured review points.

Project data and execution records are stored locally. This does not mean external model calls stay offline: engine and provider network policies still apply. You configure and authenticate the execution engine yourself.

The repository has real screenshots of engine setup, a completed two-step task and manual review: https://github.com/xzregg/workstep . The desktop packages are unsigned early access; model service fees are separate.

I would appreciate feedback on whether those examples make the input/output handoff clear, and what you would need to inspect before trying a workflow on a small project.

Description:

NetPulse watches all your home network in one place: which devices are connected, how the routers and link together, and where to look when something breaks. It is FOSS licensed under AGPL-3.0, mainly aimed at home networks running OpenWrt (but wait).

Current features include:

- Device discovery and topology maps using FDB, LLDP and SNMP, including Proxmox hosts and VMs.

- Per-router CPU, RAM, temperature, uptime and per-port traffic, plus firmware updates for vanilla OpenWrt.

- WiFi and roaming details, including signal, bands, events, channel analysis and 802.11r.

- WireGuard tunnel status and AdGuard statistics. Also test periodically your internet connection.

- Alerts through Web Push, ntfy, Telegram or webhooks.

- Home Assistant integration over MQTT and a read-only MCP server for AI clients.

There is also an experimental 19-inch rack view under Labs that suggests equipment layout and cabling.

Also (NEW) we have vendor integrations, which live in a separate repository and currently cover MikroTik/RouterOS and Asuswrt/Merlin.

Repo: https://github.com/gnacho/netpulse

Web with features and demo: https://netpulse.cloudless.club/

Why here:
I posted this (almost) same post on r/selfhosted, and without denying that AI assisted me (but I did not vibe code) I got insults, downvotes and a very rude treatment. For anyone who wants to see the thread:

https://www.reddit.com/r/selfhosted/comments/1xh1t4f/comment/19rry81q7gtb6/?context=1&screen_view_count=2

Well, if that is the deal, that's on them. They are going to end up very alone.

I've been really into the AI phone agent products that have popped up in the last few months (e.g., AgentPhone, Poke etc) but what I don't love: the audio, the transcripts, who you talked to and what was said, all sitting with a third party company. For calls with real people in my life, that felt like a lot to hand over.

So I built my own version that runs entirely on my Mac. You call a normal phone number, a local model answers, and nothing about the conversation leaves my machine. During a call the only thing it talks to is the phone line itself.

What's running locally (MLX on Apple Silicon):

• Speech to text: Parakeet TDT 0.6B
• LLM: Qwen3.5 4B by default (9B if you have 32 GB), 4-bit
• Text to speech: Kokoro 82M

How it reaches the phone network: it registers over SIP with Telnyx or Twilio straight from your Mac. A setup wizard takes your carrier API key so can buy a number or connect one you already have. It's pretty cheap, around $1 a month per phone number. (I'm moslty using Telnyx)

What it does today:

• Answers and places real calls
• Interruption: talk over it and it stops mid-sentence
• Replies in roughly 1 to 1.5 seconds on real calls on my M5 Pro
• You can choose between multiple models
• Other agents (Claude Code, Codex, etc.) can make calls through a small CLI: call, listen, say, hangup
• If you'd rather trade privacy for a smarter brain, it can also use your own endpoint or the Claude or ChatGPT subscription you already pay for. Local is the default. So no additional monthly payments for AI Phone tools if you have a sub.

Limits, up front:

• macOS on Apple Silicon only
• You need a Telnyx or Twilio account with credit (a US number is about $1/month, standard call rates do of course apply, but Telnyx gives you $10 dollars for free when you sign up, which is enough to play around with)
• English only, one call at a time
• It's early. It works for me, but I'd love to hear where it breaks for you. please feel free to report as many gh issues as you want. I'm also working into best practises for contribution for anyone who wants to contribute to the project!

Repo: github.com/oxnw/ai-phone

https://reddit.com/link/1xh9mug/video/e5tuz2zqq3yh1/player

Short demo of Cygnus, the open source app store and manager for CachyOS and KDE Plasma, choosing the install drive per app. Useful with a small SSD and a big HDD. Public beta v0.2.0, GPL-3.0. Repo: https://github.com/AbdulazizOmran/Cygnus

A thousand stars tells me people noticed a repo. It doesn’t tell me whether its skills work for my task, model, or deeply unfortunate edge case.

I’m building skillEd around repeatable evaluations and before/after comparisons: https://github.com/DeadHead04/skillEd

What evidence actually earns your trust when you install a skill?

I’d love issues suggesting useful checks, or PRs improving the examples. And yes, stars help people find the project. Discovery and proof can be different jobs.

Hi! openGym is a gym tracker I built because I wanted my training data to stay with me. It started as a side project and now has 16,000+ stars on GitHub, about 1,900 people in our Discord and a 5.0 rating in the App Store.

• Log sets in a few taps; rest timer on the Lock Screen with Log set, Skip rest and Next exercise
• Apple Watch app: countdown, heart rate per set, RPE/RIR on the wrist, Water Lock
• Plans by weekday or as a rotation, 5,600+ exercises with animations, a body map for every routine
• Records, charts, body weight trend, Apple Health sync, imports from Strong, Hevy and FitNotes
• Pick your own app icon (9 of them)
• Works fully on the phone, no account; connect your own server if you want sync
• Open source (AGPL), no ads, no subscription
• Until Halloween: spiders, bats, a witch and a hidden pumpkin (you can turn it off)

App Store: https://apps.apple.com/app/id6822275400

GitHub: https://github.com/DuarteSantos8/openGym

Discord: https://discord.gg/e62jY6fwVb

Full disclosure: I build openGym with a lot of help from AI coding tools; every change goes through review and about 7,000 tests, and a big part of the features came from the community.

Feedback very welcome, and if you like it, a review helps a ton 💚

VirtoMir: Open-source, web-based VM management panel for KVM QEMU libvirt (self promo)

Hello,

I’d like to introduce my hobby project, VirtoMir.

Links for those who would like to take a look:

Live Demo: https://onurbaydas.github.io/VirtoMir/demo/ (contains dummy data)

GitHub: https://github.com/onurbaydas/VirtoMir

My blog post: https://onurbaydas.com/posts/virtomir/

VirtoMir is an open-source control panel for managing KVM/libvirt virtual machines on Linux servers via a web interface. My goal was to create a tool that is as user-friendly as Cockpit, but with a deeper focus on virtualization-specific features.

I won’t try to hype up VirtoMir—especially when giants like Proxmox and Incus exist; that’s not my intention. Essentially, you install a single program and can then access the control panel at `localIP:8420`. Most core features are already implemented and supported. So far, the project has received 2 contributions and 4 stars on GitHub.

I’ve been developing the project using AI agents, which has allowed me to write a large amount of code in a short time, bringing it to an advanced stage on paper. However, due to resource limitations, I haven’t been able to test it on bare-metal systems. Currently, I’m testing it by configuring Linux VMs—running on my own machine—as nodes, but I don’t consider these tests sufficiently reliable. I definitely plan to conduct tests on bare-metal hardware; for instance, by installing Linux on older PCs with varying hardware specifications, setting up a cluster, and verifying the core functionality. Any help, support, or even just feedback—positive or negative—from those interested in this field would be incredibly valuable.

Advanced features like clustering, Ceph, HA (High Availability), and DRS (Distributed Resource Scheduler) have been tested and appear to work within a VM environment. However, given that these are complex features and the code was developed with the help of AI, their reliability is currently unproven. To ensure this doesn’t just become another "AI-slop" project, it is essential to test these features on bare-metal hardware, monitor their performance, and document any bugs or shortcomings.

Moving forward, I plan to pause the addition of new features to focus on solidifying the project's stability on a single-host setup. Key features include console access (SPICE, VNC, etc.), support for backup systems (Veeam, Commvault, Veritas, etc.), email-based alarm notifications, and the ability to modify resources for running virtual machines without shutting them down.

I am sharing this here to gather feedback from those who develop open-source projects, wish to contribute, are simply curious, or have any constructive criticism—positive or negative.

Thank you for reading.

Processing img xvjy8sbq5zxh1...

Processing img 9tntn6oq5zxh1...

I built a desktop app to manage my SSH config without the usual GUI-editor problems: reformatted files, lost comments, or a broken config after a bad save.

Every save:

• changes only the lines you edited. Comments, order, indentation and line endings stay.
• is checked with ssh -G first. If OpenSSH rejects it, nothing is written.
• backs up the old file and replaces it in one atomic step. History shows a diff of each backup and can restore it.

Also: lists your SSH keys and which hosts use each one, makes new Ed25519 keys, turns hosts off without deleting them, handles Include files, and groups hosts.

No account, cloud or telemetry. Rust + Tauri 2, plain JS UI with no build step. Builds for macOS, deb/rpm/AppImage (x86_64 + ARM64).

AI use: Built using Claude Code as a pair programmer. I designed it to solve real pain point for manaing ssh hosts and reviewed every change. The parser is tested against real configs.

It’s early (v0.1.1). I’d like feedback, especially if you have an unusual config that breaks it.

https://github.com/react-iot/ssh-cfg-mgr

Hi guys, I’m not the member but, I’ve seen what has happened with the other sub, and it’s unbelievable, but “unbelievable” leads to an article in the The Verge. That’s a #WIN in my books…The Verge link.

https://github.com/AnkitKumarDhal/ariaWatch/releases/tag/v0.3.0

Hello everyone!
I've been working on this TUI download manager based on aria2, because well i tried finding the lightest and fastest download manager, but i couldn't find anything better than aria2 in the terminal. I tried a few TUI options for it but i couldn't find any modern TUI (anything that didn't look it was from the mid 2010s) so i tried to make one myself.

It started out as a simple monitor for an already running aria2 server, but with this v0.3 release, it turns into a full-fledged download manager, with support for:

• adding download URLs directly, even magnet links are supported
• adding .torrent files
• keeping history of downloads
• download actions (pause, resume, remove, delete)
• information about the download
• able to monitor a pre-existing aria2 server

I'd love for people to try it out and give feedback on what issues they face, and what things can be improved. Do give it a try! The binary release is for Linux x86_64 only for now,,, with other OS's support planned for future releases.

About the other TUI's looking from mid-2010s claim,,, mine doesn't look any better either, but its still in the very early stages, and v0.5 is going to be a major UI overhaul with a UI that i have planned beforehand hehe :3

Thank you!

I'm the original author - now AI enhanced :-)

https://github.com/pglombardo/PasswordPusher

You can self host, use a 1-click deploy or try https://oss.pwpush.com.

Possibly helpful:

• Trust is a concern. Why should I trust and use Password Pusher?

• What are the potential security risks of running my own version internally?

I wanted to join TeamSpeak servers from any device without installing anything, so I started building a browser client at the end of July. Three months and ~330 commits later it’s usable enough that people I don’t know are using it, and some are even self-hosting it.

How it works: the browser can’t talk TeamSpeak’s UDP protocol, so a small gateway runs one Rust connector per user and bridges WebSocket ↔ TS3. Voice, chat, whisper, file transfers and permissions work. You can also use themes and an account sync with no email (Mullvad-style number + optional password).

Almost all the code was written by Claude Code. My part was deciding what to build, testing it against real servers and phones, and saying “no, that’s wrong” a lot. The hardest bits were the handshake and a voice server that sends commands out of order.

MIT licensed, self-hostable with one Docker container.

Try it: https://client.webspeak3.de (or the demo: https://demo.webspeak3.de )

Code: https://github.com/WebSpeak3/webspeak3

Happy to answer questions, including how the AI part actually went.

I needed to keep the same business rules running on different targets. AI wasn't solving it consistently, and the solutions I found were too complex to integrate into the lightweight pipeline I was already using. So I ended up building my own some months ago.

Today, JSOL ( currently v0.2.97 ) keeps my AIs in check while compiling 70+ examples and even itself to JavaScript, TypeScript, PHP and Python.

JSOL uses a deliberately simple syntax, a set of standard functions designed to remove ambiguities between languages, and contracts to ensure the compiled code produces the same results on every target.

Should you bother learning it? Probably not. But you don't have to learn it: you can point your AI to the language spec and let it do the work. What you get in return is a pipeline that verifies the result is still bit-for-bit identical across every target.

If you need to maintain business rules across several targets, give it a try.

That’s it. That’s all I gotta say for now :-)

Hello everyone, I'm a CS undergrad researching on making better Indic keyboards.

I've been programming in various languages for a long time now. Still, for this project, I had to think through a lot and had to use LLMs as mentors, because the topic was sitting right in the middle of Linguistics, HCI and Theoretical Computer Science.

Edit: I accidentally clicked post, here are the links:

Please start from here: https://triangulatedexistence.mataroa.blog/blog/a-starter-guide-to-taravinyas/

For understanding the mathematical model further: https://triangulatedexistence.mataroa.blog/blog/making-a-mathematical-model-for-better-indic-keyboards/

I also made a preprint, but the boolean framework is slightly outdated now: https://doi.org/10.5281/zenodo.20467634

hey everyone! i believe our reddit communities probably have quite a bit of overlap, so i just wanted to share some of the new rules/tooling that we're implementing at r/TrueOpenSource to deal with "slop", reduce duplication in the OSS community, and take another step toward a world of OSS dominance and sustainability. i wish you all luck here and hope you find this helpful!

I had just released Naughty Keyboard, it's a tool for testing input fields, the design is simple.

The app comes with values packs, each value pack is a set of problematic data, with one shortcut we can write the problematic data, with other we can switch the pack, the app is cross-platform, full GUI + CLI (there is nkb emit, so we can export the values and use in own tests form the code). Like the project? Please give it a star. GitHub If you got any questions, features requests feel free to share them :-)

Right now there are 208 values, and packs like export breakers, extreme numbers, some specific data, in the future there are plans for 1000+ values, you can read here: full list of packages. Like I said it's simple, keep it in background, use when needed, in the feature I will expand the ability for creating own packages and shortcuts, let's say we would automate whole input fields on website with one shortcut :D And I think the tool can automate some boring work too, because right now I'm using the copy/write mode for testing values, but if in easily way other pepole could create own packs for work, so there is potential.

I won't lie that all works perfect, I tested it on systems I got, but there are some known bugs that I'm fixing right now :-)

Please, don't ask me about some girls emojis or anything like that, the "naughty" in the name is in sense of "testing" not some girl things :( You now like a big list of naughty strings.

Full features list:

• One shortcut, one value - Alt+Shift+N (Option+Command+N on macOS, Ctrl+Alt+N on Linux) clears the line and types the next value of the current pack into whatever window has the keyboard. Previous and restart are one chord away, and every chord can be changed.
• Values that explain themselves - each one carries breaks (what it usually breaks, and why) and expect (what a correct application does). The pack file, nkb show and the report block all say so.
• Invisible characters made visible - the palette draws one as a marker, ␣, instead of showing nothing, and counts every value four ways: graphemes, code points, bytes and UTF-16 units.
• Know where you are - the palette shows the value that comes next and a counter of how far through the pack you are, and the value window searches the values of every pack at once.
• A bug report in one chord - Alt+Shift+B copies a block for the last value: which value, from which version of the pack, typed as what, how large, and whether all of it arrived. The value is written in a form someone else can type back, never as the marker the palette drew.
• Never takes the keyboard - the palette is a display driven by shortcuts and does not take focus, so the cursor never leaves the field you are testing.
• Clipboard mode - put values on the clipboard to paste yourself, for one window or for all of them.
• Packs you can check - a pack is a plain TOML file, nkb lint checks it against the format rules, nkb fmt puts it in canonical shape, and nkb new-pack writes the skeleton.
• Made for scripts too - nkb emit prints a pack as JSON, CSV or one value per line, escaped or raw, optionally as base64. Every command has exit codes you can branch on.
• Offline, free, no telemetry - GPL-3.0, no account, and it opens no network connection.

The technologi is Rust + slint. And Yes I'm using AI, I'm open about it (we can see Claude at PR, contributirs + there is note about ai-assited workflow).