Hi r/opensource 👋

In my quest to figure out my own AI Contribution Policy, I came across a great list of existing policies from a large variety of projects. It includes policies that both accept and ban the use of AI tools as well as some basic categorisation of the contents.

The list is located here: melissawm/open-source-ai-contribution-policies.

For those interested in how my own quest ended, you can see the final policy here, which was adapted from my original draft and from attr's AI policy.

Hello, Testing Files Generator has just got V0.5 update :-) 31+ formats, tons of settings, built-in file tools, "recipe" system, exact byte size, real files

What has changed?

- 5 new formats: geojson, mp4, webm, rtf, eml, each with tons of settings

- New settings for "html" + "PDF"

- built-in tools for checksums + tool for archive scan (zip bombs)

- Translations support in GUI

- msi installer, docker image, chocolatey package + microsoft store/winget in progress.

- fyne/go version bump + other things version bump

- bug fixes

-fuzzing testing + mutation testing was added to ci/cd

And tons of other things, over 55 commits (git squash), full changelog on GitHub. If you like the project, please give it a star. Right now I'm working on new presets + tons of new PDF files settings.

More info on Ofical Website

I have vibecoded this miniapp because I'm quite good at SQL but really bad using Excel files. In the past this should have taken me some time to be implemented but now... Just posting this hoping this helps someone else.

SheetQL is a pure client-side app for turning spreadsheets and data files into queryable SQL tables — no server, no upload, no account. Upload a file, paste some data, and query it with SQL (backed by DuckDB-WASM entirely in your browser. Everything runs via WebAssembly and Web Workers; the database lives in memory only and is reset when you reload the page.

Features

• Import — Excel (.xlsx / .xls / .xlsb), CSV/TSV, ODS, Parquet, Arrow/Feather, JSON/NDJSON, plus a "paste data" modal that sniffs CSV/TSV/JSON.
• Query — a multi-tab SQL editor with syntax highlighting, autocomplete (keywords, tables, and columns), a SQL formatter, and multi-statement execution.
• Export — query results as Excel/CSV/ODS, and all tables as Excel/ODS.
• Themes & languages — light/dark (plus a "chocolate" palette) and four locales (English, Spanish, German, French).
• Private by design — no server and no persistence. Your data never leaves the browser.

Harness: OpenCode 2.0.32

AI used: DeepSeek V4 Pro

Time used: 20 minutes for the first version, 20 minutes more polishing and adding features.

License: GPL 2

Gighub pages to use it: https://jmsanzg.github.io/sheetql/

Github code: https://github.com/jmsanzg/sheetql

Hi everyone,

I’m developing CANExplorer, an open-source desktop tool for monitoring, analyzing, diagnosing, simulating, and testing CAN devices on Linux, Windows, and macOS.

It combines everyday bus debugging with Python-based simulation and testing. You can inspect traffic, decode signals, simulate an ECU, and write regression tests in the same environment.

Some of its features:

Live analysis: filtered traces, changed-byte highlighting, signal plots, and bus-health statistics.

Recording and replay: ASC, BLF, CSV, candump, and other formats, plus triggered recording and comparisons between captures.

Signal databases: load and edit DBC, ARXML, LDF, and other formats.

Diagnostics: UDS over ISO-TP, CDD descriptions, ECU flashing, J1939 tools, and CANopen support.

Python simulation: create bus nodes that react to messages, send signals periodically, and interact with custom QML panels.

Automated tests: check responses, signal values, and cycle times; run headlessly and export HTML/JUnit reports for CI.

CAN interfaces are accessed through python-can. You can also try the included simulation and test examples on a virtual bus without hardware.

Code: https://github.com/AKJ7/CANExplorer

Documentation: https://akj7.github.io/CANExplorer/

I’d appreciate feedback —particularly on adapter compatibility, reliability under load, and workflows that still require custom scripts.

What would CANExplorer need to earn a place on your bench?

Yes, the code is built in Python but compile to C for the executables for performance.

Thanks, please star the project too.

I like to kick off my agents, shut the lid and head out. With the lid open, my Mac draws 16.7 W just on idle, and the screen eats most of it.

Pilot Light gets that down to 4.8 W with the lid shut while the agents keep working, so a battery that would last about 6 hours lasts 20+.

Benchmarked across 3x 10min tests:
With an agent building a website and testing every feature in a headless browser, it measured 2.3 Watts to completion.

Why it isn't just caffeinate:

• No caffeinate flag survives closing the lid. A lid close forces sleep unless you're on a charger with an external display plugged in. Pilot Light changes the actual sleep setting, so it works on battery with the lid shut.
• caffeinate only stops sleep. Pilot Light also switches on Low Power Mode when the lid closes, and puts your exact settings back when you open it.
• Extra safety features. If the Mac gets seriously hot in a bag, or the battery drops below your limit, it lets the Mac sleep.
• It shows you the measured power draw with the lid open and closed, so you can see it working.

It's one tiny Swift file (~1MB) with no third-party code, about 25 MB of RAM and no tracking, telemetry or accounts. MIT licensed.

Website: pilotlight.sudolabs.nz

GitHub: github.com/CyrisXD/pilot-light

I maintain mloda-registry, an open-source set of data operations (aggregations, windows, ranks, resampling) that run on PyArrow, pandas, Polars, DuckDB and SQLite. The hardest part is not writing five implementations. It is getting five engines to agree on edge cases.


Same tiny inputs, native defaults:


    engine    median     sum        max        sum           groups for
              [1, NaN]   [1, NaN]   [1, NaN]   [null, null]  keys 0.0, -0.0
    PyArrow   1.0        NaN        1.0        null          2
    pandas    1.0        1.0        1.0        0.0           1
    Polars    NaN        NaN        1.0        0.0           1
    DuckDB    NaN        NaN        NaN        null          1
    SQLite    no median  1.0        1.0        null          1


What we settled on:


- One engine is the reference (PyArrow), instead of a written spec that nobody can run.
- Every backend runs the same tests and has to match the reference.
- Where an engine can match, the implementation is fixed. Polars' all-null sum returns null in our code, not 0.
- Where it can't (pandas and SQLite can't keep NaN apart from null), the difference goes on a list, each entry with a test that pins it. A contributor who changes the behavior gets a failing test.
- When the reference is the odd one out (only PyArrow splits 0.0 and -0.0), it stays the reference. Picking a new reference per edge case brings the drift back.


