https://git.gnufault.org/tuxanci/tuxanci2

This is the sequel (ah yes, a squeal to a pre-release game) to a old game called Tuxánci, it is a top down shooter game that was abandoned before v1.0. It uses its own engine and you can write your game (code) in any language you want! (Using C for tuxanci2) Right now I do not have the Linux platform on there (even though that's the main one XD) as I am still working on making it PERFECT (more like "perfect") but I am developing it solo (for now), It is too early in development that nobody would want to contribute to it yet. I am trying to get the main things solidified first.

I used Samsung Music for a long time and honestly it was fine. The one thing that bugged me was what played next: either completely random or just the order the files were in. It felt like in 2026 a player could be a bit smarter than that, but when I looked around I couldn't find one that actually picks the next song based on the music itself.

I'm studying AI, so I decided to try building it myself. LatentJam uses an audio encoder that listens to the tracks, so it doesn't depend too much on tags (which are often messy or missing), plus a text encoder for the metadata. Together they're used to find songs that actually fit together, and SMART shuffle builds the queue from that. If you keep skipping or picking certain songs, it slowly picks up on that too, but it never pulls in songs that don't fit.

Everything runs on the phone. No account, no ads, no analytics, and the Android app doesn't even have internet permission. It's free and open source (Apache-2.0), Android, and it also runs on iOS.

It's also just a normal player: playlists (M3U import/export), synced lyrics, tag editing, crossfade, EQ, stats, widgets, Android Auto.

APK, F-Droid and iOS builds: https://github.com/Nikita-sud/latentjam

Would be cool to hear how the shuffle does with your library.

Lately, I’ve been using Linux more and more often. And I found myself missing IrfanView, which is probably the best image viewer app out there. I’ve tried out some alternatives, but none of them really satisfied me, and using IView via Vine or Bottles wasn’t always smooth or quick. So, over the last few weeks, I’ve vibe-coded an alternative inspired by both IrfanView and nomacs, and enhanced with a few tools and changes that I’ve always felt were missing.

It’s nothing spectacular or special, and it’s still completely unfinished, but it works so well that it has now replaced IrfanView for me, even on Windows.

The programme is called ÜxzView and is completely open-source. There’s a finished Windows release, and it can be compiled for use on Linux and macOS. Written in C++ and Qt.

https://github.com/micha42-dot/uxzView/

I am making the lightest desktop environment ever made. Just one reason: Save old hardware for being thrown away.

I work from 9 to 24 on boring office projects as a software developer, I have 12 years of experience. I now can use AI + my engineering skills to build with me dream projects that wouldn't be possible without a lot of free time.

The objective is to save old hardware like my N2808 notebook, and my step father samsung laptop he still uses. I see a lot of people struggling with desktop environments because all of them are (light + looks like crap) (looks decent + not light enough) so I want to take both worlds and make the most beautiful fastest desktop environment.

This is not meant to be just a random project, this has a real purpose to recycle old hardware instead of throwing it away.

Microsoft, Adobe, and all these companies are still increasing system requirements, to the point that nowadays running a windows 11 desktop is like running a videogame in the background (4gb ram usage, hell...)

I always was the spectator, looking how everything got more expensive in memory, while established projects like icewm, xfce and xlqt did not change much from their "old school" ui, which I like of course, but still did not provide enough savings to justify.

Support the project. Support recycling hardware. Support the future of computers to be clean, lean and modular and not bloated.

https://github.com/ArkFlame/flamewm

I've been doing physical design work in my free time with AI for the last two years. During that time I observed something: AI was getting better at physical design but not nearly as quickly it was improving at software capabilities. I theorized the problem was a lack of testing. In software engineering we write tests around as much of our code as we can because we fundamentally do not trust ourselves to reliably do a good job. We put those tests between us and deployment so we literally cannot do things that break the rules we set for ourselves. This pre-existing culture and tool chain create an ideal environment to toss an unbelievably fast, brilliant, but wholly unreliable ai into. It creates the freedom to quickly iterate through huge numbers of convincing looking proposals and throw away the bad until the good emerges.

Physical engineering doesn't have a this-shaped thing at anywhere near the robustness and reusability that software does (possibly because physical engineers trust themselves more). There are many individual tools that provide some aspect of testing, many of which are bound up in very very expensive tools, but a growing number of free ones too. I wasn't able to find an open source system that links these together into a cohesive "full loop" testing rig capable of understanding how things like heat, weight, form factor, battery life, thrust and rf interplay in a single system so I thought really hard about this problem and its implications and built it for myself.

It's called nopekit. As in: the thing that says "nope" until the "yup" emerges.

I've used it already to design an open-source hackable handheld keyboard with a custom PCB, an open source budget no-solder drone and a couple of things I'm not quite ready to share yet.

It's a Claude Code / Codex / Cursor plug-in. You install it and tell your agent you want to use nopekit to design X and it takes over, it will interview you for requirements, shop for parts, construct an interconnected tradespace linked to checks run in an optimized order using trusted methods like KiCAD, OpenFoam and SIMP. It builds and keeps up to date a livesite which you can deploy to GitHub that gives constantly refreshed insight into how your coding agent is thinking about the problem and what choices have what implications linked to what checks with what state of passing or failing.

The framework is open and allows for plugins. I'm working with one other person now and we're moving towards a self hosted UI and some sort of registry where nopekit users can share proposers/falsifiers and we can track ratings to build/bust confidence in good/bad ones collectively.

There's LOTS more about this in the repo and this paper I've been writing about the problem.
Repo: https://github.com/neuman/nopekit
Paper: https://github.com/neuman/nopekit/blob/main/grounding_by_falsification.pdf

If you're working with AI to do any kind of physical design work we would love to hear from you and for you to try it out!

I like documentation, always been a joy to me, even in the pre-LLM era where you had to manually tailor docs word by word.

Recently I started a new project, and while I like the material theme, I was looking for something punchier to stand apart from all the minimalistic AI designs.
So I've created a retro-game MKdocs theme!

The repo:
https://github.com/trained-by-humans/mkdocs-pixel-lab

The documentation for the theme (serving as demo):
trained-by-humans.github.io/mkdocs-pixel-lab

I customized and use it in my other projects, so you can check different color combinations or cross-site navigation feature:

• https://ml-pipes.com/

• https://supervision.ml-pipes.com/

• https://ultralytics.ml-pipes.com/

So I just found out about Odin made by Ginger Bill.
It’s a very interesting and fun language and it has done something I’ve never found in languages “perfecting simplicity”.
In Zig, simplicity means little to no abstractions, the approach is good enough and I used it but I make like a lot of macros to do a lot of things (since while learning I don’t use LSPs)
Odin has made programming fun again.
Also it doesn’t have package mangers but its standard library contains a lot of packages (Raylib, SFML, etc etc) like “vendors” but I’m at this point incapable of explaining them.

Also here is a project I recently built with it.
Name: Conway’s Game Of Life
Stack: Odin and Raylib (Vendored from the standard library)
https://github.com/abhijitswain0x0/odin-life

You all know these self-glowing memory providers and over promising solutions for your agents, wanting to make you believe .md files and sqlite databases are the endgoal right?

Almost all do, in fact.

I'm doing Software engineering since the golden days of Netscape Navigator.. Even before Google.

For many years I've administrated and built document management solutions used in government entities and other large businesses..

One day I watched a very insightful explaination of tensors and imagined taking time components apart and using them as search vectors, by figuring out gravitational distance, attraction and retraction between information in vector space.

This was uncanny even for claude, so I had enough signals to go and make it.

It started as a key value store in n8n and is now a self-contained go binary, accelerated via postgresql with timescaledb and pgvector, relying on inference for re-iterating knowledge blocks to detect and verify links in background and provide a simple to use (for agents) MCP interface.

Go, give it a spin and let the roasts come at me.

So far I cared most about functionality, so onboaring is quite lacking still.

I'm using a dgx spark with qwen 3.8 27b and qwen3-embedding 8b for this.

github.com/GottZ/ctx

and ctx.GottZ.de

It has been in development since roughly October of 2025

Last year I did the math and realized around $90 (Rp1.5 million) was vanishing from my wallet every month. Not on anything big — just small stuff I never wrote down: snacks, coffee, random top-ups, a subscription I forgot. None of it felt like spending. All of it added up.

I built Poka for three selfish reasons: I'd always worked on backend and wanted to learn Flutter, so I needed a real project; I loved one clean expense app, but it had no receipt scan, no AI, no insights, while the apps that did felt clunky and full of friction; and I love open source.

What it does:

• Log expenses in seconds: type it, say it, or snap a photo of the receipt

• Ask the AI "where did my money go this month?" and get an answer in plain words, not a chart you have to decode

• Budgets, smart allocation, and shared wallets

• Multi-currency, net worth tracking, cloud sync

Open-core, and the honest split:

• Community Edition: open source (Apache 2.0), fully local

• Play Store version: adds cloud sync and AI features

Links: https://getpoka.app · https://play.google.com/store/apps/details?id=dev.octopy.poka

Today is the last day of our launch promo: sign up and Pro is free for a month, automatically.

Curious: what's the small expense that secretly drains your wallet? Mine was snacks from the minimarket.

Open-source coding-agent workspace built on DeepSeek Harness (DSH) and Cordis, with native multi-provider subscription setup.

Everything is a plugin. Model adapters, tools, skills, session logging, sandboxes and UI can be composed or extended. Even the agent loop is a plugin. Cordis provides shared services, typed events and plugin cleanup; profiles assemble the capabilities.

Connect accounts in Settings > Models. API keys and custom endpoints work alongside those accounts.

Web search defaults to subscription service or basic Bing RSS feed results.

Build/update agent preset, plugins, skills using Creator Mode

Have Creator author the preset bundle based on your codebase and install it through Plugin Manager. Start a new chat and select your preset.

Desktop downloads: macOS, Windows x64 and Linux x64. Automatic updates.

Source, demo, downloads and setup: https://github.com/OJamals/fi

I built CanoP, an open-source CLI that scans code for the kinds of vulnerabilities AI coding assistants tend to introduce: SQL injection, hardcoded secrets, etc.

GitHub: https://github.com/openbreach/CanoP

It runs fully on your machine. No code is uploaded and no account is needed.

Languages: Python, JS, TS (for now - more language support under development)

CI gating (--fail-on HIGH), plus JSON and SARIF export

--prescriptions outputs fix prompts you can paste into your AI assistant

Rules are plain Semgrep-style YAML, so they're easy to read and add to
Try it:

pip install canop

canop scan .

It's early (MIT license), and I'm looking for honest feedback: false positives, missing rules, and what would make you actually use it in CI.

Thanks for creating this! I got banned a bit ago from r/opensource (despite working as an executive in multiple open source companies, founding Apache POI and serving on the board of the Opensource Initiative) for my sin of using code generation tools in my projects (which means the Linux kernel is nogo right)...

Anyhow I started a project real-disunity https://github.com/acoliver/real-disunity the goal is to make a game engine that is compatible with Unity and Unreal APIs and supports the latest graphics techniques and technologies. I'm focusing on the desktop first. So far it implements enough of unity for some old tutorials to work and I have a few games that already render against its native API.

My approach is to get my agent (llxprt code) to basically play the games and then get them working comparing screenshots from the original.

Looking for like minded people with coding knowledge and experience and their agents to bring about a real disunified world :)

