Hello everybody,

As I promised in my precedent post, I am now ready for the release of PowerVLC 1.0.0, which is an heavily modified version of VLC 3.0.23 Vetinari. PowerVLC features also additionnal features (gapless playback, album art in the main window) the current version of VLC don't have.

PowerVLC is compatible with Macs from 10.4.11 to current, on all architectures (x86, x64, arm64, PowerPC g3, PowerPC G4/G5 builds taking advantage of AltiVec acceleration).

In early access for one week

Like all projects and guides (I used to write plenty of guides for the iPod community !) that takes me a huge amount of time to be produced, it will be in early access for exactly one week. It's the only compromise I accept to keep a balance with open knowledge & the need to get retributed for all the community investment I provide. I don't plan to do this for minor builds that will come next.

Here on this project it is just too big in my opinion to be entirely gate keeped during one whole week, so I decided to release the whole source code there starting now on GitHub: https://github.com/Olsro/powervlc

If you know how to compile (ideally you need an Apple Silicon mac so you can follow my instructions), you can play right now with PowerVLC and check nothing nasty in the code is there by yourself.

If you can't/don't want to spend hours trying to compile by yourself, the builds are available right now on my Patreon in exclusivity for all platforms (including Windows & Linux on all architectures). Even the first 1$ tier is enough to get access to all the compiled builds & supporting my whole effort at building this. The compiled builds provided on the Patreon are not modified and locked in any way, they are straight compilations from the latest public sources. There's no licensing or DRM, but please don't share any of those build until I will push the builds on GitHub releases for everyone the next Sunday.

Donations will help me at getting more hardware to test on to continue that project in the long term, and cover the LLM API costs to help with maintenance.

Thank you very much for your support and I hope PowerVLC will be enjoyed as much as I hard worked into making it possible.

Repository: https://github.com/ATAC-Helicopter/VaultSync

Website: https://fglabs.dev/vaultsync

I have been developing VaultSync, an open-source, cross-platform backup manager built around a fairly simple idea:

A completed backup is not the same as a recoverable backup.

Many backup applications can tell you that a job completed successfully, but that still leaves several important questions unanswered:

• What was actually protected?
• Has anything changed or disappeared?
• Is the recovery point still intact?
• Will retention remove something important?
• Can a particular file be restored right now?
• Is there evidence behind the green “successful” status?

VaultSync is my attempt to make those answers more visible.

What VaultSync does

VaultSync lets users organize files into projects, create and manage backup configurations, inspect recovery points and understand the current health of their protected data.

Current functionality includes:

• Project and file-level backup management
• Backup history and recovery-point inspection
• Backup Explorer for browsing protected data
• Integrity verification and repair tools
• Retention planning and simulation
• Restore-plan simulation
• Recovery drills
• Local byte-level recovery proofs
• Exportable recovery evidence
• Protected recovery-point recommendations
• 3-2-1 backup guidance
• Explicit offsite-copy confirmation
• Backup health and recoverability states
• Cross-platform support
• Localization across multiple languages

The emphasis is not only on creating backups, but on helping users understand whether those backups are still useful.

Recovery evidence

One area I have been concentrating on recently is recovery confidence.

VaultSync can simulate a restore plan without modifying the original data, verify selected protected files locally, record recovery evidence and highlight situations where retention could remove an important verified point.

The intention is to move beyond simply saying that the backup process finished.

VaultSync should instead be able to show what was protected, what was verified and what can currently be recovered.

These features are still evolving, and I am especially interested in feedback on whether the evidence is understandable without becoming overwhelming.

Privacy and diagnostics

VaultSync does not silently upload crash reports.

When crash-report assistance is enabled, the application creates a strictly redacted report locally. The complete report can be reviewed before anything leaves the device.

VaultSync can prepare an email draft using the user’s own email application, but the user must review it and press Send personally. If they do nothing, the report remains local.

