Hey everyone,

Whenever I tried using any time tracking or wellbeing tool on Linux, it always had the exact same headache with gaming: Proton games showed up as steam_app_XXXX or wine64-preloader, and if any tool tried to enforce a session timer, it would just fire a blind SIGKILL that left zombie wine processes hanging or risked corrupting save data.

I’ve been working on an open-source project called ScreenGuard to fix this for my own setup, and wanted to see how other folks here handle it.It is also a daily life digital wellbeing software (check this post: here) how ever with the recent v0.1.1 i have been addding gaming support and session monitoring for games. You can actually also use this AS a focus mode system for games as i found out, by marking other apps in the focus list. and turning on do not disturb i your de has it (mind you i am going to add do-not-diturb to screenguard natively also later)

A few things I had to solve that I’m curious to get opinions on:

Mapping AppIDs to real titles: Ended up parsing local Steam library .vdf manifests so the tracker resolves actual game titles and icons rather than raw process names. Anyone know if Heroic or Lutris store manifests similarly if I want to expand beyond Steam?

Exiting fullscreen cleanly: Turns out many games completely ignore minimize requests while running borderless/fullscreen under Wayland. Had to force un-fullscreen before minimizing.

Closing Proton cleanly: Instead of standard process termination, I wrote a small C helper that does an escalating close: polite window close request first, grace window to save, then falling back to wineserver -k per WINEPREFIX so it cleanly wraps up Wine without leaving garbage processes in the background.

Curious if anyone else here actively limits/tracks their gaming sessions on Linux, and what your experience has been with Proton handling window signals or background process cleanup?

Repo is here if anyone wants to look at how the process handling / manifest parsing was done:

https://github.com/adityakrishnan005-a11y/ScreenGuard

(Available as .deb, Fedora Copr, and universal tarball. Working on AUR packaging right now).

Would love any feedback or edge cases from folks running different distros/setups!

NOTE: Currently it is supported only on GNOME wayland and x11 distros like cinnamon i3, other distros can also use it if it has x11

Whether you make use of AI or not, ​if you do believe in open​ software, we would be honored to have you on board. We are not a cult subreddit​​ —we do have a simple​ belief: open source = open source. If you're not Shakespeare itself that's fine, we don't ban based on immaculate English proficiency​ (also something r/OpenSource does)

Welcome.

TL;DR: It's yours. Do something awesome with it.

That's the opening statement of a software license I've been developing.

It's called the tl;dr: license, currently version 1.6.

The serious part is simple:

Use it. Modify it. Sell it. Share it.

If you separately distribute modified software, keep the source freely available under the same license.

Website hosting and ordinary browser delivery are unrestricted.

Nobody needs permission from the original creator to continue developing or distributing the software.

Then the warranty disclaimer got a little out of hand.

"If the software begins modifying you, please document the changes before your objectivity becomes compromised."

"If causality is affected, submit your bug report before the incident."

"If civilization collapses, please preserve the source code for future generations."

"If the collapse is reproducible, DO NOT ATTEMPT TO REPRODUCE IT."

The complete license is published here:

https://shogi-training-room.neocities.org/license.html

It's free to read, download, and adopt.

The license was developed with AI assistance and hasn't received independent legal review or OSI approval.

Serious criticism is welcome. So is laughter.

And if civilization collapses, please remember that the developers are no longer accepting pull requests.

Please check Detailed Post

I've been exploring how we can move beyond prompting coding agents through every individual step and instead give them a ticket and a workflow to execute.

That led me to build Agent Control Plane (ACP), an open-source POC built around the Claude Agent SDK.

The idea is to configure a project workflow where a lead coordinates the ticket, implementation agents make changes, and reviewer and tester roles run at configured stages—with human intervention when needed.

The current POC includes:

• A configurable, ticket-driven agent workflow

• Isolated Git worktrees for parallel ticket execution

• A resolver helper for integration conflicts

• Configurable test harness checks for verification

I'm currently exploring two problems:

1. Token efficiency: Different agents can repeatedly explore the same codebase. Would a shared codebase map or a project-level context coordinator help, or would the additional overhead outweigh the benefits?

2. Parallel integration: Isolated worktrees don't eliminate conflicts when branches are integrated. How should we validate the combined changes and determine which checks need to run again?

This is still an experimental POC with rough edges and unresolved architecture decisions. I'd appreciate feedback from people building agentic coding systems, particularly on context management, orchestration and reliable execution.

Repository: https://github.com/keerthivibisan/agent-control-plane

Demo and architecture: https://keerthivibisan.github.io/agent-control-plane

here is a open demo, no login required: https://demo-teagan.benjino.de/

https://github.com/Benjino16/teagan

What this is:
Teagan is a relationship tracker and journal. You log events with friends and family, rate their impact, and get a timeline of each relationship. It's also handy before meeting someone: you see right away what you talked about the last time you caught up. Over time it can help you understand (and maybe improve) your relationships.

What this is not:
It's not a full CRM. No business contacts, no social profiles, no email/messenger sync. Most is entered by hand, on purpose