The list and the tests are in the first comment. If you maintain something with several backends: how do you keep them in line?I maintain mloda-registry, an open-source set of data operations (aggregations, windows, ranks, resampling) that run on PyArrow, pandas, Polars, DuckDB and SQLite. The hardest part is not writing five implementations. It is getting five engines to agree on edge cases.


Same tiny inputs, native defaults:


    engine    median     sum        max        sum           groups for
              [1, NaN]   [1, NaN]   [1, NaN]   [null, null]  keys 0.0, -0.0
    PyArrow   1.0        NaN        1.0        null          2
    pandas    1.0        1.0        1.0        0.0           1
    Polars    NaN        NaN        1.0        0.0           1
    DuckDB    NaN        NaN        NaN        null          1
    SQLite    no median  1.0        1.0        null          1


What we settled on:


- One engine is the reference (PyArrow), instead of a written spec that nobody can run.
- Every backend runs the same tests and has to match the reference.
- Where an engine can match, the implementation is fixed. Polars' all-null sum returns null in our code, not 0.
- Where it can't (pandas and SQLite can't keep NaN apart from null), the difference goes on a list, each entry with a test that pins it. A contributor who changes the behavior gets a failing test.
- When the reference is the odd one out (only PyArrow splits 0.0 and -0.0), it stays the reference. Picking a new reference per edge case brings the drift back.


The list and the tests are in the first comment. If you maintain something with several backends: how do you keep them in line?

Hi! I've tried all recipe apps but they all need too many clicks and attention.

They want you to choose a date in a calendar, add ingredients to a list separately, get duplicate ingredients everywhere... or find a nice app but pay a subscription just to manage groceries.

So I tried to make the most convenient and modern app possible: Import recipes from anywhere (Instagram/YouTube/TikTok, websites or any pasted text) to curate your personal gallery, add meals to your plan in one click, and just throw extra items into the sidebar whenever you're out of something.

Everything gets combined and organized into aisles and it's easy to know if you're got everything to cook each meal. Check what you already have before shopping, then fly through the store.

I'm calling it Cuicuit 🐥 Hand-coded after 1 year of weekends here and there.

100% Free, open-source & self-hostable because I love open source!