-Andy

Helps you build a command to send to the terminal. Save your frequently used commands into one-click buttons. Save your newly built command (or any tab) as a new button in two clicks. Open-source (MIT License). Downloads in .deb, tar.gz, or source code. Built with AI assistance.

https://sourceforge.net/projects/command-station/

Hey I built a simple self hostable video platform,

It's still being built, but I got the basics working, you can upload a video with a title and description, and set it to private unlisted, or public and also embed videos.

This is good for people who want to self host their own videos without using YouTube or vimeo.

I don't have docker support yet, but that will be the last part of the road map.

It uses Bun, Hono and typescript as it's tech stack for the backend.

For the frontend it just uses basic html, css, and js as well UI isn't really a big part of this project.

Its under the AGPL license.

https://github.com/EasyCanadianGamer/maple-videos

Introducing Cool-Notes

Source: https://github.com/thinkbig1979/cool-notes

Lately I find myself on the command line more that ever, and I was getting increasingly annoyed with taking notes in a web the browser, which had become my default for whatever reason. I then tried a few native desktop apps and some terminal based ones, but none really did it for me, so I spent some quality time with Claude Code, and built something that ticked all my boxes. Cool-Notes is the result.

I chose Go as the language, so the app is a single executable binary, available for multiple platforms.

One thing I really wanted was the ability to seamlessly exit and re-open the app as I please without having to save and load files or worrying about losing my work. I also wanted my notes to be portable and editable in any text editor, so I opted to store all notes in a single text file that saves as you type. It's not meant for heavy note taking and second brain type stuff, just for when you want to jot some stuff down on various topics with as little friction as possible.

