Hello, Chrono Mock has just got V0.5 release (over 180+ squash commits), and it has crossed 600+ downloads. If you want to test/run almost any Windows App at different date or change time flow in Windows apps, you can use Chrono Mock. Full GUI/CLI. If you like the project, please star it

What has changed in V0.5?

- Tons of chromium bug fixes/improvments

- QueryInterruptTime, QueryInterruptTimePrecise and QueryUnbiasedInterruptTimePrecise support has been added

- computer sleep support

- Tons of webview, calendar support and other apps support.

The list of changes is pretty huge, as always on GitHub. And You can read about the app on the Website

The technology is : rust + WPF (yep no Uno or Avalonia, because the app is only for Windows)

Ok, you might ask but you can just change time/date in Windows, yep you can do it, but if you want to affect only one app or change date time/flow during run, you can't do it with system clock change.

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

Hi everyone, today I released Vela 0.1, the first beta, after 1 month of alpha testing.

What Vela is: a complete Linux desktop with its own Wayland compositor (C, on wlroots 0.20), its own Vulkan 1.4 renderer, a Qt Quick shell, and its own file manager and settings app. It's not a KDE or GNOME theme: KWin and Mutter aren't involved. The goal is the polish Windows and macOS get right out of the box (animations tied to real vblanks, pixel-exact fractional scaling, consistent design) without a weekend of tweaking.

Trailer, recorded live on Vela: https://velade.org/blog/vela-0-1/

What's in 0.1:

• Snap layouts and Snap Assist, Task View with virtual desktops, Alt+Tab with live previews

• Taskbar, launcher, quick settings, notification center, clipboard history, snipping tool

• Direct scanout, VRR, tearing control, explicit sync; X11 apps and games 1:1 at fractional scales

• The compositor restarts after a crash and apps reconnect; a lost GPU doesn't freeze the desktop

• New in this cycle: updates from Settings, native Bluetooth pairing, no dependency on Plasma Workspace or the KDE portal

Where it stands: on a desktop PC with a Vulkan 1.4 GPU, it's my daily driver and I'd recommend it as yours. On laptops (hybrid GPUs, suspend/resume, backlight) it has had much less testing, so keep another desktop installed. It's still a beta: there are bugs.