• Website, try the hosted version in 1min: https://cuicuit.laclau.dev
• GitHub (would love a star 😄⭐): https://github.com/MadeInPierre/cuicuit

What do you think of this UX? Still early but I would love your feedback, thank you!

I made and designed a custom variant of chess with interesting rules a new way to play chess.

Can you defeat the bot?

The whole thing is open source and self hostable.

If you don't wanna go through the effort of cloning and building here's a playable demo:

https://w.run/retroblade892/anarch-chess

Lemme know what do you think about this, as this is a very ambitious project that I built.

My laptop is out for repair so you get the AI built demo for now, expect the original version hosted soon. Until then have fun and tell me what breaks.

Hello people of the interwebs!

For around 4ish weeks now I have been working on a simple command-line utility to easily license your open source projects and add compliant SPDX identifiers to the top of all your code files. The tool is called Linim!

Quick Summary of features:

- Single-Command Licensing: On first setup, the program automatically writes / updates the root LICENSE file, records copyright decisions to a .linim file (which you commit to your repo), and then injects proper compliant SPDX headers into every source file. Then, when you create new files and need headers to be injected, you just run the command linim and it does it. The tool supports basically every programming language under the sun so it knows the comment format.

- Interactive License Picker: A searchable prompt appears allowing you to select what license you want your project to have, from 18 embedded SPDX licenses from MIT to 0BSD. If a license needs you to put in the copyright holder and year, Linim handles that automatically. If your repository already has a license file, it will be auto-detected and you don't even have to go through the setup, Linim just auto sets-up.

- Preamble Preservation: Everything from shebangs to XML declarations to doctypes are preserved above the injected SPDX header.

- EXTREMELY FAST: Apart from it being written in Rust, it automatically skips the .git directory, it skips any files in your .gitignore, it skips hidden files, and it skips unsupported extensions. On top of all of this, it only reads the first 8 KB of each file and if the header is always correct, it ignores that file, if the file needs a change it goes back and reads the full file so it doesn't mess up the content. And finally, ON TOP OF ALL OF THIS, all files are processed in parallel.

Quick Benchmark:

178.2 Megabytes of 8004 Source Code files Across 12 Languages and Over 8 Nested Directories.

First Run (every file lacks a header): 358 ms (~22,400 files per second)
Second Run (all files already correct, zero writes): 44 ms

- Some Extra Features: Various CLI flags are included to reconfigure from scratch / change the license, to only create the license file without injecting headers, and to use a verbose logging mode.

The project is fully open source, and supports Linux, Windows, and macOS. Link to repo: https://github.com/wendellmeset/linim

This was a project I made to learn Rust, and as such I put a lot of effort into a plan and architecture before it was made. I'm sure something like this already exists but it was really fun to make, so try it out if you'd like and tell me if you like it!

I've been developing Crestr, a free and open-source hiking route planner, and I've recently implemented a mobile-friendly interface for the web app.

Until now, the interface was primarily designed for desktop use. I've spent time addressing core functionality such as route importing and exporting before returning to the mobile experience, which is now available without requiring a dedicated mobile app.

I'd appreciate feedback from people willing to try it, particularly on:

• Mobile usability and navigation.
• The route-planning workflow and overall UX.
• Any bugs or accessibility issues you encounter.
• Features or design decisions that could be improved.

There are still some known issues I'm working through, including onboarding tours that don't yet correctly distinguish between desktop and mobile layouts.

Project links

• App: https://app.crestr.co.uk/
• Source code: https://github.com/abdlfc11/Crestr-Hiking-App

Current limitations:

Routing is currently available only in Cumbria, UK. Expanding coverage is an ongoing technical challenge involving road and footpath graph construction, routing performance, and server resource constraints.

The app is free to use, and contributions, bug reports, and constructive criticism are welcome.

One final note: Reddit's in-app browser has some layout issues with the bottom stats panel and attribution controls, so I'd recommend opening the app in your regular browser when testing it.

Thanks for reading !

Since Android 14, Android has official support for bit-perfect playback over USB DACs where the mixer is bypassed and your DAC receives the original audio, at its own sample rate and bit depth. The catch is that having Android 14 isn't enough. The phone manufacturer has to enable it in the phone's audio configuration, and the music app has to request it. In practice, it's very hard to know which phones actually support it before you buy one. As far as I've read or heard, some Pixel phone models (8 and above), some Samsung Galaxy Phone models (S22 and above) and the Motorola Signature have support but a real confirmation with pictures or videos is hard to find on the internet.