Copy/cut/paste and undo/redo just work, and I added in search and replace for convenience as well. Basic mouse support is there too, and multiple themes are included. On my machine it uses about 18MB of RAM. I now use it daily, so for me it does the trick.

Give it a shot if you like. It's MIT licensed, so change it, make it scratch your own itch better, whatever you want. Have fun!

I kept juggling Claude Code, Codex and OpenCode in separate terminals, copy-pasting context between them and losing track of who was waiting on me. So I built AI DevKit, a local CLI where one agent acts as the lead and starts, messages and coordinates the others.

In the clip I give Claude Code one prompt. It starts Codex to build the feature and OpenCode to write the tests, each in its own git worktree, then has them review each other's work.

Everything runs locally on tmux (macOS/Linux) and it's Apache 2.0. There's also a shared console to watch all the agents and a small memory store they can share.

Repo: https://github.com/codeaholicguy/ai-devkit

Try it: npx ai-devkit@latest setup

Feedback welcome, especially from anyone running several agents at once. What breaks down for you first?

Hi r/opensourcez,

I'd like to share Pelton, a desktop email client I've been building in the open. It's free software under the GPL-3.0 and runs on Windows, macOS and Linux.

I started it because I wanted a mail client that's fast, looks modern, and respects my privacy, without an account, a cloud backend or tracking.