Why I'm sharing it
I've been using it myself for a while and decided to clean it up, publish a Docker image and maintain it publicly. The database schema is designed carefully, and I follow semVer, meaning no breaking changes within a major version.

Not there yet (roadmap) but might be important:

• currently there is no vCard import, data must be entered by hand

• no option to export data as json

• no option to import from accuall crms like monica

What are mentionale other personal crms (that are fully open source and selfhostable)?
But more focused on work and business contacts.

Monica https://github.com/monicahq/monica

Bonds https://github.com/naiba/bonds

Meerkant CRM https://github.com/fbuchner/meerkat-crm
It has a demo (without login): https://meerkat-crm-demo.fly.dev

mini-AGI - is a continual learning byte-level language model that assembles its own architecture, trains from scratch on a single 8 GB VRAM GPU, and keeps learning from everything it reads. It stores its weights as ordinary files on disk and pages them onto the card as it needs them, so the parameter count is bounded by free disk space rather than by VRAM. It grows new capacity while training when it runs short, prunes what nothing asks for, and reads through exactly the same code path it serves on. Targeted at a PC or laptop with at least an 8 GB VRAM GPU on the board.

All technical details, weights and benchmarks are available on the github page.

The project is heavily AI assisted. And I am pretty sure a project like this would be practically impossible without heavy use of AI or thousands if not millions of dollars spent on research. And there is no interest for any big company to work out something like this, as it gives complete control and privacy to the end user without any commercial potential to eventually monetize the project.

A simple tool to use pi safely as an embedded component. pi-glovebox doesn't come with a sandbox attached. The security model is simple: you set up your own sandbox, run the actuator end (pi-glovebox-server) inside it, and launch your Pi with a configuration that tells where the server is reachable.

Fully LLM-generated code, mostly LLM-generated README, carefully thought through and supported by tests. Made with AI, for AI users. What doesn't change a tiny bit is that I'm still human, you're still human, the people we work with are still human, and we write and run computer programs to make human lives better.

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

So r/fossdroid decided to follow the same exact rules with the opensource sub.

And they actually copy pasted the same rules for their sub so ppl including me, said their piece about it. U can see my comment in the screenshot. And a few minutes ago I just got a message that Im banned 😂😂

I asked what is the reason for banning me and which rules I broke and I'm waiting for a reply

Btw, Im neither pro or against AI. If it works for what I wanna do I will use it, if it doesnt I wont.

But this Hitlerism in 2026 is amazing. The great minds of the past that fought for us to enjoy free speech would be really sad and disappointed with our evolution as a species 😎

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.

I built Ledge, a small native macOS menu-bar app (Swift/AppKit) that works as a temporary shelf for files.

• Shake a drag to open a shelf, drop files on it, then drag them out wherever you need them.

• It has a built-in image converter. It reads HEIC, JPG, PNG, GIF, TIFF, WebP, PDF and more, and writes WebP, PNG, JPEG or GIF.

• You can ignore specific apps or file types so they never open a shelf. The newest version also has a toggle to ignore dragged text snippets.

• It's about 3 MB on disk and runs entirely on your Mac. The only network feature is an optional iCloud Drive link.

• The license is Apache 2.0.

Install:

brew install --cask NeeL21YT/ledge/ledge

You can also download the DMG or build it from source. Repo: https://github.com/NeeL21YT/Ledge
Check us out on ProductHunt: https://www.producthunt.com/products/ledge-7
Our Website: https://galaxanticstudios.com/

Caveats: the download is Apple silicon only (Intel Macs can build from source) and needs macOS 13+. It's ad-hoc signed, not notarized, so the Homebrew cask clears the quarantine flag for you. Feedback and issues are welcome.

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.

Short demo of installing a .deb package in Cygnus on CachyOS. Public beta v0.2.0, GPL-3.0. Repo: https://github.com/AbdulazizOmran/Cygnus

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

If you are tired of programming your settings, or debugging runtime errors due to missing environment variables, do check it out:

https://github.com/sayanarijit/settingspec

https://github.com/DeSynkro/discord-notification-scheduler

This was the first very first project I've ever worked on 😄

A self-hosted docker app for scheduling Discord messages using webhooks.

Set weekly alarms or calendar alerts, send text or embeds to any channel, and keep the schedule, history, and webhook URLs on your own hardware.

One Docker container, plain JSON, no telemetry.

Why this exists

It's a funny story why I came up with this in the first place. My sister in law was working on her portfolio, and she asked me to remind her every day for her to do her portfolio because she needed it done.

After the first three days, I got tired of messaging her. So I did what every normal person would do... I started working on this app to do it for me.

Now I have a Discord Webhook set up on her server tagging her every single day for her to do her portfolio. 😂 😂 😂

There are plenty of hosted services that can trigger webhooks on a schedule.

But they require trust. Trust that your webhook URL wont be logged, trust that your messages aren't read, trust that the service will be around next month and wont charge you a fee for it.

This project says "get stuff" to all that. You run it on your own machine, your own network, your own terms. No signup, no API keys to a third party, no vendor lock-in.

Just Docker and a JSON file you can copy with one command.

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.

