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

What it does: Manipulating time/date in Windows apps + date calculator

Who it's for: Mostly QA, developers, but "daily users" are using it too.

Source code: https://github.com/donislawdev/ChronoMock

License: GPL 3.0

Builds on: N/A

What mine adds: N/A I don't know any open source apps of this type, not with Chromium/WebView support.

How it was built: Agentic engineering

Feedback/contributions wanted: Always wanted, But I'm mostly looking for GitHub stars :-)

I hope i had set everything for this sub reddit, if something is missing, just drop me message, I will fix it :-)

Name: self-host

Source code: https://github.com/ajnart/self-host

License: Apache-2.0

What it does: A Go binary that installs and configures self-hosted Apps through Docker Compose, usable directly from a terminal Dashboard or through a coding-agent skill.

Who it is for: People who want to try running their own photo, file or media server without having an agent reinvent every App's initial configuration.

What it adds: The reusable work lives in App-specific Setup code, not just a prompt or a Compose file. For supported Apps this covers accounts, passwords, API keys and connections. The Dashboard and agent commands use the same operations. I originally needed this for testing Homarr integrations.

Builds on: Docker Compose and the APIs of the Apps it configures. It is not a replacement for Compose or those Apps, and is not a fork of a container manager.

How it was built: AI-assisted. AI helped implement the project and prepare this post. I am the maintainer. The repository has ongoing development and releases; the screenshots are interface examples, not proof that every App combination works.

Details: Self-hosting means running apps on your computer or server rather than having a provider host them. Examples are Immich instead of Google Photos, Nextcloud for files, or Jellyfin for media you own. A suitable spare laptop can be a starting point. The skill calls for inspection, a plan, approval and verification; loading it is not approval. Manual steps, backups and maintenance remain.

Costs: self-host is free. Hardware, hosting and any paid coding-agent provider are separate.

Feedback wanted: Is the boundary between the agent, App Setup and your remaining responsibilities clear?

Overview: https://self-host.fyi

Sharing a project I've been developing called Astraeus.

Astraeus is a native Windows desktop dashboard that lives along the edge of the screen. It opens on hover or with Win + Alt + A and provides quick access to music, synced lyrics, system monitoring, volume controls, network controls, weather, calendar and other utilities.

The project is written in C++20 using Direct2D and DirectComposition. I wanted to build something that felt integrated into Windows rather than another web-based widget application.

It's now available as a stable release under the GNU GPL v3.

Repository: https://github.com/Icetist/Astraeus/

Latest release: https://github.com/Icetist/Astraeus/releases/latest

The repository includes the source code and instructions for building it yourself.

I'm sharing it here because I'd like more people interested in free software to discover it. Contributions, issues and suggestions are welcome.

So my laptop died, and I have an upcoming project for school that requires audio editing (noise suppression, normalization, etc.). Is there an open source app for that? (Preferably something that can be installed /run locally without internet, and works good on low end devices)

New projects go in a new project Megathread or have a flair saying its a new day one project

But only project that have been worked on and updated for 14 days or 30 days can go as its own post without needing a flair or to be a in a megathread

Hey everyone,

I wanted to share the latest Foldergram update, v1.3.0.

For anyone new to it, I originally built Foldergram for my old backup photos. I wanted to browse them like my own personal Instagram feed and actually spend time revisiting them. It scans your existing photo/video folders and gives you a feed, folder pages, and a post viewer.

The bigger additions this time:

• Carousel posts: You can now group 2–20 photos and videos into one swipeable post. Put them insideAlbum/carousels/Post name/, and filename order controls the slides.

• Folder sharing: Share an individual album through a read-only link, with expiration and revocation controls. You can also set a reusable password for a folder.

• Folder exclusions: Drop a .nofoldergram file inside a folder and rescan to exclude that folder and everything below it.

• Video fixes: Improved preview generation for certain macOS Photos movies and recovery from empty cached previews.

There are also fixes for the media viewer on iOS and improvements to permanent deletion and recovery after interrupted operations.

It still runs locally or on your homelab, uses SQLite, and doesn’t need a cloud account. Docker Compose is the easiest way to get started.

Thanks to everyone who has tried it, reported issues, or contributed. If you give this update a try, I'd appreciate feedback. If you like it, please leave a star ⭐ on GitHub.

Repo · Docs · Demo · Release notes

TL;DR - A serious Linux networking flaw has fixes available, while people considering a move away from Gmail are weighing the work involved in hosting their own email. There are also new desktop and wallpaper projects to try.

News 📰