So I built Bit-Perfect Audio Detector, a small app that checks it for you:

🎯 Bit-perfect support: reads the manufacturer's audio configuration and, with a USB DAC connected, confirms it with Android's own API.

🎚️ Hi-Res audio: shows the maximum resolution your phone offers through USB, with and without a DAC.

🎵 Compatible apps: lists the music apps on your phone that use Android's native bit-perfect mode (and suggests others).

📋 Send Report: The app has a "Send report" button that sends your results anonymously: no name, email or anything that identifies you, and you can review everything before sending. I review each report and add the phone to a public table, so other audiophiles can check which phones have native bit-perfect support before buying one. Right now the table is tiny, so every report counts, whether your phone supports it or not, with or without a DAC. The report server is open source and stores nothing.

📣 Ask the manufacturer: if your phone doesn't support bit-perfect, the app gives you a ready-to-post request with your phone's details and what the app found, and opens your manufacturer's community forum, in your language when there is one. The more people ask for it, the more likely it is to arrive in an update.

🔓 Free and open source (GPL v3), with no ads. The app only uses the internet to send the report, and only when you tap "Send". 🔒 Nothing leaves your phone unless you choose to send a report.

📥 Download the app from the Bit-Perfect Audio Detector GitHub repository today!.

Feedback, bug reports and feature ideas are very welcome. Thanks! 🎶

Hey, guys.
I've been working on Gofer for several months now. It's an email client with special care on multi-account support. It also has Contacts and Calendar

This is a project that I started and dropped like 5 times in the last several years. I finally committed this time!

I was tired of email clients with poor multi-account support or built in PHP (ew)

It's fully open source, built in Go + HTMX, and it uses SQLite as a DB.

The app is not 1.0 yet, but I use it daily with several accounts and I'm improving it constantly.

To be honest I'm not 'selling' anything here, I just think the software came up decent and It's always nice to have the open source community to join and help. So any criticism is welcomed, the idea is to improve!

Mandatory disclaimer: AI was used for this project. I mean you can tell just by checking the amount of code commited in 6 months, but it makes sense to clarify. I still plan every step, make every decision, manually test every single implementation. I'm a software engineer working on the field for 18 years now.
I'm not a 'vibe coder'. I'm just a very bad coder that found help on new tools

No AI was used to write this post!

Github repo: https://github.com/cristianadrielbraun/gofer

It also has its own website, because why not: https://gofer.email

I hope you like it as much as I do 😄

ArtCraft gained a lot of steam lately with their AI reverse engineered versions of Photoshop and Adobe suite apps.

While they are very obviously reverse engineered, they claim it is a "clean-room reimplementation of Adobe Photoshop" which by very definition means "without ever looking at or copying the original source code".

Fireship even did a video covering these apps, in which he finds their apps are barely usable, and filled with bugs and usability issues.

Today I came across "TraceDraw" which is, again, a total ripoff of CorelDraw. While I'm not on the side of large predatory corporations like Adobe charging ridiculous monthly subscription fees, I can totally understand the pain a company like Corel might feel seeing a ripoff of their 30+ year old product lovingly created and maintained by a team of skilled HUMANS. And once again, this repo claims it is a "clean-room" implementation. I find it ironic how only the reverse engineered apps bother to add this oddly specific disclaimer.

So are we, as a community, okay with these new breed of AI reverse engineered apps claiming that they are "open source"?

