what's the best way to play hdr on sdr screen?

I really like windows movies and tv but recently somehow it can no longer play 6 channel dolby audio and I don't know how to fix it

I tried vlc and mpc hc, but none of the video players have matching video qualities of windows m&t, and I don't know how to tune the mapping

somehow somewhat I think the windows movies and TV utilize my screen dynamics more than other players when converting hdr to sdr, even though it's sdr the brighter parts are brighter and the darker parts are darker than vlc and mpchc and other video players I tried, and I found pot player to be the worst with so much noise in both video and audio quality.

So how do I fix my windows movies and TV or how do I tune my vlc converter to fit my screen better?

https://redd.it/1more90
@r_opensource

API Live Sync #2: Live Source Data Structures and Types
https://creative-labs.hashnode.dev/api-live-sync-2-live-source-data-structures-and-types

https://redd.it/1mos7ys
@r_opensource

Germany: No digital sovereignty without open source, warns OSBA
https://www.heise.de/en/news/No-digital-sovereignty-without-open-source-warns-OSBA-10518946.html

https://redd.it/1mov6za
@r_opensource

sshPilot, an opensource alternative to Putty and Termius

I've recently released sshPilot.

It's a desktop app (linux-only) for managing your remote servers with ease.

You can copy public keys, upload files, configure ssh tenelling and more right from the app.

No need to add and remember aliases anymore.

Please read the full feature list on GitHub, and feel free to share your thoughts/feedback.


https://redd.it/1mowar9
@r_opensource

Kafe - a TUI tool for Kafka cluster observability

I am a huge fan of K9s to interact and explore AWS contexts and what is going on in different clusters

I have seen some alike tools to explore kafka clusters, but they were too rare. Going through a kafka cluster feel more cumbersome than it should be, so I hope that I can eventually build something that make a lot of people's life easier :)

I hugely appreciate any suggestion on what direction to take this. What would be your needs, around the topics, messages, consumer groups, etc...

The repo can be found at https://github.com/clemsau/kafe

https://redd.it/1moxjwv
@r_opensource

Meet DocPilot – My little open-source doc manager (MVP stage)

Hey everyone,

I built DocPilot because my Downloads folder was… chaos. You know the kind , hundreds of random PDFs, images, and files I *swear* I was going to organize “later.” One weekend I thought: *why not make something that not only fixes my mess, but could be useful for anyone… and free?*

So I started hacking, and here’s what I’ve got so far:

* **Backend:** A simple Flask API that uses the **phi-3 LLM** from Ollama (runs locally, you’ll need to install Ollama separately).
* **Frontend:** Built with Electron.js for a clean, cross-platform desktop interface.
* Current features: browse documents, upload, preview, and start organizing.

It’s still just an **MVP** , no fancy polish yet , but the goal is to make it a lightweight, privacy-friendly document manager anyone can run.



**Links:**