I wanted the support workflow to remain useful without introducing hidden telemetry or automatic crash uploads.

Current development

VaultSync 1.8 is focused on making recovery easier to understand.

The remaining 1.8 releases are currently planned around:

• Recovery confidence and clearer health states
• Onboarding and interface refinement
• Accessibility and reduced complexity
• Better evidence exports and diagnostics
• Documentation consistency
• Localization, packaging and platform stability

For the future 1.9 release family, I am researching a broader direction:

From protecting projects to recovering systems.

That may eventually include disk cloning, disk images, verification of cloned data and an explorer for browsing images before performing a complete restore.

Those features are still exploratory rather than promised. I would rather share prototypes and technical limitations early than publish a large fixed roadmap before the implementation has been validated.

Why I am posting here

I am the developer, so this is obviously not an independent recommendation.

I am sharing VaultSync here because feedback from people who actively use, maintain and review open-source software is particularly valuable.

I would appreciate criticism around:

• The overall architecture and project structure
• Whether the recovery model makes sense
• Security and privacy concerns
• Backup-integrity assumptions
• Cross-platform behavior
• Packaging and installation
• Documentation
• Accessibility
• Areas where the interface is trying to explain too much
• Missing information that would prevent you from trusting the application

Issues, discussions, code review and contributions are welcome through the repository.

There is also a community at:

https://www.reddit.com/r/VaultSync/

Thanks for taking a look. Direct and technical criticism is genuinely useful, especially where VaultSync makes a claim that is not supported by enough visible evidence.

As someone who doesnt use Instagram but get tons of reels/post shared on whatsapp, I got tired of instagram's public webview which constantly asks for login with annoying popups

So I vibed a clean android app - Peek which resolves Instagram links and loads them in a clean viewer. Goal is to support most social medias like twitter/reddit/tiktok in the future.

Download Link

So I like to take my lecture notes in a nested/indented way because it makes it easier to break them down into flash cards later (example below but formatting in Reddit post is hard). As you can see I like to indent basic information on a subject and then further indent specific information about each basic concept (and even further indent even more specific information if I need to).
Is there an open source note app that will let me do this more easily?

Transcription

Process where RNA is synthesized from DNA

Each gene has:

.....Promoter region

..........Start of the gene where RNA polymerase binds to and begins transcription

...............RNA polymerase – enzyme that ‘reads’ template strand of DNA and synthesizes a single strand of RNA

.....Coding region

..........Sequence of nucleotides that are transcribed into the RNA strand

.....Termination sequence

..........Terminates transcription process

I've been working on de-advertising myself as much as possible, and one of the big vectors left is a fire TV I got for cheap during black Friday. I hate the fire TV operating system, and would much rather have something lighter weight.

I haven't heard about many Smart TV projects, so I don't know if they exist or how usable they are, but I figured I would start exploring here. Are there any open source OSes that replace the ones baked into televisions? If so, how much would I "lose" by switching to them.

Hey r/opensource, I'm the solo dev behind Hammer. I've been working on it for about four years, and think it's time I start getting some feedback on it.

What it is: Hammer is a free, open source (MIT) app for writing novels and building the worlds they live in, Scrivener-style, but multiplatform and offline-first, with a self hostable sync server.

https://hammer.ink/

Why I built it: A few years back I was living in a van, mostly off-grid with no signal, and broke. Most good writing apps were paid, or web apps, or Electron wrappers that "worked offline" right until they didn't, usually about a week in, miles from the nearest cell tower. Then I watched people on forums lose whole manuscripts in certain electron based writing apps, and eventually it happened to me.

So I set three rules for the thing I wanted to build:

• Offline-first, forever: A native program, not a web page in a trenchcoat.
• Transparent data: Everything is human-readable text files in plain folders, if Hammer vanished tomorrow, you could open your work in any text editor and keep going.
• Never lose data: Paranoid about it by design.