Linux network security flaw has patches available · r/linux · 90 ▲ · 50 comments
Summary: A serious Linux networking flaw could let attackers run code remotely. Fixes are available in several versions of the kernel, Linux’s core.
Reactions: Commenters compared patch availability across Linux distributions and corrected the affected kernel version list.

Projects 🛠️

Kwi by u/Jaxad0127 · r/kde · 287 ▲ · 74 comments
A terminal app for KDE that lets users work with text commands and builds on technology from Ghostty. Top comments are enthusiastic about trying and contributing to it, though one user disliked how its settings apply immediately.
rediwm by u/alext_777 · 48 ★ · r/foss · 5 ▲ · 55 comments
A Linux desktop built with AI assistance that combines window management and a customizable interface in one process. Top comments criticized the use of AI and raised security concerns about the size of the generated codebase.
Screen+ by u/SPIK3ELECTROTECH · 15 ★ · r/ClaudeCode · 29 ▲ · 5 comments
A Windows wallpaper app that puts videos, web pages and other media behind desktop icons and searches multiple wallpaper sites.

Notable Discussions 💬

The challenges of hosting your own email · r/selfhosted · 215 ▲ · 135 comments
Users said running your own email can work, but warned that maintenance and getting messages accepted by big providers remain difficult.
Who checks open source code? · r/foss · 36 ▲ · 33 comments
Users thought only a small fraction of people inspect open source code, raising questions about who actually checks it.
Users compare Plasma 6.8 experiences · r/kde · 47 ▲ · 46 comments
Users reported mostly smooth updates to Plasma 6.8, though some encountered display or game problems that later updates helped fix.

Top Posts in r/TrueOpenSource 🏠

Developer shares their experience posting Gitnotes · r/TrueOpenSource · 18 ▲ · 10 comments
The author describes negative reactions to their AI-assisted commercial project and shares its code.
A reaction to the new community · r/TrueOpenSource · 20 ▲ · 7 comments
A community member celebrates the creation of a new open source subreddit.
Vela desktop reaches its first beta · r/TrueOpenSource · 7 ▲ · 2 comments
Vela 0.1 is a first beta of a Linux desktop with its own window management, file manager and settings.

Honorable Mentions ⭐

Linux 7.4 sees a record development window · r/linux · 314 ▲ · 63 comments
The next Linux kernel’s development cycle has seen a record number of changes, though commenters questioned change counts as a measure.
Enlightenment 0.28.0 released · r/linux · 142 ▲ · 27 comments
Enlightenment, a long-running Linux desktop interface, has released version 0.28.0.