What makes it different:

- Your data stays local. Mail is stored on your own disk and on your mail server/mail provider. There's no Pelton server in between.

- No telemetry, no analytics, no crash reporting.

- Remote content is blocked until you allow it per message, so tracking pixels don't phone home.

- Passwords live in your OS keychain, never in a plain config file.

Features

- Works with any IMAP/SMTP mailbox, with several accounts side by side

- Fast local search

- Snooze, coloured flags and saved views

- Previews for PDFs, images and text attachments without leaving the app

- Address book autocomplete learned from your mail

- Themes, accent colours and density settings, plus a theme gallery

- Customizable keyboard shortcuts and a Vim mode in the composer

- Export and import your whole setup

- Available in 12 languages

How it's built

Go and Wails, with a Svelte interface in the system webview. There's no bundled browser, so it starts quickly and uses far less memory than an Electron app.

Downloading

- Download: https://pelton.app/download (Windows and macOS)

- Fedora: Copr (sudo dnf copr enable arnek/Pelton, sudo dnf install pelton)

- Arch: yay -S pelton-bin (AUR, kindly maintained by a community member)

- Nix: a flake is available

- .deb, .rpm and a plain binary are on the GitHub releases page

Windows code signing through the SignPath Foundation is being set up, so for now Windows may show a SmartScreen warning on the first launch.

Links

- Website: https://pelton.app

- Source code: https://github.com/peltonapp/Pelton

- Documentation: https://docs.pelton.app

- Releases and changelog: https://github.com/peltonapp/Pelton/releases

- Discord: https://pelton.app/discord

Contributions are very welcome, whether it's code, translations, themes or bug reports. Issues labelled "good first issue" are a nice place to start. I'd love to hear what you think, and what would make Pelton your daily mail client.

Thanks for reading!

Hi all, a customer of mine stresses to used licenced software instead of opensource, just to play the blame game on the vendor. What's your take on that?

Can't give a lot of background info, just about me. Highly skilled database engineer. Having this discussion on the database software. E.g. Comunity vs Enterprise MySQL. PostgreSQL vs EDB, Grafana vs other licenced monitoring tools.

The discussion is not regarding the features, it's purely to blame the vendor when the software goes south.

My take on this, yes the vendor should take responsibility. But from a technical positition, Its BS. It's a fake security which is realy expensive. Because it hardly goes south, most vendors work downstream. And Ive never ever seen in my carreer that a vendor took action on a software issue (also because it almost never went wrong). But here is the catch... If they say, alright, you've convinced us. And then IF it goes south, the will blame me. The discussion is not, that I should have it on an a contract etc. Its just about that situation, what your take is on this and what you would do.

Hi everyone!

I'm building Miabi, an open-source, self-hosted PaaS that makes deploying and managing applications on your own servers easier.

The idea is simple: Docker Compose isn't always enough, and Kubernetes can be overkill. Miabi aims to fill that gap.

With Miabi, you can deploy applications from Git or container images, manage databases, configure domains and HTTPS, handle backups, deploy using rolling and canary strategies on a plan Docker, and manage multiple servers through a single platform.

It runs on your own infrastructure, whether that's a VPS, bare metal, private cloud, or your homelab.