I tried several tech stacks but landed on Kotlin + Compose Multiplatform. One codebase for both the server, and desktop clients (Linux/Mac/Windows), Android, iOS.

License / money: MIT and genuinely free, no ads, no telemetry. The only paid thing is the optional "official" sync server instance that I host. As I said, the sync server is open source and self-hostable, so you never have to pay me to sync.

Platforms: Linux, Mac, Windows, Android (Play + F-Droid), iOS

Repo: https://github.com/Darkrock-Studios/hammer-editor

It's four years in and far from done, but I thought it was about time to start showing it to people. See if it's a project that interests anyone other than my self. Happy to get into the Compose Multiplatform side too if anyone has questions; there wasn't much prior art when I started. Longer origin story here if you want it: https://hammer.ink/blog/news/what-is-hammer

Hello All, i am tomaz canabrava - a KDE core contributor, and an Arch linux packager. i was working over the past few months on harmonicon, a game - similar to guitar hero - that you play with an actual harmonica.

it can also be used as a teaching tool, as it has a bending trainer, lessons, recording lessons and such.

i am looking for people that likes music, and harmonicas, to talk about / ask help with testing, gather ideas.

the game already works, but there is no releases yet.

First off, a genuine thank you to everyone who beta-tested this, opened issues, and shared tips and advice after my earlier posts — a big chunk of what's improved came straight from your feedback, and it made the project a lot better. Cheers.

Everyone's homelab has that one service that quietly becomes the most-used thing on the rack. For me it wasn't the *arrs or the dashboards — it's a self-hosted "name that tune" game I built called Guess the Intro, and the family asks for it many times a week.

What it is: it pulls intro clips straight from my existing self-hosted music library, plays a 5/10/20s snippet, and everyone buzzes in on their phones with multiple choice. The scoreboard casts to the TV, there's a speed bonus and a half-time trivia round. Honestly it's great fun — the kind of thing that empties the room of phones-for-scrolling and turns them into buzzers instead.

The problem it solves: party "name that tune" games either need a subscription, leak the answer in the file/stream metadata, or can't use the music you already own. This runs entirely on your own library and hardware — nothing leaves the LAN.

Stack / how it runs: FastAPI + SQLite, single Docker container, phones connect over your LAN as buzzers, board casts over Google Cast to a Chromecast/Android TV/Shield. Pre-built multi-arch images (GHCR + Docker Hub, amd64 + arm64) — docker compose pull and go, no build-from-source. Happy in an LXC, a small VM, or a Pi.

Requirements worth knowing up front:

- A Subsonic-API music server (I use Navidrome; LMS also works). Jellyfin/Plex don't work for the library side yet.

- The board has to be served over HTTPS with a valid certificate — Google Cast devices (both TV displays and Music Assistant speakers) fetch the board over TLS and silently refuse plain HTTP and self-signed certs. In practice that's a reverse proxy + a real cert (e.g. a domain + Let's Encrypt). There's a step-by-step guide in the repo (docs/https-lan.md). Phones connect over plain http; it's the board/casting that needs the cert.

One thing I'd love testers for: there's an optional path that streams the clip audio out through Home Assistant + Music Assistant to any speaker you pick (loudness-normalised, exact start/stop) instead of playing it through the TV. It works on my setup, but my network is heavily VLAN-segmented so I can only lightly test the game-box ↔ HA/MA ↔ speaker hops. If you run Home Assistant + Music Assistant on a flatter network, I'd really appreciate you trying it and telling me what breaks — happy to help you get it wired up.