Backend: [https://github.com/naodt1/doc\_pilot\_backend](https://github.com/naodt1/doc_pilot_backend)

Frontend: [https://github.com/naodt1/doc\_pilot\_frontend](https://github.com/naodt1/doc_pilot_frontend)

I’d love feedback on what works, what’s missing, and what would make this genuinely useful in everyday life. Contributions, ideas, or even “this broke on my machine” comments are more than welcome.

If your Downloads folder is as scary as mine used to be, give DocPilot a spin.

https://redd.it/1moxsv2
@r_opensource

What are your wishes for a package manager?

I'm currently creating a universal package manager and I'm curious what are your wishes for a universal package manager.

What something you wish for, a feature you want, or a platform you want it to support (obviously not replacing the native package manager).

For anyone who's curious here's the link to the repo

https://redd.it/1moysq3
@r_opensource

Question about GPL and AGPL webapps

Hi all!

I want to write a webapp that will have a GPLv3 licensed frontend and a (most likely) AGPLv3 licensed backend.

That webapp will be a 3rd party tool for a game so when I refer to "organizations" or "orgs" I basically just mean a group of players that use a common group name and maybe even have their own IT infrastructure to track where they leave items and maybe financials (ingame currency).

My goal is to allow users to

* Self host their own version of the webapp (without modifying it, just hosting their own instance to be in control of their data)
* Self host their own version of the webapp with modifications to the frontend to their organization
* Self host their own version of the webapp with modifications to (the frontend and) the backend to their organization
* Self host their own version of the webapp with modifications to (the frontend and) the backend *publicly* but so they need to disclose their changes to the frontend and backend.


===

As I understand it right now whenever they just use it privately (so a single person uses it or a organization uses it) they can keep changes closed. I want that, its the only way for people to integrate their own IT infrastructure into the tool. I wont to provide a platform for people to build up on.

**Here is my first question:**

When an organization hosts their own version of the webapp, is simply putting a login screen into the frontend enough? The app still gets send to the clients browser after all, but its locked until you get authenticated by the backend.

If that is not enough how can I allow self hosters and modders to host their own version of the webapp privately?

===

Another thing I am unsure about is the backend. I want to license it under AGPL so that when people modify it, then they also need to make the modified backend open source.

Modifications may be anything, including:

* Adding a different API which provides the same item, trading price, mining survey, salvage survey, etc. data. (Most data is collected by players so at any point a new API could show up that has higher quality data.)
* Adding a new tool to the backend (maybe the ability to add bookmarks and save them in the database)
* Changing a tool in the backend (maybe improving caching for a tools 3rd party API so it has faster response times)

What I am concerned about is that people might just hide their super new tool implementation by adding a wrapper into the AGPL backend and have it interface with a separate closed source backend.

**Here is my second question:**

I know that tight integration is counted by the GPL license as one program but if we talk about moving logic into a proprietary API, which is required for the feature in the AGPL backend to function are we still within the space of "this is one program dude, you need to release hiden service as AGPL"?

And similar there are these 3rd party APIs which provide data. Obviously I cant start to force them to start becoming AGPL. How is that handled when someone opens their own 3rd party data API and provides a proof of concept implementation for that API in their own self hosted instance of the webapp?

===

I hope I explained my two dilemmas well enough.

Thanks for any help in advance.

https://redd.it/1mp0gqq
@r_opensource

Open Source SigNoz MCP Server

we built a Go mcp signoz server

[https://github.com/CalmoAI/mcp-server-signoz](https://github.com/CalmoAI/mcp-server-signoz)

* `signoz_test_connection`: Verify connectivity to your Signoz instance and configuration
* `signoz_fetch_dashboards`: List all available dashboards from Signoz
* `signoz_fetch_dashboard_details`: Retrieve detailed information about a specific dashboard by its ID
* `signoz_fetch_dashboard_data`: Fetch all panel data for a given dashboard by name and time range
* `signoz_fetch_apm_metrics`: Retrieve standard APM metrics (request rate, error rate, latency, apdex) for a given service and time range
* `signoz_fetch_services`: Fetch all instrumented services from Signoz with optional time range filtering
* `signoz_execute_clickhouse_query`: Execute custom ClickHouse SQL queries via the Signoz API with time range support
* `signoz_execute_builder_query`: Execute Signoz builder queries for custom metrics and aggregations with time range support
* `signoz_fetch_traces_or_logs`: Fetch traces or logs from SigNoz using ClickHouse SQL

https://redd.it/1mozqrx
@r_opensource

Funding Open Source like public infrastructure
https://dri.es/funding-open-source-like-public-infrastructure

https://redd.it/1mp1jrd
@r_opensource

ID Verifier - helping us avoid another Tea app fiasco
https://github.com/universal-verify/id-verifier

https://redd.it/1mp39u1
@r_opensource

Markdown-ui: Render UI Inside Markdown At Runtime

Currently markdown is used widely across documentation, blogs and AI output for its simplicity and content-first focus. But they do not allow users to interact with the content.

Existing attempts like MDX, web components, and embedding html/jss directly in markdown are compile time only, non-portable, and security risks.

This is why I created Markdown UI, an open MIT standard for easily embedding UI in markdown. The UI widgets are just simple JSON objects inside the markdown and are parsed into web component XML tags. Then any renderer (React/Svelte/Vue/Swift etc.) can render the component into actual UI on the platform and emit standardised {id, value} events to the application for capturing and processing.

The standard is designed to be minimal, extensible, and secure.

Here is the live demo: markdown-ui.com

Here is the GitHub: https://github.com/BlueprintDesignLab/markdown-ui/

https://redd.it/1mp5f5c
@r_opensource

Apache 2.0 900+ Neural TTS Voices 100% Local In-Browser with No Downloads (Kitten TTS, Piper, Kokoro)

Hey all! Last week, I posted a Kitten TTS web demo to r/localllama that many people liked, so I decided to take it a step further and add Piper and Kokoro to the project! The project lets you load Kitten TTS, Piper Voices, or Kokoro completely in the browser, 100% local. It also has a quick preview feature in the voice selection dropdowns.

# **Online Demo** (GitHub Pages)

Repo (Apache 2.0): https://github.com/clowerweb/tts-studio

The Kitten TTS standalone was also updated to include a bunch of your feedback including bug fixes and requested features! There's also a Piper standalone available.

Lemme know what you think and if you've got any feedback or suggestions!

If this project helps you save a few GPU hours, please consider grabbing me a coffee! ☕

https://redd.it/1mp3sk4
@r_opensource

A Technical Deep-Dive for the Security-Conscious- Persistent Memory CLI Tool-Free to Use

Since transparency and verifiability are core to the project, here’s a deeper dive into the technical implementation.

The entire security posture is built on a zero-trust, local-first foundation. The tool assumes it's operating in a potentially untrusted environment and gives you the power to verify its behavior and lock down its capabilities.

1. Verifiable Zero-Egress

We claim the tool is air-gapped, but you shouldn't have to take our word for it.

How it works: At startup, the CLI can monkey-patch Node.js's http and https modules. Any outbound request is intercepted. If the destination isn't on an explicit allowlist (e.g., localhost for a local vector server), the request is blocked, and the process exits with a non-zero status code.

How to verify: Run agm prove-offline. This command attempts to make a DNS lookup to a public resolver. It will fail and print a confirmation that the network guard is active. This allows you to confirm at any time that no data is leaving your machine.

2. Supply Chain Integrity for Shared Context: The .agmctx Bundle

When you share context with a colleague, you need to be sure it hasn't been tampered with. The .agmctx bundle format is designed for this.



When you run agm export-context --sign --zip:

Checksums First: A checksums.json file is created, containing the SHA-256 hash of every file in the export (the manifest, the vector map, etc.).

Cryptographic Signature: An Ed25519 key pair (generated and stored locally in keys) is used to sign the SHA-256 hash of the concatenated checksums. This signature is stored in signature.bin.

Verification on Import: When agm import-context runs, it performs the checks in reverse order:

It first verifies that the checksum of every file matches the value in checksums.json. If any file has been altered, it fails immediately with exit code 4 (Checksum Mismatch). This prevents wasting CPU cycles on a tampered package.

If the checksums match, it then verifies the signature against the public key. If the signature is invalid, it fails with exit code 3 (Invalid Signature).

This layered approach ensures both integrity and authenticity.

3. Policy-Driven Operation

The tool is governed by a policy.json file in your project's .antigoldfishmode directory. This file is your control panel for the tool's behavior.

Command Whitelisting: You can restrict which agm commands are allowed to run. For example, you could disable export-context entirely in a highly sensitive project.

File Path Globs: Restrict the tool to only read from specific directories (e.g., src and docs, but not dist or node_modules).

Enforced Signing Policies:

"requireSignedContext": true: The tool will refuse to import any .agmctx bundle that isn't signed with a valid signature. This is a critical security control for teams.

"forceSignedExports": true: This makes signing non-optional. Even if a user tries to export with --no-sign, the policy will override it and sign the export.

4. Transparent Auditing via Receipts and Journal

You should never have to wonder what the tool did.

Receipts: Every significant command (export, import, index-code, etc.) generates a JSON receipt in receipts. This receipt contains a cryptographic hash of the inputs and outputs, timing data, and a summary of the operation.

Journal: A journal.jsonl file provides a chronological, append-only log of every command executed and its corresponding receipt ID. This gives you a complete, verifiable audit trail of all actions performed by the tool.

This combination of features is designed to provide a tool that is not only powerful but also transparent, verifiable, and secure enough for the most sensitive development environments.

I would love your feedback.

You can check out the source code on GitHub: https://github.com/jahboukie/antigoldfish

If you find it useful, please consider sponsoring the project:

Building an open source P2P password manager: Looking for collaborators

Hello all who read,

I am looking for collaborators to build a truly P2P password manager from scratch that is robust, extensible, and wholly secure.

Most current password managers store data in the centralized cloud servers, creating attractive targets for attackers. A P2P approach puts users in complete control of their data--eliminating the honeypot problem whilst shifting security responsibility to the individual users. Such an approach, I believe, would lead to a higher ceiling of security, which may be of interest to many users--particularly those who value privacy and examine app architecture to determine their security.

Right now, Rust with the libp2p library is the stack I am thinking of, primarily for performance and cross-platform support, but I am open to discussion on the stack.

The key goals of this project include:

\- True P2P sync (no servers)

\- Strong conflict resolution

\- Cross-platform (desktop/mobile)

\- Usable UX and CLI option for power users

I am looking for developers interested in P2P networking, cryptography, systems programming, or just people passionate about privacy tech.

I have a decent amount of experience in both Rust, specifically in lower level graphics and networking, and some experience with libp2p. I also have experience with JS, TS, Go, Python, C, Cpp, and other languages, but most of my networking experience lies in Rust and Go. Here is my GitHub if anyone wants to take a look: https://github.com/gituser12981u2.

Here is the GitHub link to the project:

https://github.com/gituser12981u2/p2p\_password\_manager

There is not much code yet since I want all us collaborators to make architectural decisions together. I have a CI pipeline setup and plan to make ADRs for any decisions.

As I said, this would be a collaborative effort--let us figure out the architecture together.

Anyone interested in exploring this?

https://redd.it/1mpb2et
@r_opensource

I rebuilt the Eisenhower Matrix for modern use, here’s why

A few months ago, I was looking for a simple, focused Eisenhower Matrix app.
I wanted something clean, distraction-free, and fast, but everything I found was either outdated, bloated with features I didn’t need, or just… ugly.

So, I decided to build my own.

This week, I released version 2.0, shaped entirely by feedback from the small group of early users. The interface is fully redesigned with a calmer, more focused look, and I finally added due times and smart notifications so tasks don’t slip through the cracks.

What I’m most proud of is that it’s still minimalist. No endless menus, no complex setup. Just four quadrants to sort your tasks, and a few thoughtful touches to make it more human.

If you’re curious, the project’s open-source and you can check it out here:
🔗 **github.com/Appaxaap/Focus**

I’m curious, for those who’ve tried using an Eisenhower Matrix (or a similar system), what’s the one feature you wish more productivity apps had?

https://redd.it/1mpc25k
@r_opensource

Amical: Open Source AI Dictation App. Type 3x faster, no keyboard needed.
https://github.com/amicalhq/amical

https://redd.it/1mpclv6
@r_opensource

Bulk email verifier

Found these 2, i was curios if you tested it or if you have any other alternative:

https://github.com/truemail-rb/truemail-rack

https://github.com/reacherhq/check-if-email-exists

https://redd.it/1mpg3xw
@r_opensource

Open-source ATS-friendly resume builder focused on privacy

I’ve built an open-source CV builder designed to create resumes that are ATS-compatible and privacy friendly. All processing happens locally in the browser, with no servers or external tracking involved.

The application supports six professional templates, real-time preview, instant PDF generation, and multiple languages (Portuguese, English, Spanish). Data is stored only in the user’s browser and can be exported or imported via XML.

Built with Next.js 15, TypeScript and Tailwind CSS, it’s fully responsive and works on desktop and mobile. Licensed under MIT.

GitHub: https://github.com/goncalojbsousa/EasyPeasyCV
Live demo: https://www.easypeasycv.com

Feedback and contributions are welcome.

https://redd.it/1mpke1a
@r_opensource

Right to Repair: An Open Source Approach to Hardware Freedom
https://brainnoises.com/blog/the-ethical-battle-for-the-right-to-repair/

https://redd.it/1mplkmp
@r_opensource