About 10 days ago I released an open source alternative to paper (https://github.com/tidydesigns/tidy)

Since then we got 50 users and 34 stars. It’s a humble start but I’m super excited about this project.

We’re trying to reduce the friction between design and engineering.

Since the 2 roles are becoming more tightly coupled we think there’s lots of unique ideas we could implement here !

Project Name: Valence

Repo/Website Link:
https://github.com/ValenceOSS/Valence
https://getvalence.app
https://docs.getvalence.app
https://demo.getvalence.app

Description:

Valence is a self-hosted streaming platform for your own library, along the lines of Jellyfin. It handles films, shows, anime, music, books, manga and audiobooks. The difference is that it's meant to be an all-in-one setup. If you want, it can replace the rest of your usual stack (Seerr, Prowlarr, the *arrs), or it can plug into the stack you already run. All of that is optional and off by default.

You point it at your folders and it pulls in artwork and details. Your media is mounted read-only, so files are never renamed or moved. Each device gets direct play where it can and a transcode where it can't, and HDR stays HDR. It can also make lighter copies overnight for slow connections, detects intros and credits so you can skip them, and fetches subtitles from OpenSubtitles and SubDL.

It's built for a whole household. Everyone gets their own profile and history, with passkey and two-step sign-in. You add people with a setup link, so you never handle their passwords, and you can control who sees which libraries. You can hold watch parties, or send a single title to someone without an account. Requests for films, shows, music and books are built in. If you'd rather keep Radarr/Sonarr/Lidarr, Prowlarr or Overseerr/Jellyseerr, it works with them instead. Setup can import your accounts, watch history, playlists and *arr settings from Jellyfin, Emby or Plex, and it only ever reads from the old server.

To be honest about where it's at: Jellyfin is great and 12.0 was a solid release. If you need Live TV, Roku, Android TV or something battle-tested, stick with Jellyfin for now. Valence runs on web, desktop, Apple TV, and iOS and Android (the mobile apps are in store review). It's young, so please don't make it your only copy of anything yet.

Deployment:
There's a Docker image and a compose file in the GitHub repo, and the setup walks you through the rest. Docs are at https://docs.getvalence.app, or you can try it first at https://demo.getvalence.app

AI Involvement:
Roughly 80% of the backend and 20% of the frontend code was written with AI tools. My day job is frontend engineering, with some TypeScript and Java on the backend, so AI covered what I don't know as well and let me build this in my free time. I designed and review everything, and every change goes through CI with type checks, linting and tests.

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

Hey all. A few weeks back I posted Ettin Edit, a clean-room, Notepad++-inspired text editor for Linux and Windows. It's grown up a fair bit since then, so here's an update.

Quick recap: it's free, MIT-licensed, written in Rust with egui, and contains none of Notepad++'s code. It's aimed at people who spend their day turning one system's output into another system's input: logs, CSV and JSON exports, Excel workbooks, XML, HL7 messages.

The big new thing is tables:

• Open an Excel workbook, CSV, JSON or XML export, or a file of HL7 v2 messages as a table. Think spreadsheet, but for structured data. Columns are typed, and dates are read the way they were written (DD/MM/YYYY stays DD/MM/YYYY).

• Every change is a step. Filters, sorting, renames and value clean-up all show up in a Steps panel, where you can switch any of them off or change them later.

• Nested data works too. Pick which list in a JSON or XML tree becomes the rows and the fields above it come along. There are also Explode into Rows and Flatten Objects steps.

• HL7 is readable. One message or one result (like OBX) per row, and pointing at a column tells you what PID.5.1 actually is.

• Export it however you need it. CSV, .xlsx, nested JSON, YAML, XML, Markdown, or HL7 messages from a template.

• Save the steps as a recipe and run them again on next week's export, even from the command line.

Everything else is still there:

• A Transform menu with previews before anything changes: pipe through a shell command, keep or drop matching lines, convert between JSON, YAML, TOML, XML and CSV, escape strings, turn Unix times into dates, hashes, JWT decoding and a lot more.

• The Notepad++ plugins I always installed are built in: CsvQuery (SQL against your CSV), a compare view, JSON tree and XML tools.

• Plugins in Python or JavaScript, your pick.

• A proper editor underneath: multiple carets, column mode, split view, folding, macros, regex find/replace, find in files, hex view.

• 2.8.1 also fixes Bangla, Hindi, Tamil, Thai and other scripts showing as boxes.

• Packages for pretty much everything: Arch, .deb, .rpm, Flatpak, AppImage, tar.gz, and a Windows installer or zip, with a built-in updater.

Same disclosure as last time: this is still 100% vibe coded. The AI writes the Rust, I type "no, not like that," and somehow it now has opinions about HL7. The two-headed giant mascot remains the only member of the team who reads the code.

Release: https://github.com/Tharkis/Ettin-Edit/releases/tag/v2.8.1

Repo: https://github.com/Tharkis/Ettin-Edit

Manual: https://tharkis.github.io/Ettin-Edit/

Bug reports and ideas are welcome, especially sample files that break the table view.

**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!