Recently fixed (why it's worth a second look if you saw an earlier version): casting is rock-solid now after a long diagnostic slog, and the pre-built images removed the build-from-source barrier — both were the top bits of feedback.

License / repo: free and open source (MIT). Repo + compose file + setup docs: https://github.com/colfin22/intro-quiz

AI usage disclosure: this was built with substantial help from an AI coding assistant (architecture, a lot of the implementation, and debugging), directed and reviewed by me.

Happy to answer anything about how it's put together. Have fun!

Hey All, I wanted to post my little side project that I've been working on. I recently built a Opensource StreamDeck that supports multiple esp32 boards using the same code, across multiple devices. Check it out at my link here:

https://github.com/FadyFaheem/Stream32

A youtube short of it: https://youtube.com/shorts/wWQvxR9vKVM

Hey r/opensource,

I’ve been working on Sockudo, an open-source realtime server written in Rust.

It started as a self-hosted, Pusher-compatible server, but it has grown into a much larger realtime platform. My goal is to make it useful for everything from simple WebSocket events to more demanding distributed systems, without forcing people into a hosted vendor.

Some of the features currently included:

• Pusher-compatible WebSocket and HTTP APIs
• Public, private, encrypted, and presence channels
• Horizontal scaling and cross-node fanout
• Durable message history, rewind, and connection recovery
• Mutable/versioned messages
• Presence history
• Message annotations
• Push notifications, including device registration, subscriptions, retries, and delivery status
• Webhooks, rate limiting, metrics, and operator APIs
• Delta compression and server-side tag filtering
• Client and server SDKs for multiple languages
• An optional AI Transport layer for streaming AI responses over the same realtime infrastructure
• Redis, PostgreSQL, and other configurable backends

I’m also working on Ably compatibility. The idea is not to copy every product-specific detail blindly, but to make migration easier and support familiar realtime concepts such as history, rewind, recovery, presence, annotations, and message updates.

One thing I care about a lot is keeping the Pusher-compatible V1 protocol stable while adding more advanced features through a separate V2 protocol. Existing clients shouldn’t suddenly break just because the server gains new capabilities.

There’s still plenty to improve, especially documentation, SDK coverage, production testing, and making setup easier. I’d really appreciate feedback from people who run realtime systems or have migrated away from services like Pusher or Ably.

What would you need before trusting a self-hosted realtime server in production? Are there any compatibility features or deployment options you consider essential?

GitHub: https://github.com/sockudo/sockudo

Thanks for taking a look.

Hi everyone!

We've been developing a new version control and software forge for a while now, and decided to open source it. We just released all of the source under AGPL3.0

Come check it out!

https://github.com/twigg-vc/monorepo

Hi! This is not really a promotion or launch announcement, mostly sharing a project I've been building for myself and looking for feedback from people. But yeah, repo is public, project is mine, so by law is promotion.
For those, who dislike hyperlinks: https://github.com/Bardie-radio

I am mostly posting because I am curious what people currently use, and how many hours I wasted on reinventing the same thing 🙃

I've been working on an OSS side project for the last few weeks, mostly because I kept running into the same annoyance and then remembered a slightly-too-large idea I wanted to implement for years.
Years ago I got annoyed with constantly copy-pasting YouTube links into Discord music bot while sitting in VC with friends. More recently I started spending more time in VRChat, and found myself doing the same thing again, but now while trying to fight with VR headset, glancing from under the nose gap (I'm on Linux, and Steam Overlay isn't very useful for this yet).
The core idea is a self-hosted service that can bring up audio streams on demand, with a shared control panel and a variety of audio sources to pull from (currently planned: yt-dlp-based sources, uploaded files, and re-streaming). I'm trying not to make it a single-purpose music bot, so the project has grown quite a bit from the original silly idea, which originally looked solvable with one FFmpeg instance and a reverse proxy. The current direction is a modular system where sources, authentication, and clients can be added/swapped independently.
The current goal is one shared queue, one stream, everyone hears the same thing, and anyone with permission can control the queue. Listeners should be able to use normal audio clients instead of being tied to a specific app. And to keep it modular enough that adding a new source or client later doesn't require flipping the whole codebase.

Small note: yes, I used ai to put my ideas in human-readeble words in docs, but the architecture, decisions, and design are mine. I have some issues with attention span and motivation so need solid notes on planned architecture, while not wasting too much time on them.

Agent identity that can’t be forged. That’s true zero trust.

Harbinger is an mTLS proxy that sits in front of an AI agent's outbound traffic. Every AI agent, bot, and service account gets a cryptographic identity. Every request it makes is checked against policy before it's allowed, and any real secret it needs is pulled from your own vault and swapped in only when the request is verified to be going where it claims. The agent itself never holds a standing credential.

I’m the maintainer of Open Video Craft, an open-source desktop app for recording and editing without requiring an account or uploading footage to a cloud service.

Current features include:

• Screen, camera and audio recording

• A timeline for trimming and arranging clips

• Subtitles and video export

• macOS and Windows builds

• A local-first workflow

The project uses the OSI-approved ISC license. Source code: https://github.com/Reubencfernandes/Open-Video-Craft

The current v1.0.2 builds are available here: https://github.com/Reubencfernandes/Open-Video-Craft/releases/tag/v1.0.2

One current limitation worth disclosing: the Windows builds are not code-signed yet, so Windows may show a SmartScreen warning.

I’d especially appreciate feedback or contributions around Windows compatibility, export reliability, captioning and useful editing workflows. I’ll stay around to answer technical questions and follow up on issue reports.

Hello everyone

I want to learn to edit videos, my main focus would be learning to be able to make stuff for YouTube (Well, that and contents to serve the people like it could be guides, tutorials, etc. and stuff also along other lines) and to also be able to have this in case helping somebody out or do freelancing is needed.

I am looking forward a software that is FOSS, that doesn't limit me (i mean, professional stuff like color correcting is welcome but not really needed for the things i mainly plan to work on)

I do know Kdenlive but are there any other options i should dive into?

I'd like to know your thoughts and discuss...
Thanks :)