(Note: I'm not questioning their legality, just how ethical it is)

Hi,

A small background on me: I have been programming/modding games since the mid-2000s. I wanted to start a gaming company and develop a game in college. That didn't work out, but as a result I started a company in 2017, doing freelance work for games and, along with that, game-adjacent stuff.

Around 2018 we pivoted into doing R&D and finding clients who would want these products. This has worked decently. At the same time, I have been working on products to release something. These are small sales that keep me afloat, and I have not been able to get something of my own out.

In the last 10 years, I have worked across multiple client projects and domains. Along with that, internally I have worked on multiple unreleased projects, planning to get them out to market, getting investment, sales etc. Most didn't reach the polishing stage internally for me to work on them further.

Coming to the actual product, I am planning to market it as a Universal Inference Stack. I worked on parts of it in 2016, when I was working on some game AI and learning ML, parts of it in 2019-2020, and parts of it in 2025-2026. No name revealed yet.

It's a framework that allows you to build agent systems, do reality modeling and reality simulation, and I am currently using it across multiple projects that I am working on for clients.
The reason for development was internal only, but throughout the development I realized we were making something that didn't exist, and there is a big market for it. I have shown the product to multiple enteprise people and they have an intrest for it.

I am not sure how much I can reveal before getting it out, but I have plans to tie up with a few researchers and release some papers about it before releasing.

Coming to the actual topic, my reasoning behind going open source is as follows:

1. If something like this already existed, I wouldn't have created this, so I am sure people will have similar problems.
   
2. I will have to get the research papers out anyway, and it wont be difficult to recrease it for it.
   
3. I want to get this into the hands of as many people as possible, and I see a lot of developers who could actually use this.
   
4. It will actually help multiple developers control the billing of LLMs and have more control over their process.
   
5. Along with this, my goal is to release all features possible so the user can host, do diagnostics etc. 6. I see these features locked on similar platforms.
   
6. I think this will make the implementation of intelligence systems more streamlined compared to what we have now.
   
7. More eyes on this would be better for the system in the long run.
   
8. It matches what I believe about software and open source.
   

Coming to the next topic, my initial goal was to release it under a very open license like MIT, but multiple people are saying to keep something closed. I don't want to keep parts of the framework closed, as there is no point in that.

My idea has been to patent something from it, then go Apache 2.0 and release all the papers and the framework together.

I have also been planning to release a kind of representation/notation framework along with the software, and I want to introduce a new kind of thinking with this.

License-wise, I have not thought it through yet, but I want it to be open source for everyone up to companies at around $1 million annual revenue, then a fixed cost per bracket, something like the PolyForm Small Business License.

Along with this, the goal is to create a marketplace and take a small cut from it.

I am not sure how much success I will get. I am considering that we have built something, and even from the service side, if I can enter a few industries and have strong products in them, that alone i am considering as well, if the above open source strategy doesn't work out.

My hope for this is to be a kind of new understanding framework for developers on how intelligent systems are planned, created and understood, and pave the way for future development. This is me being hopeful, and a target.

This is my potential business plan along with going open source. I just wanted to know what your thoughts are about this in the community, is it the right way, etc.

I will release more information about this in time, as there is quite a bit to do.

The security of open source applications was already criticized enough before AI, but now legitimate concerns can be made. The effect is not as pronounced as it will be in the future, since many stable projects still have enough "manual" developers left on their team to reasonably understand the submissions that are being made. But what happens when vibe coders start to take over these apps? How can those that do not understand the code that is being submitted reasonably validate that malware is not being added? It would be trivial for a state actor to mask malware and get it past a reviewer that has little to no understanding of the language itself (even if it takes multiple submissions).

Several of these viral vibe coded apps have hundreds of contributors and are merging large PRs at a pace that simply does not allow for a proper analysis to occur (security or otherwise). It's more like, "test merge the code", "looks like it fixes the problem", "approve PR". How can companies, or individuals for that matter, that are concerned about the security and integrity of their systems ever use these applications?

I know the some will say, "run it in a VM" or "it's your choice to download it", but those aren't practical solutions. All it will take is a few high profile security incidents with these apps for people to start questioning the open source model with vibe coding.

Open Co-Scientist is an open-source recreation of Google's AI Co-Scientist. It's a multi-agent system that generates research hypotheses, critiques them, ranks them in an Elo tournament, and evolves the winners.

What it does

You describe a research goal in chat. The system then:

• Searches literature for grounding
• Generates hypotheses with a team of agents
• Runs pairwise debates and ranks the ideas by Elo
• Evolves the top ideas
• Checks every citation and writes a final report

I'm looking for feedback and help developing this. I believe it could be a great contribution to the open-source AI for Science community, and I want to make the most of it!

Try it out at: open-coscientist.com

G-remap is a lightweight Linux bash script that quietly swaps your Google Maps links for Brave Maps — no extensions, no browser tinkering. Just paste a Google Maps URL, and the script parses it with Python, converts the coordinates and bounds into the current Brave Maps format, copies the new link to your clipboard, and launches it in Brave.

It's built for privacy-first users who don't want Google tracking their location clicks. The tool uses zenity for friendly dialog prompts, handles short-link expansion via curl, and auto-detects Brave across Debian, Fedora, Arch, OpenSUSE, Flatpak, and standalone installs. If your clipboard isn't available, it still prints the converted URL so you're not stuck.

Why it's useful:

• zero config required
• Supports all major Linux distros out of the box
• Graceful fallbacks for browser detection and clipboard tools
• GPL-3.0 — truly free and open source

TL;DR: It's a one-click privacy bridge between Google Maps and Brave Maps, written in pure bash + Python, designed to be simple, fast, and distro-agnostic. A small tool, but a smart one for anyone trying to break out of Google's ecosystem.

Hi, everyone,

as you know, I have been releasing Linux drivers for a while.

When using USB dongles, it has come to attention the CSR8510 (a specific CSR Bluetooth dongle clone). was being detected as a generic CSR clone, so it would not work at all under Linux.

The TP-Link UB500, on the other hand, apparently IS supported by the kernel, but only a few revisions. And mine wasn't.

So, we had one device that would never work under Linux, and another that maybe could, but was a pain to configure.

But not anymore!

I'm presenting you new Bluetooth dongle drivers compatible with Ubuntu, Debian and Mint!
While you can download and build from the source, I'm also making binaries pre-available for them.

And because I couldn't find a hotspot program that is easy to use, I'm also releasing Magic Hotspot, which integrates well with these drivers. Devices are scanned automatically, and you can connect through USB, Wi-Fi or Bluetooth.

If you guys are interested, the releases are available here.

• Magic Hotspot: https://github.com/NullMagic2/magic-hotspot
• TP Link UB500: https://github.com/NullMagic2/tp-link-ub500
• CSR8510 https://github.com/NullMagic2/csr8510

Limitations: I have a CSR8510 clone, so while the device poses as the real thing, not all functionalities are implemented in the actual hardware. This means audio connections are dropped after 30 seconds. Sadly, this is a hardware issue. The TP Link UB 500 works as it should.

Disclaimer: This project is developed for personal interest, with no intent of being useful to anyone. If it is interesting or useful to you, that's good, but not a goal.

It’s available as an HTTP gateway and Java library for controlling expensive server side work. Equivalent requests can share a computation, new work runs within explicit limits, and saved results can be reused across restarts.

I’ve been using it internally for a website struggling with bot traffic. It worked for that specific use case and I also tested it against a separate cgit application and the results were reasonable. But there’s a trade off as it shows higher latency overhead.

The benefits depend heavily on the workload, so keep that in mind if you want to experiment with it. I wouldn’t recommend it for production use. Some of its core capabilities are useful, though, and I’d encourage anyone interested to pilot it in staging and measure the results before considering anything further.

And yeah just to clarify the gateway isn’t a replacement for authentication, tls termination, rate limits and waf controls. It does not identify bots or stop incoming traffic, it helps controlling expensive computation load.

https://github.com/aalsanie/bounded-origin

Hello, I had built Better Windows Services an alternative to windows services with dark theme, query language, mass actions, force stop/restart, export of services and tons of extra data. If you like the project, please give it a star

You can read here about about query language

Yes the strange text on the GIF is from Polish Windows :-), right now I'm working on snapshots from the GUI, msi installer and tons of other things. Rust + WPF.

Some features:

• Ask, instead of scroll - start:auto !status:running is what should be up and is not. One language, in the search box and in bws list --query, with the fields offered as you type.
• Show the plan before anything happens - every stop, start, restart and start type change is previewed with the services it takes down with it, and the preview is what runs.
• Tell you what drifted - bws snapshot create freezes the machine into a file, and bws snapshot diff says what changed since, configuration apart from what merely started or stopped.
• Stop a service that will not stop - it asks politely first and ends the process only if that fails, naming every other service that lives in it.
• Show what services.msc hides - who signed the binary and whether Windows trusts it, triggers, privileges, the security descriptor, the process and its memory. As columns, and as things to search on.
• Say when it could not read something - a field it could not read is reported as not read, never shown as empty. A snapshot taken without administrator rights says so inside the file.
• Fit into scripts - --json on every command, an exit code for every ending, and 5 when a diff finds drift.
• Run from one file, offline - no installer, no .NET to install, and it never talks to the internet. Reading needs no administrator rights. GPL-3.0.

GitHub