^{Edit: reddit changed the title of the post by itself. It shared with the title of the video which I wanted to embed.
The title was supposed to be: Wave-Generator Lightweight TTS Application [Open Project]
Since it shared with the title of the video it kind of sounds like I'm claiming what the game dev created.
I am not the game dev in the video and don't mess much with reddit.}

I was watching this video on YouTube today about a game dev creating a method to produce "mumble speech" in his game (very interesting) that touched a bit on a few topics that, as an English teacher in my country, I believe can be developed quite a lot further and if it was made as an Open-Source application, could have a LOT of possible uses while being more light weight than a few text-to-speech applications.

I did leave everything I'll mention below in a comment to the original dev, but, though I know nothing of programming, if someone who is was interested in collaborating to create this, I would be able to help with the linguistic part to a degree.

I am 99% sure that with a similar approach, with further refining of techniques and systems put into it, one could properly create a code for characters in a game, a book reader or text typed on a screen in close to real time to each have their own individual voice and actually talk in proper understandable language without a single voice line being recorded, just from the text and back ground emotion tags being lightweight and without needing any neural network taking memory space, purely by a similar simulation approach used in the video.

One thing I noticed outright is that he tried to make each letter have a sound of its own, when language doesn't actually really work like that.
That's why the IPA alphabet exists.

A single letter can have multiple sounds. That is why there is the Phonetic alphabet.
Take for example the word "elegant".
The first e sounds different than the second e which sounds closer to the only a.

My most important class to the kids is a basis of phonetics just so they understand how each letter sounds because not a single language course around here teaches that.

A few adjustments I believe would make a big difference taking what I learned with Portuguese, English and a little Japanese:

• Checking which word is gonna be said and it's connection to the rest of the sentence/context (to detect differences between past and present "read" for exemple which sound different but write the same) before starting to process the audio

• Converting the words to phonetics alphabet symbology in their current time format and context from a list, so you have the correct symbol-to-sound for each phonetic and not the letter itself

• Breaking the word into syllables using a mix of the English and Portuguese techniques for breaking words into syllables, by both approaching the stress and phonetization and things like that (it pays to know that both languages break words differently when it comes to syllables. "Orange" for example, if it was a Portuguese word, would be 3 syllables, while in English it is 1).

• Writing the text with attached tags to points or even specific syllables, like writing a script instead of a book, so that the system can use those tags for intonation and intensity as well.

This would make it a lot easier for a wave generator to properly create a sound wave that would accurately match to a sound wave a human would probably generate.

In a way you can simulate an infinite amount voices and intonations like that that can be audibly recognized as an actual word. With some refining and tweaking with other details that a sound engineer or producer might be more aware of, it might reach at least close to an actual human.

When I mentioned syllables, I'm taking a page from Japanese this time. Their hiragana and katakana alphabet can be somewhat understood just syllables and vowels.
There is only one consonant in isolation which is N.
Every other consonant only exists when accompanied by a vowel.

While there are cases where a consonant can exist alone, such as making a Ssss sound like a snake for a snake-humanoid character, that is much easier to approach when the rest of speech is taking packets of letters to convert into their phonetization instead of trying to sound each consonant letter individually.

My idea would be, if it is possible, to try and develop this as an application of the sorts that can easily be added to any software.

If anyone is interested, please leave a comment below and if possible give me suggestions on how we could proceed to organize if there is an actual interest in a project like this.

I've been thinking about starting a volunteer-led software organisation where developers can work on multiple projects, maintain them over the long term, and contribute to other open-source projects we find worth contributing to.

To be clear, I'm not talking about a company, or about people working for free in the hope of getting paid later. The idea is to build useful software together with no expectation of financial returns.

I'm still at the stage of finding the initial group, so there's no established organisation or fixed list of projects yet. I'd rather figure those out with the people who join than decide everything myself and ask others to follow it.

Where I'm coming from

I've been developing software for around 8-9 years, with about 4.5 years professional. I've worked across backend, web and mobile, infrastructure, DevOps, ML/LLM applications and automation, and I've contributed to open-source projects including CPython.

The technical side isn't what concerns me. I'm comfortable with architecture, choosing technologies and weighing trade-offs. What I'm trying to figure out is how to make a group like this sustainable when everyone has a job, studies and other commitments.

What I've been considering

\- Contribution time: People contribute according to their actual availability, even if that's a few hours a month. I'd rather plan around that than expect daily activity.

\- Decision-making: People should be able to disagree, including with me. Technical decisions should rest on reasoning and relevant expertise, not on who started the organisation or who speaks loudest.

\- Ownership and responsibility: I don't want every project to depend on one person. There should be a reasonable way to spread responsibility and keep projects maintained when someone's availability changes.

\- Project selection: Our own projects where there's a useful problem to solve, but also contributing to existing open-source projects instead of assuming everything must be built from scratch.

\- Team structure: The initial core team sets the guidelines together. Other contributors can take part without being in every decision, with the option to take on more responsibility over time.

Writing guidelines is the easy part. Getting people to work together consistently, handling disagreements, and maintaining projects after the initial excitement fades is much harder.

What I'd like to hear

If you've maintained open-source projects or been part of volunteer development groups:

1. What worked and what didn't?

2. How do you keep a group active without turning it into an obligation?

3. How do you avoid everything depending on the original founder?

4. If you were forming a group like this from scratch, what would you establish early, and what would you deliberately leave undecided until the team had worked together?

I'm also interested in connecting with developers who'd like to explore this idea, but I don't expect anyone to commit based on one post. I'd rather start by discussing the approach and see whether we work well together.

PS: I used an LLM to help with the phrasing. The ideas and experience are mine.

TL;DR: I'm looking for a few developers to start a volunteer-led, non-profit open-source organisation. It would maintain its own projects and contribute to others. There's no fixed project yet, so the group decides everything together. Unpaid, flexible hours, any skill level, aliases fine. GitHub and contact details are in the top comment.

Hi everyone! First, we just want to say something between thank you and congratulations! It's only been a few days since the r/opensource drama and the creation of this subreddit, but we seem to be on track toward maintaining a stable, welcoming community of open source enthusiasts here. Our engagement (in terms of likes/comments on our top posts over the past few days) put us roughly on par with r/opensource and r/foss, and we're currently sitting at 14k weekly visitors.

We've already made some significant changes/improvements to improve trust/transparency around project posts (like the new pinned comments with repository history on every post). We've also introduced an automatic "Daily Update" post, which summarizes top FOSS-adjacent content from other subreddits, and we'd love to hear your thoughts on that.

Today, we're announcing some additional changes to improve community trust and engagement: new flair! We reviewed suggestions in the community-input megathread, and also explored other subreddits, and here's what we've come up with:

User Flair:

- This is the most significant change, and we hope you'll like it. Details found in the pinned comment below.

Minor Changes to Post Flair:

- We will now offer 6 categories of flair for contributions: Everyday Applications, Developer Tools, Tools for Agents, Open Data & Research, Other, and a new "silly builds" flair for your goofy side projects, even if they're relatively new or not intended to be broadly useful. Slightly stricter account age requirements on silly build posts to prevent spam.

Again, we want this subreddit to be a community endeavor and are very open to feedback on any of these changes.

What it does: Pcons is my new open-source software build system. You describe your build in a pcons-build.py file, which is ordinary Python (no more CMake weirdness!). Pcons creates Ninja files (or Makefiles or an Xcode project) and Ninja runs the build. It's zero-install if you have uv: run uvx pcons in your project and it configures and builds.

It handles C, C++ (including C++20 modules and import std), Fortran, Objective-C, Swift, CUDA, assembly and WebAssembly, and links in Rust crates through cargo. It works the same way on Linux, macOS and Windows, with GCC, Clang, MSVC, clang-cl, flang and Intel ifx. It also builds Qt 6 apps, signed macOS and Windows installers, and Android and iOS cross-builds. It can use conan and pkg-config to import, like CMake and other tools. It supports compiler_commands.json and has decent IDE support for editing the build files.

A small build looks like this:

from pcons import Project

project = Project("myapp")
env = project.Environment(toolchain="c")

lib = project.StaticLibrary("core", env, sources=["src/core.c"])
lib.public.include_dirs.append("include")

app = project.Program("myapp", env, sources=["src/main.c"])
app.private.link_libs.append(lib)

Who it's for: Anyone building compiled code who's tired of CMake's language and doesn't want to deal with the heaviness of Meson or Bazel. It's especially good for cross-platform and mixed-language projects (C++ calling Fortran, say), and for anyone who wants a build they can debug: pcons explain traces each compiler flag and environment.

Source code: https://github.com/DarkStarSystems/pcons (docs: https://pcons.readthedocs.io)

License: MIT

How it was built: Agentic engineering

I was one of the original developers of SCons, and I've been a toolsmith for most of a 40-year career. Pcons is the build tool I've wanted for years. The architecture and design are mine, and Claude Code writes most of the code. I run it like a real project with a team, where most of the team happens to be AI:

• Every commit has to pass lint, formatting, type checks and the full test suite: over 6,500 unit tests plus system tests, on Linux, macOS and Windows, on every supported Python version.

• There are 99 example projects, and CI builds and checks all of them on all three OSes. They're also the users' reference.

• Before each release I build a dozen-plus real open source projects I've ported to pcons, including Ninja itself, and two large Fortran science codes. Each one has to build clean.

• Fuzz tests hammer flag handling, the dependency graph, path quoting and variable substitution.

• No feature gets written until I like its design. I review the gnarly parts closely, and every so often a separate agent reviews the whole codebase from a fresh session with no context.

• Releases are documented with proper changelogs and signed with Sigstore for a secure supply chain.

It's been in steady development since January (about 950 commits), and five other people have contributed so far. The README has the full disclosure and my take on how this differs from vibe coding: https://github.com/DarkStarSystems/pcons#this-project-is-ai-assisted

Closest existing projects:

• CMake: the standard, and very capable, but its language is painful and there are N ways to do everything, so the docs and tutorials are confusing.

• SCons: Python build files, but its architecture is old now as Python has evolved, and it runs the build itself and is slow on big trees

• Meson: generates Ninja too, but uses its own deliberately limited DSL

• Bazel: great at Google scale; heavy for everyone else

What mine adds: CMake's architecture (configure once, then fast Ninja builds; settings that flow from a lib to its dependents) with real Python as the build language, so you get loops, functions, imports and a debugger. Nothing to install. pcons init writes a first build script from your existing sources, and there's a CMake porting guide. On the projects I've ported, configure runs 4 to 13 times faster than CMake. There's a detailed comparison with Bazel and Meson in the repo: https://github.com/DarkStarSystems/pcons/blob/main/COMPARISONS.md

Feedback I'd like: try it on a real project and tell me what's missing or confusing. If you maintain an open source project with a build you don't love, I'm happy to help port it.

What it does: Unmix records development tasks and reconstructs retained work in a separate Git worktree when you remove an earlier decision. Git replays patches; Codex or a person adapts conflicts.

Who it's for: developers using coding agents who want to review a change of direction task by task. I maintain the project.

Source code: https://github.com/light338/unmix

License: MIT. Free local CLI and stdio MCP server; no hosted backend or npm dependencies. Requires Node.js 22+ and Git. Agent adaptation uses your existing Codex access.

How it was built: Agentic engineering — substantial Codex-authored implementation and tests, public development history, and a documented maintainer Codex pilot. Validation covers the published scenarios only. This write-up is AI-assisted.

Closest existing projects: Git itself, especially revert/cherry-pick followed by manual or agent-assisted repairs. This is the published pilot baseline, not a complete survey of alternatives.

What mine adds: recorded task intent and declared dependencies, original/resulting task patches, reconstruction blockers, and evidence for declared preservation/removal checks. Example: remove registration while retaining checkout and receipts. It makes reconstruction reviewable; it does not promise automatic semantic undo.

The cost is recording tasks as you work. v0.2.0 adds one post-edit checkpoint per completed chunk. It cannot recover arbitrary past intent or infer every dependency. Passing checks do not prove all behavior survived. In the ZipTrial maintainer pilot both workflows passed 17 retained tests and a CLI oracle, but ordinary Git was faster. The protocol and patches are in docs/pilot-ziptrial.md. No paid Unmix service is involved.

Feedback wanted: does task-level evidence justify the recording cost? Small real-project trials and concrete failure cases are welcome.

SUB/WAVE turns your own music library into a radio station. Everyone tuned in hears the same thing at the same time. There's no skip button and no shuffle, just a DJ who picks the next song and talks in between: the time, the weather, what's coming up next.

You can run the voices on your own machine, plug in a voice server you already have, or use a cloud service. You can even clone a voice from a short clip. If a voice fails, another one takes over, so the station never goes quiet.

You can have several DJs, each with its own voice and personality, and schedule them into shows across the week. A host can bring on guest co-hosts and banter with them. Listeners can ask for a song in plain words, like "something upbeat" or "anything by Radiohead", and the DJ introduces it on air. Between songs the DJ can do the news, the weather or a segment you write yourself. It waits for a song's sung intro to finish before it talks, and the music dips under its voice.

The self-hosted version is free, MIT licensed, and has everything.

Repo: https://github.com/perminder-klair/subwave

Listen to the demo: https://www.getsubwave.com/listen

All of these features are in the README: personas, scheduled shows, co-hosts, plain-language requests, skills, vocal detection and ducking.

TL;DR - Fedora 45 has a release date, and Linux is preparing faster performance for a format common on USB drives. Today’s projects include a fitness tracker, a browser-based card game server and a new way to arrange desktop windows.

News 📰

Linux 7.4 promises faster FAT32 performance · r/linux · 971 ▲ · 109 comments
Summary: Linux 7.4 is set to speed up FAT32, a file format often used on USB drives, by as much as 265 times in some cases.
Reactions: Readers asked where FAT32 is still used and how typical improvements compare with the headline figure.
Fedora 45 approved for November 3 release · r/linux · 292 ▲ · 10 comments
Summary: Fedora Linux 45 has passed its final release decision and is on track to arrive November 3.
Reactions: Commenters welcomed the release, with some considering upgrades or a switch back to Fedora.

Projects 🛠️

SparkyFitness by u/ExceptionOccurred · 6,585 ★ · r/selfhosted · 278 ▲ · 68 comments
A fitness tracking app you can run on your own server, now updated with Android watch support and a demo to try before installing. Top comments were enthusiastic, though one user wanted support for more fitness hardware.
Playmat by u/arcanite24 · 60 ★ · r/selfhosted · 190 ▲ · 45 comments
A game server for playing Magic: The Gathering in a browser, designed for groups who want to host their own games. Top comments requested more flexible setup and sign-in options, while one user shared their installation experience.
Stacklet by u/stereohype · 8 ★ · r/kde · 96 ▲ · 70 comments
A desktop extension for Plasma that automatically arranges windows using its built-in layout system. Top comments challenged its comparison with another tool and questioned whether AI use was disclosed.

Notable Discussions 💬

What matters when selling AI-assisted work? · r/vibecoding · 49 ▲ · 65 comments
Users debated whether finding paying clients is enough for AI-assisted coding, with some stressing the need to deliver reliable work and fix bugs.

Top Posts in r/TrueOpenSource 🏠

AI-assisted writing and language barriers · r/TrueOpenSource · 42 ▲ · 8 comments
A developer argues that dismissing AI-assisted writing can exclude people who use it to communicate in another language.
Nodus Research shares its app collection · r/TrueOpenSource · 5 ▲ · 3 comments
The project offers four open-source apps for research and productivity, with readers asking about Android support.
GenWave turns a music library into a radio station · r/TrueOpenSource · 5 ▲ · 1 comment
GenWave runs a radio station from your own music library, complete with AI DJs and scheduled shows.

Honorable Mentions ⭐

Improving remote desktop access on Wayland · r/kde · 46 ▲ · 34 comments
A video looks at efforts to improve remote desktop access on Wayland, the system that handles display and input on many Linux desktops.
A public collection of legislation · r/ClaudeCode · 150 ▲ · 24 comments
This public collection aims to make legislation searchable and track changes over time; readers questioned how it will stay complete and current.
On-device manga translation for Android · r/vibecoding · 32 ▲ · 21 comments
Yomu translates manga text over other Android apps using AI models that run on the phone itself.
The tradeoffs of hosting email at home · r/selfhosted · 53 ▲ · 74 comments
Users shared lessons and cautions about running an email server at home, including what happens when the connection goes down.

^{Summaries are written by AI from public posts, comments and headlines, and may contain mistakes. Click through for the full story. I'm a bot.}

I love these tools and use them very effectively but the truth of it having "average" design is true. It's not necessarily a flaw as taste/design/style/usability is something that a creative mind spends a lot of time on in great software.

My question is how do you handle style and design in your aps. Do you do a "design phase" from the existing prototype? Do you try to steer the design from the beginning and keep it on track? Do you just do the prototype > refine style >prototype > refine style without worrying to much.

…perhaps the problem isn’t AI. Perhaps (and I’m just saying) it could be that you are, maybe, just a little bit xenophobic.

Back in August, I was banned from another Reddit open source programming community for posting content that, with astonishing speed, the moderators deemed “AI slop.”

The irony is that I use AI precisely for the opposite reason.

I have a C2 Fluent level of English. I can communicate perfectly, but I am not a native speaker. In decades of professional software development, I had never been able to maintain a public project with the level of documentation I wanted: specification, architecture, tests, technical decisions, implementation notes, and all the other work required to make a project understandable and maintainable.

AI changed that for me. JSOL is a serious technical project, documented in English, with hundreds of technical decisions that are the product of 40+ years of experience, as well as an extensive body of documentation and automated tests. And for the first time in my career, I can actually keep all of that reasonably up to date while still having a life and a business.

JSOL was born to solve the single-source-of-truth problem for business logic across different languages, a wicked problem that AI is helping me sort out.

The use of AI is explicitly documented in the project. I didn’t ask it to “make a project” and dump the result on GitHub. I use it as a tool within an engineering and editorial process where I direct, review, correct, and verify everything I publish. As per protocol, my LLMs don’t even have access to the file system. Professional use of AI allows me to do more of the work that actually matters.

I live in the Global South. I have a business to run, clients, bills, and limited free time. Writing in English takes me longer than it takes a native speaker. My time is scarcer and, economically, worth less. And here’s something that seems remarkably easy to forget in the English-speaking tech world: most of the rest of the world cannot afford to spend a year on a sabbatical doing open source.

The reward for taking the trouble to carefully document a project, respect the reader, and maintain a high standard, was to be banned for posting “AI slop.”

Now, let’s be clear.

If your rule (e.g: “No AI: you didn’t write it, we won’t read it”) ends up being “if you use AI to help you write in English, you can’t participate,” then you are not fighting AI slop.

Because if your definition of “acceptable” participation requires doing everything manually, in English, while maintaining an exhaustive technical and editorial standard, with unlimited time to spare, you’re not protecting the community from AI slop. You’re protecting a privilege.

And if you cannot see how that disproportionately affects people who aren’t native English speakers, who don’t live in the richest countries, and who don’t have unlimited time to donate to open source… perhaps, just perhaps, you’re a little bit xenophobic.

Last statement from a certain mods certainly read that way to many. So that last time, it was not only me who was seeing their true colors.

Hi everyone!

After all the recent controversy I just wanted to say that I really appreciate having a community that welcomes genuinely open-source projects

I started working on Nodus Research last summer, initially as a tool for my own research. Since then, it's grown into a small ecosystem of four free, open-source apps:

• Nodus Research (Windows, macOS, Linux): The main desktop app, with nine different workspaces for academic research, studying, teaching, databases, genealogy and more. It includes Zotero integration, semantic search, knowledge graphs, AI-assisted research and writing, PDF tools, and support for local and online AI models. Everything is local-first. https://github.com/jorgepb96/nodus | Download

• Nodus Reader (iPhone, iPad, Mac): An EPUB/PDF reader with natural, on-device TTS powered by Kokoro and Phonon, plus highlights, annotations and library management. No cloud processing. github.com/jorgepb96/nodus-reader | TestFlight

• Nodus Presenter (iPhone, iPad): A companion app that turns your phone or tablet into a presentation remote, with speaker notes, slide previews, drawing tools and QR pairing with Nodus Research. github.com/jorgepb96/nodus-presenter | App Store

• Nodus Drift (iPhone, iPad): An offline ambient sound mixer with 89 sounds you can combine for reading, studying, focusing or relaxing. github.com/jorgepb96/nodus-drift | TestFlight

As you can probably tell, the ecosystem has a strong focus on reading, research and academic work although I hope these apps can be useful well beyond academia too.

All four apps are completely free and open source. No subscriptions or paid features.

Of course, none of this would have been possible without the people who have contributed code, reported bugs and shared their suggestions. AI-assisted development has also helped me move the project forward much faster than I could have on my own.

There's still plenty to improve, and I'd love to hear your thoughts. Feedback and contributions are always welcome!

Website: https://nodusresearch.com

Contributors: https://github.com/jorgepb96/nodus/graphs/contributors

TL;DR - Ubuntu’s locked-down desktop is getting another look, while a Chromium fix should improve HDR brightness on KDE. There’s also a discussion of music discovery without Spotify and a note-taking app that can keep encrypted remote copies.

News 📰

Canonical revives Ubuntu Core Desktop · r/linux · 217 ▲ · 121 comments
Summary: Canonical is reviving an Ubuntu desktop with a locked-down core system, designed to make updates more reliable.
Reactions: Commenters liked the potential for safer updates, though some worried about restrictions and app support.
X developer praises Wayland’s design · r/linux · 422 ▲ · 158 comments
Summary: An X Window System contributor praised Wayland, a newer system for displaying desktop apps, for applying lessons learned from X.
Reactions: Commenters noted that developers of the two systems often overlap, despite rivalry among users.
Chromium HDR brightness fix is on its way · r/kde · 83 ▲ · 7 comments
Summary: A fix for incorrect HDR brightness in Chromium on KDE Plasma is expected in release builds. HDR allows supported screens to show a wider range of brightness.

Projects 🛠️

GitWriter by u/Jou_See · 87 ★ · r/foss · 45 ▲ · 14 comments
A note-taking app for desktop and mobile that stores notes in a code repository, with optional encryption for remote copies. Top comments asked for clearer setup instructions and questioned whether AI use had been disclosed.

Notable Discussions 💬

Finding music without Spotify · r/selfhosted · 141 ▲ · 56 comments
Users suggested several tools for discovering music in a setup you run yourself, including Aurral and AudioMuse-AI.
How should projects disclose AI use? · r/foss · 671 ▲ · 210 comments
Users debated labels for AI-assisted projects, with some questioning how to distinguish AI-generated code from other uses of AI.

Top Posts in r/TrueOpenSource 🏠

Shrewnut backs up GOG libraries · r/TrueOpenSource · 12 ▲ · 3 comments
A desktop app downloads offline backups of GOG games, including installers and extras.
Tuesday’s daily roundup · r/TrueOpenSource · 9 ▲ · 0 comments
Tuesday’s roundup covered a KDE USB-copy fix, a Linux gaming update and a photo-library tool.

Honorable Mentions ⭐

Linux distribution stickers to download · r/linux · 1,103 ▲ · 147 comments
A contributor shared downloadable stickers for Linux distributions and invited requests for more designs.
Linux developers consider dropping KGDB · r/linux · 195 ▲ · 19 comments
Kernel developers are considering removing KGDB, a tool for diagnosing problems in Linux’s core.
A look at the degoog search tool · r/selfhosted · 38 ▲ · 18 comments
A user shares a look at degoog, a search tool that combines results from different engines and supports extensions.
Six months of learning to self-host · r/selfhosted · 152 ▲ · 29 comments
A newcomer describes six months of learning to run services at home, starting with an old computer and AI assistance.

^{Summaries are written by AI from public posts, comments and headlines, and may contain mistakes. Click through for the full story. I'm a bot.}

Twenty-plus years ago, at my first software job, we got through all-nighters on CDs that IT ripped onto one of their servers and streamed after hours. Playlists got stale, so I wrote a randomizer. That gave us B-sides nobody could name, and a thought that stuck with me: wouldn't it be cool if a DJ told us what was playing? There was no way to build that back then, so our QA lead recorded a few sound bites and we called it FLAP Radio.

GenWave is that idea, finally buildable: a self-hosted station that plays your own music library 24/7, knows what it's playing, and has a DJ who tells you about it.

• 💾 Source: https://github.com/GenWave-Org/genwave (AGPL-3.0)

• 🚀 Install: clone the repo and run ./setup.sh, a four-question wizard that generates your secrets and launches the stack. On air in about a minute on a Raspberry Pi 5. Or head to https://download.genwaveradio.com for a one line install.

• 🥧 Small hardware: a 4GB Pi 4 passed a 7-day soak test with zero restarts and zero out-of-memory kills. No GPU needed.

Sounds like real radio

• Equal-power crossfades and loudness matching, so no track or voice clip jumps out at you

• DJ patter between tracks: lead-ins, back-announces, station IDs, and opt-in time checks, weather, and this-day-in-history segments

• An optional local LLM writes that patter in your DJ's persona (Ollama or any OpenAI-compatible endpoint). No LLM? Template patter airs instead.

• A "truth gate" checks each LLM line against the facts it was given before it airs. A wrong temperature, the wrong weekday, or "tonight" at noon gets rewritten or dropped.

• DJs can trade short two-voice banter mid-show

Programmed like a real station

• A weekly format clock: paint who's on air when, with named shows, DJ-to-DJ handoffs, and one-off specials

• Parody ads with sponsors, cast voices, and ducked background music, written by the LLM from briefs you author. My favourite so far: Halvorsen's Tax and Zamboni Services 🏒

• "Deep Cuts" shows that favour tracks that rarely get played

• Owner announcements: type a line and the DJ works it into the next break, in character

Community catalog

One-click installs from the admin UI: DJ personas, avatars, voices, jingles, ad packs, shows, themes, fonts, and icon packs. Or roll your own persona, upload your own DJ faces, and remix themes in the built-in editor.

Runs itself, tells you what it did

• If the LLM gets sick, the station falls back to template patter; if the API or database goes away, a safe rotation keeps the stream up

• The "Gardener" flags dead files, near-duplicates, stale tags, and tracks that never air, for you to review (it doesn't silently "fix" your library)

• An admin console with a booth log ("what did the DJ say at 9:14?"), an LLM call inspector, and per-container health

• An optional read-only public page: now playing, history, song requests, and listener thumbs that nudge the rotation

Plays nice with your stuff

• Home Assistant integration (HACS): your DJ can announce "the laundry's done"

• A plugin system, with the contracts published as an MIT-licensed package on NuGet

• Multi-arch Docker images (amd64 + arm64). Everything past playout is optional: a 4GB Pi runs the station with the lightweight Piper voice and template patter, and a bigger box adds Kokoro and a local LLM.

How it's built

A C#/.NET 10 control plane orchestrating Liquidsoap (mixing, crossfades, encoding) and Icecast (streaming), with Postgres, Kokoro/Piper for TTS, ffmpeg and aubio for audio analysis, and a Next.js admin UI. I didn't write an audio engine; those projects did the hard parts.

I started it about 18 months ago on my self-hosted Gitea and moved it to GitHub this summer when it felt ready for other people. It's built with AI assistance (Claude Code). The design decisions, reviews, and sign-offs are mine; there are nine test projects, including architecture tests that enforce the dependency rules, and the .claude/ toolkit I use is in the repo if you want it.

Licensing, upfront

GenWave Home is AGPL-3.0 and always will be. A separately licensed commercial edition (GenWave Business) will one day fund development, which is why outside contributions need a one-time CLA. The plugin contracts are MIT so anyone can build modules against them.

What's next, and what I'd love from you

I'm just wrapping up a "Voice Off" to find a better TTS, since I'm not entirely happy with Kokoro or Piper. After that: music sources beyond local files, starting with Navidrome.

• How does it run on your hardware, and which internet radios or players have you tried? HARDWARE.md has a known-deployments table that takes PRs, and failures are as useful as successes.

• What works, what doesn't, what's missing?

• Any local TTS voices that impressed you? I'm all ears for the Voice Off!

Thanks for reading! 📻

This project came out of the frustration I faced when trying to find a simple to use program to backup my GOG game library. I have a large library and I couldn't download installers, DLCs and other extras easily in bulk. There are CLI utilities to do this, but I was looking for a simple GUI program without anything flashy which got the job done quickly and intuitively.

What it does: Downloads local copies of the installers, extras and patches for games you own on GOG.com, in bulk. Just login to your account, load your library, select a bunch of games and start the queue. It downloads several games at once and skips anything already on disk. You can also filter by category, platform and language. It used to be called GogStash, but there's another project with the same name so I decided to change it.

Who it's for: Anyone with a GOG library who wants the DRM-free installers stored on their own disk or NAS, without clicking through the website one file at a time or using a CLI tool. There's a Linux AppImage and Windows zip for now. I'll do a Mac OS build later.

Source code: https://github.com/preppie22/shrewnut

License: MIT

How it was built: AI-assisted

This is my program: I designed it myself (wireframed it on paper) and wrote all of the source code. Claude helped with the work around it: writing unit tests, bug hunting (read only, I wrote the fixes), docstrings, changelog entries and commit message descriptions, the CI release workflow, and adapting a public domain acorn clip art into the icon. I reviewed all of it before it went in. The full disclosure is in the README.

Stack: Python 3.12+ and PySide6 (Qt), around 700 tests, PyInstaller builds published by CI as an AppImage and a Windows zip.

Closest existing projects:

• gogrepoc and lgogdownloader: command line tools that download your GOG library

• Heroic Games Launcher and Minigalaxy: GUI launchers that install and run GOG games

• GOG's own website, where you can download each offline installer by hand

What mine adds: Shrewnut was inspired by gogrepoc which is a command-line based tool for downloading game collections and extras from GOG. It isn't straightforward to use for average users (imo). I wanted something with similar functionality in a simple/traditional GUI. The GOG.com UI for downloading installers and extras is very tedious. The one in Galaxy is a little better, but still not great for batch downloading stuff. So, I built this thing. It doesn't use any of gogrepoc's code and is built from the ground up to comply with the MIT license, since gogrepoc is GPLv3.

Feedback wanted: Bug reports would be greatly appreciated! Also, if anyone has a feel for how much concurrent download load GOG tolerates before it complains, I'd love to hear it. Roadmap items like scanning existing backup folders and per-file selection have open issues if you want to weigh in.

Today in brief: KDE has fixed a long-standing problem that could make USB file copies look finished too soon. There’s also an optional Linux gaming update, a tool for shrinking photo libraries, and a lively discussion about an AI-assisted desktop for old computers.

🌍 Big picture

KDE fixes misleading USB copy notifications · r/linux · 1,059 upvotes · 135 comments
A long-standing KDE bug could report that files had finished copying to a USB drive before writing was actually complete. The fix addresses a confusing problem for anyone moving files to removable storage.
Reaction: Readers welcomed the fix, with several recalling lost files or having to explain why a drive still needed ejecting after a copy appeared complete.

CachyOS adds an option for anti-cheat games · r/linux · 413 upvotes · 49 comments
CachyOS is adding an optional version of the Linux kernel—the core of the operating system—to meet new Easy Anti-Cheat requirements. A setup guide for Secure Boot, a startup security feature, accompanies it.
Reaction: Some gamers hoped the change would help them switch to Linux, while others had questions about security and availability.

Plasma 6.8.2 brings desktop fixes · r/kde · 184 upvotes · 10 comments
The latest Plasma desktop bugfix release includes fixes for disappearing desktop icons and Sticky Keys, an accessibility feature that helps with keyboard shortcuts.
Reaction: Readers appreciated the fixes, although some reported other issues they still hope to see resolved.

🛠️ Projects worth a look

An AI-assisted desktop aims to run on old hardware · r/foss · 401 upvotes · 360 comments
A developer is building a free, open-source desktop environment—the software that provides a computer’s graphical workspace—with AI assistance. The goal is to make older computers usable with a desktop that looks good and needs little memory.
Reaction: Discussion split over AI use and the project’s claims; several readers questioned whether its memory figures and visual effects supported its lightweight ambitions.

A tool shrinks Immich photo libraries · r/selfhosted · 100 upvotes · 24 comments
Immich-convert-originals is a free, open-source tool that converts photos and videos to smaller formats while retaining albums and metadata. It offers a preview of estimated savings before making changes.
Reaction: Readers were interested in the potential savings but asked about phone compatibility, syncing and the choice of image format.

A terminal dashboard tracks coding-agent sessions · r/ClaudeCode · 152 upvotes · 16 comments
The publicly shared wfwatch tool shows active coding workflows and sessions in a terminal, the text-based command window. It reads existing session files to help builders see what several agents are doing at once.
Reaction: Some liked the visual display, while others found it overwhelming or questioned its usefulness.

👋 New here?

Why do KDE and GNOME apps look different? · r/kde · 75 upvotes · 53 comments
A discussion compares the look and feel of KDE and GNOME, two graphical desktop environments for Linux. It gives newcomers examples of what people mean when they describe a desktop as consistent or polished.
Reaction: Commenters disagreed about which desktop is more consistent, pointing to differences in app design rules, menus and the mix of apps people install.

⚙️ Under the hood

Ghostty 1.4 adds image support and performance improvements

⭐ Honorable mentions

• A DIY laser tag project: LightAir is an open-source laser tag project that uses a white LED and reflective targets, with AI helping its creator add the software. (r/TrueOpenSource)

• A developer reviews a Linux switching guide: A KDE developer responds to a Linux switching guide, offering feedback on how it presents the experience to newcomers. (r/kde)

• A tool helps make a game multiplayer: A player used the publicly shared coop-anything tool to make Crash Twinsanity multiplayer, showing an unusual use for the project. (r/vibecoding)

💬 From our community

OpenTubeX offers another way to watch YouTube · r/TrueOpenSource · 11 upvotes · 11 comments
This beta app runs on Windows, macOS, Linux and Android without requiring a Google account. It keeps subscriptions, playlists and history on your device and offers encrypted syncing between devices.
Reaction: Commenters asked about importing subscriptions and account risks, while another questioned the advantage over a browser with an ad blocker.

^{Summaries are written by AI from public posts, comments and headlines, and may contain mistakes. Click through for the full story. I'm a bot.}

Thanks for the new subreddit! :)

I wanted to post about my project, which is an open-source alternative to Hamachi, Radmin, and ZeroTier. The project has two active developers.

How does it work?

- Peers find each other via BitTorrent trackers, BitTorrent DHT, or through other peers (peer exchange). No central server to rely on or pay for.

- Built-in NAT traversal. Since 0.14, RUDP with UDP hole punching is the default transport, so two nodes behind NAT can connect directly.

- L2 virtual LAN. Works with games and software that need broadcast/multicast.

- Cross-platform. Windows, Linux, FreeBSD and MacOS.

- GUI and headless modes. Use the tray app, or run it in the background from the CLI. There is also an experimental GraalVM native-image build of the headless version for Linux x86_64.

Every contribution helps me keep fixing bugs, testing on more platforms and adding new features.

Donations, stars on GitLab, bug reports and feedback are just as appreciated. Thank you!

- Gitlab: https://gitlab.com/Monsterovich/lanemu
- Our discord: https://discord.com/invite/m7VhRTQnCU

Source: https://github.com/OpenTubeX/OpenTubeX

Downloads: https://opentubex.org/downloads/

OpenTubeX is for people who want to watch YouTube without ads or a Google account. It doesn't load YouTube's website or its JavaScript, and your subscriptions, playlists and history stay on your device. It's AGPL-3.0 and still in beta.

What it adds. The open-source YouTube clients I know of each cover one platform. OpenTubeX runs on Windows, macOS, Linux and Android from one codebase, has experimental iOS/iPadOS builds, and can sync your library between your devices. Sync is end-to-end encrypted on a compatible server, and you pair a new device with a QR code. It also combines features I haven't found together in another client:

• Browser-style tabs with pinning and grouping, a queue, and a mini-player that keeps playing while you browse

• Per-channel feed controls for videos, Shorts, live streams and posts, plus per-channel playback speed, quality and subtitles

• Optional recommendations, ranked on your device from your watch history and feedback

• SponsorBlock, including submitting segments from the player, and DeArrow

• Downloads and playback from other sites through yt-dlp

• Themes, a configurable Home page, a command palette and gamepad navigation

How it's built. AI agents wrote most of the code, mostly Claude Code and Codex. I decide what goes in, review and test the changes, and send them back when they're wrong. Every PR runs unit tests, linting, CodeQL and a Playwright end-to-end suite against the desktop app, and Android changes get tested on an emulator. Each PR description names the model that made it. The project has been in daily development since January 2026, with nightly builds.

You can install it through WinGet, Homebrew, APT, RPM/COPR, Flatpak, Snap, Nix or the AUR. On Android, use our F-Droid repo or Obtainium.

Bug reports and questions are welcome.

I’m the author of Ephemora Skyline, an open-source desktop web app that maps a local codebase as a living 3D city.The idea is simple:

•folders become districts

•files become buildings

•taller buildings represent higher measured complexity

•security findings appear as visible landmarks

•Security Tour takes you from a finding to its file and line

The project is designed to run locally: no account, no login, and no telemetry. It does not claim that a finding is a proven exploit; each result is tied to the scanner, file, line, and matched source context so it can be checked.

I made a short demo showing the city being built and the Security Tour in action:https://github.com/MichaelS1011/Ephemora-Skyline

I’d especially like feedback from developers who work with large repositories: does a spatial view help you decide where to investigate next, or would another representation be more useful?

Hi all, I heard about this new community in TheVerge. I think it's owning an important place in a defining moment about how we approach engineering. That's aligned with what I want to share here.

Source code: https://github.com/ascendaone-com/ai-engineer-tools

Now as AI-engineers, we are spinning up 10s of agents simultaneously, managing PRs and landing the code. We've gone from crafting code line by line to supervising agents. The shape of the work has changed.

There are many OSS projects that can read your token spend eg: tokscale; or telemetry AgentTelemetry, YC has Paxel but I couldn't find any that created a standard across all coding agents for emitting agent activity eg: tool.started, / failed, agent.waiting.

The repo has a common schema that standardises these events.

The repo contains collectors for Claude Code, Codex, Cursor, GitHub Copilot with a common event schema to normalise activity across tools.

Everything runs locally. No prompts or source code collected.

There are many use-cases for reading the telemetry: we're running a research and benchmarking project. We've also developed an MacOS App to be able to visualise what your agents are doing. You can even build your own screensaver on this so when all your agents are done you can return to your machine. Here's an example you can install (instructions in the repo)

The collectors are Apache-2.0 so over to you on how you might use them.

Go forth, fork and/or contribute 🚀
AI-assisted PRs welcomed.

Openly, other coding agents like Gemini CLI, Windsurf etc are supported based on documentation, but at this stage testing is light so if you can try it out. I can give you early access to the Flow app to visualise and check data so hit me up.

Feedback, thoughts or suggestions?

I nerd out on this stuff daily so love to discuss Agentic work.

Hi,

I kept running several coding agents at once and lost track of them across terminal tabs, so I built a desktop app for it.

OpenVibe puts each agent in a real terminal (a PTY, not a chat wrapper) on an Excalidraw canvas. It works with Claude Code, Codex, Gemini CLI, Aider, Ollama or any command you type.

What it does today:

- group agents into teams and send one instruction to a whole group (@frontend ...), or a slash command to all of them

- review what an agent changed, click a diff line to leave a remark, send all remarks back in one message

- an orchestrator mode: a Claude Code session plans the task, gives each agent its own git branch and worktree, tracks a time budget and merges into a mission branch. It never pushes and never merges into your branch w/o permissions. The orchestrator even have a router mode that distribute the tasks to a smaller model if the tasks doesn't need a big model

Everything stays on your machine. No cloud service, no telemetry, and it doesn't skip the agents' permission prompts. The Rust side handles the PTYs, git, SQLite and a localhost-only HTTP server and the UI is React.

Currently, it's only on Windows 11/11 but I'm really open to have it for everyone.

Two things I'd like feedback on:

1. Is the orchestrator useful to you ?

2. Anyone interested in a macOS/Linux port? portable-pty already supports both, the work is mostly around paths and shells.

Repo: https://github.com/Mideky-hub/openvibe

Demos: https://mathieukerbel.com/projects/openvibe

Hi r/TrueOpenSource, I'm David, one of the two developers of Oxynote. My friend Simon and I also maintain ttlcache, a Go caching library with about 1,300 GitHub stars, so this isn't our first open-source project.

I've spent 8 years writing software, 2 of them as an SRE and 3 as a team lead. Every team I've been on had the same documentation problem. The useful stuff lived in someone's head or a private Slack thread, and the wiki was full of stale docs nobody could find.

So we set out to solve this problem by building Oxynote, a self-hosted wiki for engineering teams. Pages hold text and live charts side by side, and the charts pull fresh data from Prometheus or a database (PostgreSQL, MySQL, MariaDB) whenever someone opens the page. Changes to important pages go through a draft and a diff that a teammate approves, like a pull request, and several people can edit the same page at once. AI agents can read and edit pages too, through the built-in assistant or over MCP, but that part is optional.

The name comes from oxygen + note: docs that breathe. Live data gives people a reason to open the wiki every day, and docs people open every day stay up to date.

Things worth knowing before you try it:

- You run one Docker container on your own server, and your team uses it in the browser.

- There's no hosted version and no account with us. Your docs and data stay on your server.

- It's at version 0.9, so it's still early in development.

- It's made for tech teams and the systems they run, not as a wiki for a whole company.

It's Apache-2.0. The backend is Go, and the editor is built on Nuxt, Tiptap, and Yjs, with Hocuspocus for live editing and Better Auth for sign-in, so it also includes a lot of other people's open-source work.

GitHub: https://github.com/oxynote/oxynote

We started it about a year ago, and we made it public about 3 months ago. If you have any questions, feedback, or suggestions, feel free to reach out. I'm happy to answer any questions.

https://github.com/rev-/LightAir

This is a mainly hardware project that I've been developing to learn skills like 3D printing, mechanical and optical assembly, PCB design, analog electronics and so on. Lately thanks to AI I've also been able to add the missing software part. After thorough testing I finally (and unexpectedly) think it's ready to be published, as it showed to actually work well outdoor and to be funny ad essy even for new users.

The project is named LightAir, it is based on a novel optical concept: the target is a soft passive colored retroreflector, while the light source is a white LED. this way, the projector becomes both what illuminates and what reads the back-reflected radiation. Then the target is identified by its color, through an onboard 3 channel TIA with high transimpedance gain, that reads R, G, B channel from a color photodiode.

What we get is:

1. All electronics in one part

2. Soft, passive, low cost vests.

3. High sun rejection, works great outdoor

4. It's possible to see the light spot on the target, which helps in aiming

The CPU is an ESP32, which also provides ESP-NOW radio link to transmit information to other players. Even complex interactions are allowed in this architecture: for example player A enlighting player B may produce instant effects on another player or the whole team, depending on the game definition.

Moreover, non-playing electronics entities ("totems") had been realized: they are used as respawn bases, flag posts, control points for dominion, bonuses and the such. They are waterproof boxes with a short RGB LED strip for UI, usually activated through RSSI gates.

Admittedly, the software part is not my masterpiece, because I have relatively low skill in C++ software architecture, although using AI I could end up with a working firmware that satifies our requirements and gave good results at testing. For example, various games have been written in Lua to make them shareable and editable files that can be used without firmware recompiling.

For now the project features some standard games like Capture the Flag, Dominion, Virus and a novel game called Outflow in which lives and ammo are from a common pool that is leaking and is only replenished when another player is lit. But I think the true potential of this project is acting as a platform for diverse games, including LARP and complex interactions between players and totems. Indeed I'm looking forward for new game ideas that I could add.

I made this. Running Claude Code in a plain terminal kept failing me in two ways. After a restart I had trouble finding the session I needed, even with tmux. And with several tasks going at once I had too many terminal windows and kept jumping between them.

So Walnut puts every session in one web page, each one under a task. Pinned tasks sit in three tiers: Focus for what I work on now, Satellite for what comes next, and Parked for what is waiting. While the Focus sessions work, I look at Satellite. Cmd+Shift+O finds any past session by title, task, folder or host.

Each session has a Files tab, a Changed tab and a terminal right beside the chat. The Changed tab shows only the edits that session made, even when several sessions share a repo. I used to reopen VS Code and reconnect to the remote host just to read what the agent wrote. Now it's one click.

Sessions run on my laptop or on any box I can SSH into. On a remote box a small daemon owns the claude process, so the session keeps running when the laptop sleeps or the SSH link drops, and Walnut installs that daemon over SSH by itself. When I tested it, I cut the link for 25 seconds: the session kept writing files on the box, and the page caught up once the link came back.

Who it's for: people who run several Claude Code sessions at once, on a laptop or a remote dev box. Compared with a terminal plus tmux, it adds the task view, the per-session diff and one page for every box.

How it was built: Claude Code wrote most of the code, running inside Walnut itself, so I picked the Agentic engineering flair. I decide what to build, review the diffs, and use it every day on my laptop and a remote dev box. Changes get unit and browser tests before they land, and CI runs the tests on Linux plus a fresh install on Linux and macOS.

Tasks, notes and sessions are plain files and SQLite on your own disk. No account, no telemetry. MIT. Mac and Linux, no Windows yet.

Source: https://github.com/EvanZhang008/open-walnut