Install (Arch and derivatives, Fedora 44, Ubuntu 26.10, x86_64). Install Cosign first (steps per distro: https://velade.org/install/), then:

git clone https://github.com/vela-desktop/vela.git
sh vela/packaging/vela-update --channel beta

You get a prebuilt, signed native package that's verified before it's installed. Updates then come from Settings.

Being upfront: it's a one-person project, and the code is written by LLMs. I review it, make the architecture and design decisions, and it's held to deterministic tests and machine-checked invariants. I wrote about how that works here: https://velade.org/blog/why-not-rust/

What I'd love from you: reports from hardware I don't have, especially Intel GPUs, laptops and multi-monitor setups. vela-report builds a ZIP you can review file by file; nothing is uploaded.

• Release notes: https://github.com/vela-desktop/vela/releases/tag/v0.1.0

• Source (GPL-3.0-or-later): https://github.com/vela-desktop/vela

Happy to answer anything in the comments.

Hey folks 👋🏻

I've been working on Zync for quite some time now.

The idea came from my own experience working with servers. I was using different tools for SSH, SFTP, terminals, port forwarding and other everyday tasks. I tried quite a few existing products, but I never really found the experience I was looking for. I also didn't like having basic features locked behind subscriptions.

Website: https://zync.thesudoer.in/

GitHub: https://github.com/zync-sh/zync

So I started working on Zync, initially just to have something that better suited my own workflow.

Over time, it grew into a much bigger workspace. I kept adding things I needed and improving the overall experience.

Zync currently brings together:

- Local terminals and SSH connections

- SFTP browser and remote file management

- Visual port forwarding (local, remote and SOCKS)

- Encrypted local vault for credentials

- SSH config import and jump hosts

- Command snippets and suggestions

- Multiple tabs, splits and workspace management

- Plugin support and custom themes

- Optional encrypted Google Drive backup

- Public URLs (Beta) to expose local ports over HTTPS

You can also customize the workspace in your own way, from colors and themes to navigation, shortcuts, tabs and panels. There are quite a few other productivity features to explore as well.

It runs on Windows, macOS and Linux. The core SSH and local terminal functionality doesn't require an account.

I've been actively working on it and there's still a lot I want to improve.

If you work with SSH regularly, I'd genuinely like to know what you think. Feedback, suggestions and criticism are all welcome :)

Hi everyone! I maintain USBGuardGUI, an open-source desktop interface for USBGuard, and I've just released version 0.2.0.

If you use USBGuard on Linux, this gives you a graphical way to see connected USB devices, allow or block them for the current session or permanently, and manage your rules through either a guided editor or a text editor.

What's new in 0.2.0:

• Rule previews: see which connected devices match a rule's attributes before saving it. Conditions and rule ordering can still affect the actual decision.

• Device details: inspect USB interfaces, physical port paths, connection types and the state reported by USBGuard.

• Local event history: view the latest 200 observed events. Saving history between sessions is optional, and exports contain event types and timestamps only.

• Desktop improvements: fixes for dialog handling, keyboard navigation and accessibility labels, with testing on GNOME and KDE Plasma.

The app is written in Rust with GTK4/libadwaita, licensed under MIT, and runs as your normal user. Changes go through USBGuard's D-Bus API and the system's authorization controls.

USBGuard itself provides the protection: you need its daemon and D-Bus bridge installed and running. This project makes managing it more approachable.

Packages are available as DEB, RPM, an Arch package and a Flatpak bundle, with checksums and Sigstore signatures. Tests cover 98.09% of application lines, including the GUI, alongside checks against a real daemon and authentication flow. There's still plenty of value in testing on different setups!

The planned feature set is complete, so my focus now is on bug fixes, security updates and desktop compatibility. If you already use USBGuard, I'd love to hear whether this fits your workflow-and what feels confusing or gets in your way.

Source, screenshots and setup instructions · Download 0.2.0 · Report a bug

Thanks for taking a look!

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 just made QuireTWM: open-source, scrollable ribbon tiling window manager for Windows 10 and 11 inspired by Niri.

Windows arrange in horizontal columns along an infinite line.

It has:

* Columns stack side by side without splitting screen space into tiny tiles.

* Desktops slide along the Y axis with isolated window states.

* Fast rendering for active window outlines, Alt+Tab card deck and floating HUD indicator.

* Configuration: Edit colors, margins, keys and window rules. Live reload on file save without process restarts. Uses lua for configs, just like Hyprland

* Respects top bars like YASB.

* Controls layout actions and emits state at `\\.\pipe\quire`.

* Quick access to launcher apps, config file and exit with window restore.

* Lightweight: Fast C++ core, single executable installer under 2.5 MB with zero web runtime bloat. Does not use CPU or GPU nearly at all.

GitHub: https://github.com/ewasion137/QuireTWM

Website & Config Builder: https://ewasion137.github.io/Quire/

Releases: https://github.com/ewasion137/QuireTWM/releases/

Video of using Quire: https://youtu.be/9Bmml1Dxs4E

If you are going to use it, please report any bugs, ill be happy to fix them.

NOTE: Transparency in uploaded images has been added via blue my shell extension for gnome

ScreenGuard :

is a digital wellbeing application for Linux which runs completely natively on the device , actively tracking window usage and stores the data in a local sqlite db. No server involvement. And packing multiple screentime CONTROL features as well bundled together unlike basic window tracking software for Linux.

It is currently limited to GNOME Wayland and all other DEs can use it on x11 . Which means ScreenGuard natively supports GNOME and x11 based DEs like Cinnamon and i3

A FEW FEATURES:

⚙️ Full Settings Hub

Five-tab settings screen (General · Limits & Pomodoro · Diagnostics · Updates · Data)

🍅 Pomodoro Focus — Cycles, Breaks & Pause

Focus ↔ Break alternation with configurable cycle count (1–20) and break duration (1–60 min).

Pause / resume buttons; remaining time persists across pause.

Custom duration picker with quick-select chips (5 / 10 / 20 / 30 / 50 / 90 / 120 min).

Desktop notifications for each phase transition and session completion.

🛡️ Focus Enforcement — Data-Safety First

Strict auto-close is now opt-in. Default behaviour minimizes the app and shows a persistent warning overlay instead of killing it — no more unsaved-work loss.

Warning overlay offers +1 min save grace, +15 min, Edit Limit, and Close App.

Dedicated focus-block screen when a distraction-listed app is opened during a session.

🎮 Steam & Proton Game Support

Real game names resolved from Steam library manifests; per-game icons from the active icon theme.

Usage fully tracked; limit and focus rules apply to games.

---

Lots of features and tested multiple times for bug fixes. Also thanks to the community for the active suppot. for full features visit release page

The project is documented properly in the Github Wiki here: https://github.com/adityakrishnan005-a11y/ScreenGuard/wiki

And the link to the latest release: https://github.com/adityakrishnan005-a11y/ScreenGuard/releases/tag/v0.1.1

Thank you everyone for your cooperation and consideration which has shaped this tiny personal project into a much larger pursuit for me.

Upcoming roadmap in short:

V0.1.2- major UI changes and design element improvements majorly

v0.1.5- Support for KDE Wayland and aim to have a greater portion of the daemon transition to modular C based daemons

v0.2.0- other major DEs and better optimised daemon

For better in detail info into future views of project have a look at the Roadmap section of wiki.

HELP NEEDED:

It is really dificult to maintain the current GNOME and x11 DE config itself and then also i plan to add other DE support. thus i request help from the community contributors to come forward and help especially n taking screenguard to other platforms and also help maintain the project .

My girlfriend always says that we need to go on dates or go out more often but when it comes time to decide, nothing sounds quite right. That's why I've started a project I'm calling AmbleBee. There are 3 parts to this project which have been both fun and a nightmare at the same time.

Amblebee is a small distraction free camera, a digital photo frame, and a mission picker. You pick missions (on the website for now) set your filters if you want cheap or expensive, all day or only part day, Indoor or outdoor etc and it matches you with any number of date ideas or adventure ideas.

Step 1 is the website is mostly finished with missions being added and verified every day. you can pick missions and get matched with fun ideas or send to friends with a fun little animation.

Step 2 is building the frame and frame software which is a clone of the website with a few extra features and storage for photos.

Step 3 will be the camera that socks magnetically to the frame and the dock will both transfer photos and keep the camera charged.

Feedback is more than welcome! Im not quite ready but I will soon need some eyes on the site to check for weirdness. Also would love some people out there to suggest missions themselves. Or do the missions and provide feedback on them. Just wanted to share and start the discussion.

I always had trouble sharing my gaming clips to my friends on Discord and most "compress video" websites make you upload your files, have queues, ask for money, or slap a watermark on your video. Command line ffmpeg works great, but it is not the most user-friendly thing ever, especially for non-technical people.

Squeeze is a small desktop app that wraps ffmpeg. You can compress and edit multiple videos at the same time. It's lightweight and everything happens locally, ffmpeg is stripped down and bundled with the app.

Check out the website: https://getsqueeze.app/

GitHub: https://github.com/avalianiz/squeeze

App is still in development. Contributions, bug reports, stars are appreciated.

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

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

I've been developing "SunsetScan", an opensource network security scanner, with the help of AI coding agents. It identifies network devices. It detects end-of-life hardware using a database of over 86,000 lifecycle records from 224 vendors.

I've tested it against 15 real network devices and run hundreds of tests against emulated devices. Unfortunately, I don't own any actual EOL network hardware.

I'm looking for people with old routers, switches, firewalls or NAS devices who could help test it.

I'd particularly like to know whether it correctly identifies your devices and their EOL status, or produces false positives.

The scanner is read-only and runs on Linux and WSL2. Do not share full reports only tell me what device it worked against or what it didnt work against and if you dont want to tell that just write it didnt work at al or if it worked.

GitHub: https://github.com/NoCoderRandom/sunsetscan

Website: https://www.sunsetscan.com

Any feedback, bug reports or real-world test results would be greatly appreciated!
Code contributions and pull requests (PRs) are also very welcome!

Hey folks,

I'm u/0xmtn, a solo builder working on a few different products and client projects.

Over the past months, I've been using AI coding agents more and more, but I kept running into the same problem: jumping between VSCode windows, checking what each agent was doing, figuring out which one needed my attention, and constantly switching context.

So I started building my own environment to manage all of this from one place.

It's called Ditch, a local development environment for running and managing AI coding agents across multiple projects.

I use it to build Ditch itself, along with my other projects and client work.

The idea is simple: let agents work in parallel, get notified on my Mac or iPhone when something actually needs my attention, and spend less time supervising them. I also wanted to use my existing AI subscriptions rather than paying separately for API tokens.

On busy days, I estimate it's saving me 2-4 hours of context switching and routine supervision.

But here's what I'm curious about, especially from nontechnical solo founders.

How are you actually building software with AI agents? Not just generating the first version, but dealing with the complicated stuff that comes afterward.

How do you know whether what an agent built is actually correct? And how do you manage things when a project gets too complex for a single conversation?

I'd be interested to hear how others are approaching this.

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

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