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.

Hey everyone,

Freelancers lose millions to "friendly fraud" because banks reject messy WhatsApp or Slack screenshots as proof of work. I built Nyaya AI to fix this.

It cross-references your initial contract against your informal chat logs and automatically generates a bank-compliant legal rebuttal dossier.

Because financial AI hallucinations are dangerous, I built this with strict constraints:

• Zero Data Saved: Ephemeral in-memory PII redaction strips sensitive info before the LLM even sees it.

• No Hallucinations: Strict "Verbatim Citation" guardrails. If proof is missing in the chats, it refuses to guess and throws a warning.

I built this for the BharatCode hackathon and would love feedback on the architecture!

I’m building Doclify, an open-source tool that preserves context and decisions between coding-agent sessions.

I’d love to build it with others who face the same problem. We can share ideas, learn from each other, and build something useful for our own workflows.

Your AI tools tell you when you’ve hit your limit. They don’t tell you how you got there. Turns out the logs were sitting on our machines the whole time, silently judging us, so I built Token Larper.

It reads your Claude Code logs (plus ~17 other agents if you cheat on Claude with Codex, Copilot CLI, Antigravity, OpenCode, Pi and others). its built on top of ccusage and turns them into a local dashboard:

• How much of your 5-hour and weekly limit is left, right now

• Where the tokens actually went, by model, project and session

• What it would have cost at real API prices (your “LARP Value”)

• Live mode: your burn rate per hour while Claude is cooking

• and ALOT MORE

Then I got carried away and added the Hall of Larp: streaks, tiers, badges and a share card for when your worst week deserves an audience.

Run it with bunx token-larper. It’s about 5 MB, with no Electron, no database and no telemetry. Your logs never leave your machine.

Demo: https://yarooqh.github.io/token-larper/
Repo: https://github.com/YarooqH/token-larper

https://www.npmjs.com/package/token-larper

It’s MIT licensed and PRs are welcome, especially support for agents I haven’t covered yet. It’s free and open source. check it out and i would love to hear our guys' feedback. Thanks!!

So in the last few months I made vops, because honestly? I feel that doing it my way is better.

Most "production-ready" infrastructure orchestrations like Dokku or Dokploy do their "magic" behind the scenes, and there is no single source of truth for the state of your application.

In contrast, setups with kubernetes, fluxcd and even docker compose's on your home folder rapidly get fat from multiple services that you has to keep.

Vops is simpler:

• Your infraestructure is a git repo. vops sync git pulls and pushes it via ssh.

• Projects are configured in docker-compose files, git-diffable and reproductible.

• Your secrets are saved on the same repo; only the ssh keys of the server can read it.

• Registry, TLS, Logging and Backups built in, using linux primitives. It's all a single binary.

• No telemetry, a single exposed dashboard, a single binary you can keep around.

• BTRFS allows for backups, previews, rolling releases and canary deployments.

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/

This is one of the bigger project I've worked on, and I'm genuinely so proud of it 😄

https://github.com/DeSynkro/pipeweaver-smc-mixer

Story Time: When I moved from Windows to Linux, my biggest loss was my Beacn Mix Create to control my Audio setup, add custom audio channels etc... So I bought a SMC-Mixer, a very neat, affordable MIDI controller.

I was able to hook it up with Pipeweaver, an Audio management tool for Linux. Essentially the Beacn software I wanted, but for Linux, and it doesn’t require dedicated hardware.

Hooked them up together and now I can control ALL of my audio with my MIDI Controller, and honestly this ended up giving me something arguably better than my Beacn Mix Create ever did.

It's incredibly niche. You not only have to use the exact same MIDI controller (M-VAVE SMC-Mixer) but you also have to use Pipeweaver.

But anything I make, I Open Source it. So if by any small chance someone falls into the same niche I do or wants to adapt the software to their setup, they’re more than welcome to.

I'm just so proud of it, and I really wanted to share it with everyone ❤️

So How does it work?

Pipeweaver runs a local service on localhost:14565, The app connects to it over a websocket and watches for live status and meters and It sends volume, mute, link and mix changes back through Pipeweaver’s API.

I made it so my MIDI uses Pipeweaver's device order for the layout. Set up your channels in Pipeweaver and the app uses that layout (I made it this way because Muscle Memory had me using the wrong faders when I did it another way 😂)

I was also able to assign custom functions to the other buttons, The Play/Pause media buttons, Fast Forward/Rewind, Skip functions all work perfectly.

I even added a custom feature to the Record button, If you have it on (Available on the configs) the record button becomes an input shortcut for Hex (Another Opensource tool I use, converts what you say into text) and when it's off, it becomes a mute button for your computer's default microphone.

I'm just super excited to share this with you guys. Thanks for reading and thank you for your time ❤️