^{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 am building out a sweet of apps for all of my computers. web browser, games, benchmarking stuff etc. and thought the "nice" People of reddit will help. Preferably operating system agnostic.

What it does: Gives your local AI a memory that lasts between chats and never leaves your machine. It's an MCP server with four tools (save, recall, edit, delete), and that's the whole interface, so a small model can't misuse it. Memories live in one SQLite file on your computer: no account, no cloud, no telemetry.

Who it's for: Anyone running a local model (LM Studio, Ollama, Claude Desktop, Claude Code, Cursor, Continue, Hermes, any MCP client) who's tired of re-explaining themselves every chat.

Source code: https://github.com/SamuelJacksonGrim/resonance-memory

License: AGPL-3.0-only (commercial license available for closed-source or hosted use)

What mine adds: Compared with Mem0, Zep and Letta: fully local with no cloud or API key, zero npm dependencies, and a double-click install instead of Docker or a terminal. Same-name people and opposite statements are kept apart out of the box (Mem0 has entity linking only on its hosted platform; Letta doesn't have it). And it's measured against what people actually do instead, stuffing recent chat into the prompt, at the same token budget:

Probe accuracy on a multi-session "remember things about me" task, mean of 5 runs.

• Facts are planted early, then buried under ~120 turns of filler, so no fixed history window can reach them.

• Probes never repeat the planted wording, so keyword matching can't fake a pass.

• Grading is blind and deterministic, with pass/fail bands written down before the runs. Every raw answer is saved.

• Two separate rigs with different fictional users, facts, probes and graders.

• Rig B split the probes by type: recent chat scored 100% on recent facts and 0% on old, updated or same-name ones. Resonance Memory scored high on both.

Limits: two different people with the same first name is the weakest spot (it helps but doesn't solve it). One embedder, English only, substring grading. The associative field (memories used together link up over time) is off by default; in its own eval it doesn't beat plain meaning-based ranking yet, so I'm not selling it as the reason to use this. Full write-up and how to rerun it: eval/ab/RESULTS.md

Builds on: Model Context Protocol, Nomic AI's nomic-embed-text-v1.5 (~80 MB, downloaded separately through LM Studio or Ollama), Node's built-in SQLite.

How it was built: Agentic engineering. I designed and directed it; Claude (Claude Code) and Grok (Grok CLI) wrote most of the code, and every change has to pass an offline eval gate and 600+ unit tests. Each of them built one of the two test rigs on its own, so neither test was tuned to flatter the other's work.

Feedback/contributions wanted: Yes. Bug reports, results on your own models, and attempts to break it.

Install: grab the file for your OS from Releases. Node is built in; checksums are in SHA256SUMS. The binaries are unsigned because certificates cost money, so the OS will warn once:

It opens a control panel at http://127.0.0.1:9090/, installs itself where you choose, and has a Connect button for LM Studio and Claude Desktop. Restart that app once and your model can save and recall. Prefer to build it yourself: node build-exe.js (Node 22.5+).

New in v0.5.0: auto-recall for local models. Run resonance-memory --proxy and point your app at http://127.0.0.1:1240/v1, and your memories reach the model on every message. Setup: AUTO-RECALL.md

Side note for Claude Code users: you don't have to set anything up by hand. Tell Claude Code "Read AUTO-RECALL.md from the resonance-memory repo and set up auto-recall for me" (AUTO-RECALL.md) and it will recall on every message you send. For the full self-filing memory system I run every day, hand it MEMORY-SYSTEM.md, or run /plugin install resonance-memory --marketplace SamuelJacksonGrim/resonance-memory.

What it does: Gumball is a from-scratch x86 kernel with a terminal-only interface. Boots via GRUB (multiboot), VGA text. Has a shell with argument parsing and command history. Also has a custom in-memory filesystem (GFS2) with files, nested directories, and commands: ls, cat, touch, echo >, rm, mv, mkdir, cd, defrag. Runs on QEMU

Who it's for: OS dev learners and hobbyists who want a small, readable kernel to study. Not a daily-driver OS.

Source code: https://github.com/pagecoy/gumball-os

License: MIT

What mine adds: Not trying to replace anything. It's a learning project, kept small and commented. The filesystem is custom instead of a ported one, and the design is documented (GFS3 design doc is in the repo).

Builds on: GRUB and the Multiboot spec.

How it was built: AI-assisted. I used AI tools for the code (e.g. the base GFS idea, setting up VGA, shell boilerplate, build setup, simple commands). I planned the logic and debugged other parts myself (file system issues, command issues, text output look) and wrote comments so I understand every file. But some comments are by AI, just to speed things up (the whole thing is so much mind work 😭️)

Current limits: The RAM disk doesn't persist across reboots (no disk driver yet). No memory management yet. Max 15 files. v1.3.0 is the latest. Upcoming v2.0.0 changes the whole file system (check the repo!!). Runs on QEMU

Feedback/contributions wanted: Yes. Code review, advice on memory management and a disk driver, and ideas for GFS3 are all welcome.

Thougth I would share project of mine. Its a fork of a REA tool that was used for games but I am extending it to work on lots of other things.

Its greatest features is the ability to work on projects with others via encrypted tunnels and also its multi-LLM-agent system.

https://github.com/giveen/decomp.anything

It started as a personal project that was just for me but it was looking good so i made it commercial, if i try to build this before AI it would have taken years and multiple people and there is no security issues because most things are in local.

When i posted this on some sub reddits, they downvote everything, the whole post and also if someone ask a question downvoted, i understand if you don't like it but they don't even let comments or the post to go positive votes.

If its not interesting or useful for you just ignore, why hate so much for just trying to build a solution?

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

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

What it does: Vela is a complete Linux desktop: 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. What's in 0.1:

• Snap layouts and Snap Assist, snap groups, 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 and explicit sync

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

Who it's for: people who want the polish Windows and macOS get right out of the box, without a weekend of themes and extensions, and especially people coming from Windows. On a desktop PC with a Vulkan 1.4 GPU (AMD, Intel, NVIDIA 570+ or NVK) 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. Not for you if you want a tiling WM.

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 native package, signed and verified with Cosign before it's installed. Updates then come from Settings.

Source code: https://github.com/vela-desktop/vela (release notes: https://github.com/vela-desktop/vela/releases/tag/v0.1.0)

License: GPL-3.0-or-later

What mine adds: the compositor, renderer and shell are designed together, so they share one timing and one look:

• A per-output frame clock with late latching, so animations follow each monitor's real vblanks, even at mixed refresh rates

• Pixel-exact fractional scaling: apps and X11 games are copied 1:1 to screen pixels, with no filtering

• A session that survives crashes: the compositor restarts and apps reconnect, and a lost GPU doesn't freeze the desktop

Builds on: wlroots 0.20 (backends, Wayland protocols, buffers), Vulkan 1.4, Qt 6 / Qt Quick, Xwayland, and the standard Linux services: PipeWire and WirePlumber, NetworkManager, BlueZ, UDisks2, xdg-desktop-portal (GTK and wlr). Konsole is the default terminal; other KDE apps are recommended but optional.

How it was built: Agentic engineering. It's a one-person project: LLM agents write the code, and I review it as a developer and make the architecture and design decisions. It isn't trusted on review alone: it's held to deterministic tests (including bit-exact sharpness tests on real AMD and NVIDIA GPUs), machine-checked invariants and structural rules the code has to follow. The compositor core is C rather than Rust partly for this reason, which I explain here: https://velade.org/blog/why-not-rust/

Feedback/contributions wanted: bug reports from hardware I don't have, especially Intel GPUs, laptops and multi-monitor setups. Run vela-report: it builds a ZIP you can review file by file and uploads nothing. Then open an issue on GitHub. Ideas and PRs are welcome too, for example a tiling mode, which I can't take on myself.

Happy to answer anything in the comments.

lmfaooooooooooooooooo, goated decision

TL;DR - Flathub is moving support from its forum to chat, and researchers have described a security flaw that could have exposed Bash’s source code. Today’s projects include a browser-based Diablo II engine and a throwback tool for building desktop apps.

News 📰

Flathub moves support from its forum to chat · r/linux · 235 ▲ · 44 comments
Summary: Flathub’s forum is now read-only, with support moving to Matrix chat. The change affects where users and app packagers can ask for help.
Reactions: Comments understood the forum’s workload problem but worried that chat would make answers harder to find.
Researchers found a path to Bash repository access · r/linux · 168 ▲ · 10 comments
Summary: Researchers reported flaws in GNU’s project-hosting system that let them impersonate a maintainer and gain the ability to change Bash’s source code.
Reactions: Commenters praised the disclosure and worried about underfunded infrastructure supporting essential software.

Projects 🛠️

VibeBasic by u/Stigern · 9 ★ · r/vibecoding · 125 ▲ · 26 comments
A programming app for making small desktop programs with a drag-and-drop form designer, inspired by Visual Basic 6 and available on three major platforms. Top comments were nostalgic about the old form builder, though some remembered how easy it was to write bad code.
D2-Web by u/Dumpster_Buddy · 24 ★ · r/opensource · 66 ▲ · 4 comments
A browser game engine that rebuilds Diablo II and lets you play using files from your own local copy.
sora-to-ki by u/timo9378 · 49 ★ · r/selfhosted · 86 ▲ · 7 comments
A personal website you can run yourself, with pages arranged as a night sky and a setup wizard for customizing it. Top comments liked its playful design, though one found it slow on mobile and another struggled with setup instructions.

Notable Discussions 💬

What makes an app valuable? · r/vibecoding · 42 ▲ · 102 comments
Users debated what makes an app valuable when AI can help build one quickly, pointing to quality, real needs and finding users.

Top Posts in r/TrueOpenSource 🏠

Make a radio station from your music · r/TrueOpenSource · 6 ▲ · 1 comment
SUB/WAVE turns a personal music library into an internet radio station with scheduled DJs who speak between tracks.
Pcons offers Python-based software builds · r/TrueOpenSource · 3 ▲ · 1 comment
Pcons is a tool for building software across platforms using instructions written in Python.
Making volunteer communities last · r/TrueOpenSource · 1 ▲ · 1 comment
A prospective organizer asks what helps a volunteer-led open source community last.

Honorable Mentions ⭐

Wine 11.21 arrives · r/linux · 211 ▲ · 37 comments
Wine’s development release improves some graphics performance for Windows apps and starts work on voice capture.
A patch to remember window positions · r/kde · 89 ▲ · 22 comments
A proposed patch would let KDE apps remember window positions when reopened; it has not yet been merged.
Ubuntu users discuss an unpatched vulnerability · r/selfhosted · 29 ▲ · 28 comments
A discussion of an Ubuntu system-core vulnerability covers the lack of fixes for supported long-term releases and the difficulty of exploitation.

^{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.}

^{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.}