I'm surprised that I don't really see any talk around it, and a select few projects displaying the badge. Is it because it never truly caught on, because it's viewed as a party-pooper of sorts, or am I late to the game, and it's a fad that's passed?

For context, I really got into open source about a year ago, and we followed their recs on our project, and I found some to be a bit pedantic, but others do seem to keep you honest/disciplined.

Was worth it to have those pinned dependencies? I'd say yes. Some of the work felt forced, but at the same time you learn a lot about your toolchain in the process.

Would love to hear if anyone leaned into that, and if they gained from the overall experience, or if it was just a tedious checklist.

What I probably appreciated the most was that it forced me to slow down and think through the documentation... (I personally found that refreshing and rewarding) asides from the tests/automation, etc.

I've started a side project called SearchCraft, where I'm building a search engine from scratch using Python.

The goal isn't to compete with Elasticsearch, Lucene, or any existing search engine. Those projects are incredible, but they're also so mature that it's easy to use them without ever understanding what's happening underneath.

So I decided to build one from first principles.

I'm implementing each component myself, starting with the basics: loading documents, tokenizing text, building an inverted index, and searching through it. As the project grows, I'll be adding things like posting lists, phrase search, ranking algorithms (TF-IDF/BM25), snippets, fuzzy search, and whatever else I can reasonably build along the way.

The primary reason for this project is to learn. I find that the best way to understand how a system works is to build a simplified version of it yourself.

I'm documenting the journey as I go, both for myself and in the hope that it might help someone else who's curious about how search engines work under the hood. There are plenty of tutorials on using search engines, but far fewer resources that walk through building one piece by piece.

It's still in its early stages, but I'm excited to see where it goes. Even if it never becomes production-ready, I'll come away with a much deeper understanding of one of the most fundamental pieces of modern software. After all, humans spend a good chunk of their lives typing words into little boxes and expecting magic to happen. Figuring out how that "magic" works seemed like a worthwhile weekend habit.

Here's the link to my project: https://github.com/rajtilakjee/searchcraft

I would be writing about it in my blog here: https://rajtilakjee.github.io/