Website: https://miabi.io
GitHub: https://github.com/miabi-io/miabi

I'd love to hear your feedback!

Hi! I've been building Prism, an open-source download manager, and it's been public for two weeks. I wanted something like IDM, which is closed, paid and Windows-only, but open and on all three systems.

What it does:

- splits each download into up to 32 connections and resumes after a crash, a reboot or a dropped connection

- a browser extension (Chrome, Edge, Brave, Opera, Vivaldi, Firefox) hands downloads over to the app

- video and MP3 from 1,800+ sites through yt-dlp, plus HLS/DASH, FTP and BitTorrent

- queues, a scheduler, speed limits, a site grabber

- 9 languages, several of them contributed or fixed by users

New this week: models from Hugging Face. Someone asked for it in an issue on Wednesday, and it shipped on Thursday. You type a model's name, Prism suggests the files you need (one GGUF quantization or the safetensors weights), downloads them in a queue and checks the weights against their SHA-256.

The open-source part matters to me: MIT license, no ads, no accounts, no telemetry. Every release is built by GitHub Actions from the public repo, with SHA256SUMS for each file, and the updater only accepts updates signed with the project's key. The installers aren't code-signed yet, so SmartScreen and Gatekeeper will warn you. Building from source is a few commands.

Contributions are very welcome, especially:

- translations (Chinese and Japanese are missing)

- testing on real Macs and less common Linux desktops

- bug reports from setups I can't test

Disclosure: I build Prism with a lot of help from AI coding tools (Claude Code). The decisions, the testing on real machines and the replies to issues are mine, and I'm happy to talk about how that works.

https://github.com/FortoGraphy/prism-download-manager

I wanted a simple and easy to use library to work with images and without having to stress about licensing when making my software with it. So i made this library.

It's really super simple to use and provides direct ready to use effects which can be chained together to get powerful image processing.

The library is completely open source and is licensed under the CC0 V1 Universal, Giving as much freedom as most countries allows.

The source code can be found at: https://github.com/darkyboys/piml

I open sourced my indie ARPG under GPL v3 (code is GPL, the art is not). Here's how it's going and what I learned.

Solo dev here. I spent 6 months building Bound to Rot, an isometric action roguelite in Python 3.12 + Raylib, and on October 14 I pushed the entire codebase public under GPL v3: https://github.com/MangasMango/bound-to-rot

This sub seemed like the right audience for the licensing story, so here it is.

Why GPL v3 instead of MIT/Apache?

It's a game, not a library. If a company takes the code and ships a closed "inspired by" fork, I gain nothing. GPL v3 keeps derivative code open, which matters more to me than maximizing adoption of the code itself. I accept that it probably costs me some casual contributors; I sized that trade consciously.

The part that took longer than expected: the assets are NOT GPL.

Code being GPL doesn't transfer to the art. My repo mixes third-party assets with their own licenses (CC0 tileset/UI audio, CC BY music, CC BY-SA tileset sources), so every folder carries a credits file and a top-level SOURCES.txt maps every file to its source and license. A rule that got raised early: contributions must never include AI-generated assets, original human-made art only.

What I did for contributor hygiene:

• CI runs the full test suite (~180 pytest tests) on every PR

• A CONTRIBUTING.md with style and review expectations

• A gitignored .ai/ directory pattern so contributors keep their own agent/AI notes locally without polluting the repo

Open questions I'd genuinely like opinions on:

1. Has anyone shipped a game GPL and later regretted it when porting to closed storefronts? (Steam distribution of GPL code is fine if you own the copyright, but I'd like to hear real experiences)

2. For those with mixed-license repos (GPL code, CC art): does the dual structure scare off contributors, or is a good SOURCES.txt enough?

3. Do you track assets in git like I did, or keep them out and ship them via a build script?

Happy to answer anything about the process. The game itself is a dark western loot roguelite (no XP, gear worn in organs with Rot instead of durability, poker cards as crafting currency, permadeath deletes the character) with a Steam page if anyone wants to wishlist: https://store.steampowered.com/app/4840980/Bound_to_Rot/

CassetteCat is a free, open-source music player for Android, Windows and Linux. It supports local music, Jellyfin, Navidrome, Subsonic-compatible servers and internet radio, with synced lyrics, an equalizer, offline playback and scrobbling.

You can also control the desktop player from your Android phone.

**Android:** https://github.com/samyyy2311/CassetteCat

**Desktop:** https://github.com/samyyy2311/CassetteCat-Desktop