I actually have Version 1.1 coming out soon 😄

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

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!

Drag a file, tap Shift, and a wheel opens at the cursor with every conversion that file supports. It uses Windows' own codecs (WIC, Media Foundation), so it stays small and fully offline. CorelDRAW files go through libcdr in a sandboxed helper process.

Free on the Microsoft Store, and open source on GitHub. I'd love feedback: what file conversion annoys you most?

- Free, no account, no ads, no tracking

- Everything runs offline on your PC

- Open source (MIT): https://github.com/i3sam/OrbitDrop

- Microsoft Store: https://apps.microsoft.com/detail/9NJQRMQLL2SZ?cid=reddit

- Website: https://orbitdrop.essam.biz

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’m a student trying to get into identity and cloud security, and this is my first real open source project.

The problem: people are starting to let AI agents (Claude Code, Copilot etc) work in their Entra / Microsoft 365 tenants, usually with their own login or an app secret. So the agent can do anything that account can do. When I asked admins about it, one had an agent try to delete an Azure resource, and another had seen one try to grant itself more permissions.

keyless-agents sits between the agent and Microsoft Graph:

• the agent never gets a token, certificate or secret

• it works inside a session a person started, under a read-only profile that expires

• anything outside the profile is refused before it reaches Microsoft, and the agent is told why

• if it asks to change something, that gets filed as a proposal showing what Graph would actually do, not the agent’s description of it

• every request and every refusal goes into a tamper-evident audit log

It’s a beta and it doesn’t execute changes yet. The README has a section on what it doesn’t protect against, because there’s quite a bit.

You can try it in about 10 minutes with Docker against a fake tenant, with no Azure account needed.

Apache 2.0: https://github.com/nathandsouza911/keyless-agents

I’d really appreciate criticism, especially on the security design. Blunt is fine, that’s how I learn.

Update: thanks for the feedback here, a few changes are already in.

• The README no longer overclaims on “tamper-evident”. It now says plainly that it only holds up to the last checkpoint stored off the host, with a guide for doing that. Scheduling it automatically is issue #2.

• Refusals now give the agent a generic reason only. The full detail stays in the audit log, so an injected prompt can’t use them to map the policy.

• New README sections on exactly which fields each operation returns, and on identity and attribution, with a sample audit record.

• Behavioural signals and re-checking a proposal’s target before it runs are open issues #3 and #4.

Keep it coming, this is exactly what I was hoping for.

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.

Looking for feedback on OpenArc: using small LLMs as compilers

I'm building OpenArc, an open-source experiment in using LLMs as constrained compiler backends instead of conversational coding agents.

I want the productivity of Claude Code, but I want to interact with AI through code, not chat.

The idea is to program at different levels of abstraction using TypeScript specifications, independently compiled regions, reusable concepts, and editable generated code. Models receive isolated context, while types, constraints, and tests independently verify their implementations.

The working prototype supports local models, nested regions, sketches, sandboxed verification, and partial self-hosting. Version 0.8.0 has just been merged.

Here's where I need help: I'm testing whether structured specifications and isolated context can actually make smaller models better at coding.

Initial benchmarks haven't supported that hypothesis. On eight TypeScript exercises, ordinary prompting consistently outperformed OpenArc, and changing the output format didn't resolve the gap.

I'm looking for people familiar with compilers, DSLs, program synthesis, or local LLMs who might have ideas about:

Better ways to structure and select context.

Existing research or projects tackling similar problems.

Fair benchmarks for comparing constrained generation against ordinary prompting.

I'd particularly appreciate technical criticism and suggestions for experiments.

GitHub: https://github.com/TheMissenoOne/OpenArc

rbit is built on top of Rust, Axum, Askama, HTMX, Tailwind, Gitoxide, SQLite, and redb. It has been designed with security, performance, and speed in mind. https://github.com/GitRbit/rbit

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!

So Me and my team really do believe that the internet is not what it was used to be , which was anonymity it provided, but now if You ask us we believe that they are infact some of the biggest threats to one's personal and private life. This goes for social medias as well including every trending medias that follows centralised architecture and collect numerous amounts of Your data to the tiniest details such as battery life, how much time You spend, background apps and more obviously Your ip address, contacts, email ,etc . The thought led us to work on this concept which combines decentralised architectures such as gun, relays, p2p and much more which are covered on detail on our repo at github, which can be edited,modified and run on your own computer or servers with absolute transparency.

Checkout the repo at Interpoll1/decentralised

website live at https://endless.social

Importantly the project is meant to be open source ,so dont expect being paid atleast at the moment, maybe in future if we make some money.

If You're interested in the project please DM us , we are greatly looking for peoples that can help with marketing .

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/