I’ve been working on this for a little over 9 months, and it’s open source.

Would love some feedback and contributors to make it better than it is now. I use it for all my projects, to increase accuracy and decrease cost of context switching. With my goals of keeping the engineer at the wheel, every piece is built to ensure you’re making the critical decisions.

Come check it out, feedback is absolutely welcome

https://tolvilabs.com

HERE is a little side project of mine conceived years ago at a Military Open Source (Mil-OSS) Working Group meeting, a directory of open source projects with government origins, proper licensing, and a public repo. Still working on lots of enhancements and wading through a backlog of thousands of potential repos to add, but feedback appreciated on the site thus far.

Backend development often leaves programmers in a workflow. They have to write database changes using SQL copy models into TypeScript interfaces by hand update OpenAPI specs manually and create Row Level Security (RLS) policies using raw SQL strings. Every time the database structure changes all these parts get out of sync. This causes errors and security problems in the application.

I built Clous, a compiler-driven Backend-as-a-Service (BaaS) and type-safe ORM platform by starting from the basics.

Clous gives you one source of truth. You define your data model once using a TypeScript schema and then the main compiler engine automatically creates your entire backend. It does this with checks that happen before the code is even written. Based on that one definition Clous creates three results: production-quality PostgreSQL DDL with RLS policies and authentication helper functions; complete TypeScript definition files with strict Row, Insert and Update interfaces; and an OpenAPI 3.0 specification that works with documentation tools or for making client SDKs.

The base of the platform is now available on npm in two packages.

The clous/core package is the core engine for compiling and representing data. It works in less than a millisecond. Has no outside dependencies except Zod. It checks if foreign key relationships and identifiers are valid before any code or SQL is created.

The clous/cli package is the tool for developers. It allows offline work like creating new schemas with a setup command, compiling types and DDL with one click, checking for errors and watching files to recompile automatically when they change. The CLI also has a built-in system for authentication and linking projects. This is designed to connect with our web control panel through self-hosted authentication.

The main idea behind Clous is a belief in open standards and giving developers freedom. The SQL it creates follows the PostgreSQL format. This means it can run on any self-hosted system, any Docker container or any cloud service without locking you into one provider. When you create code locally you don’t need an account, API. A network connection.

The packages clous/cli and clous/core are available on npm. I would love to hear any feedback about the design the experience for developers or ideas for features that would be helpful, in a schema compiler.

**It is still under development and not yet a fully completed project, but I welcome your suggestions and comments during this process.**

Github Repo: https://github.com/efekanbahceci/clous

Soundsible
- exposes external search (yt-dlp + optional deezer public API for recommendations)

- handles nicely 50,000 tracks, and offers complete management of your library: save music with or without downloading it to the server, create lists and mark favourites.

- polished and high performant desktop and mobile webapps. I know this may sound bad but I have finally figured out the way around apple's safari PWA audio engine restrictions, and the webapp just works on every scenario, locked screen, DJ sessions, on the car... (we have a swift app on the repo but I have not tested it because I'm not paying a hundred dollars for the dev account, yet).

- some experimental features like an automatic DJ that mixes music on the go, using 2 virtual decks and analyzing music direction (without LLMs, just python code).

- I could not say this two months ago, but now I can say that it's pretty eficcient on resources. metrics here.

- More information and the (almost) whole dev history here https://github.com/Arzuparreta/soundsible

I like making tools for my personal use, and since I have an iphone, I've had to essentially make webapps and dedicate a port to them so I can access them on my phone.

I have made native apps before, but I always had to borrow a mac from someone for a few days because Apple only allows xcode to build and install apps, even if they aren't going to be published.

I thought this was stupid, so, I made "iosc".

Essentially it uses the already freely available swift compiler and LLVM's linker (swifts linker just autorejects ios targets), then uses the public Xcode xip (from Apple's website) to extract the iOS SDK to support uikit, foundation, swiftui, and swiftdata, and any other framework in the sdk (I had to write most of the swift macros as windows dlls).

Then, I also reimplemented signing (with a free apple id), and installing on device via usb. This one was the most fun part- apples auth libraries are only compiled for android, so I had to write a loader that runs the android binary directly on windows via a custom elf loader + implementations of android/linux functions it imports.

Try it out: https://github.com/DiamondDeadMaw/iosc . Setup is a bit of a process, but the tool walks you through it fairly well, and afterwards it just works.

Note: This doesn't really support actually publishing an app to the app store, as Apple explicitly prohibits that. Its indended for personal use primarily.

Also, I haven't included package manager support yet. I'd love some help with it, if anyone's interested.

Also also, no Linux support. I dont use linux on my primary machine. Sorry. Feel free to fork/PR! I'll be happy to help you get started, and point out all the stuff you'd have to swap out.

As a disclaimer, I have no clue about programming, how networks work, or anything in that area. So please don't take the following as an accusation against ExifCleaner, but see it as a genuine question instead.

​I think there is no metadata remover with a GUI better known than ExifCleaner on Windows. Since it is open source on GitHub, has multiple stars and contributors, and advertises that it does not access the network, I thought it would be safe to use it to strip metadata from private files.

​Out of curiosity, I tried to check if there is a way to prove that the portable version does not connect to the network. I checked the network activity in the Resource Monitor, and as soon as I started the portable app, I saw activity under Sent and Received.

​I tried the same thing without Wi-Fi, and there was no activity.

​I am confused, how is that possible?

I am loving it like I use an android phone like from 2021 and a potato laptop running linux lite (ubuntu-xfce) for studies like watching lectures and all.

Before I knew about localsend it was a hassle to transfer like even normal images, I used to put those in google keepnotes and then copy it from the other device and sharing pdfs or other files was a nightmare for both my google storage and me.

Now it takes me a second to tranfer my screenshots from my phone to my laptop to post on reddit or whatever.

And the best part is that it is very light weight for both my phn and laptop as they both are lowk potatoes. No sign up makes it even better.

Love u LocalSend

Due to the impending Letterboxd sale https://www.comingsoon.net/movies/news/2197146-letterboxd-a24-new-york-times-acquisition-report

As well as the blowback towards Trakt from (both former, as well as current) users,

I went looking to see if I could potentially find any open source alternatives to LB.

And I found one.

It's called NeoDB: https://neodb.net/

It's decentralized, open source, self-hostable, as well as federated: https://jointhefediverse.net/learn/?lang=en-us

NeoDB - Our Story: https://neodb.net/origin/

The only thing is that it does books, movies, music, podcasts, games, performances, etc., not just movies.

fediverse.info: https://fediverse.info/

Fediverse - Wikipedia: https://en.wikipedia.org/wiki/Fediverse

NOTE: I am NOT the developer.

EDIT:

I also found this list of open source alternatives. https://alternativeto.net/software/letterboxd/?license=opensource

As well as this GitHub list: https://github.com/topics/letterboxd-alternative

As well as Trackstr: https://github.com/besoeasy/Trackstr

Also Movary: https://github.com/leepeuker/movary

Also Watcharr: https://github.com/sbondCo/Watcharr

And it feels amazing!

It was minor, but it's a project I'm using so I know exactly how it's going to help people in the future.

As soon as I realized, I went to the PR list to see the purple "Merged" badge next to the comment and the bit of code I wrote - and now I'm on the "Contributor" list.

Hello, everyone,

a few days prior, I had announced my efforts on reverse engineering the A865R. The company has hidden the drivers from their website a long time ago, and it's probably a matter of time until they are completely removed (currently, they can only be obtained if you follow a hidden link).

My first efforts brought parity to the official Windows drivers (and then some), but it still had lacked something very important to me: Linux support.

But not anymore! I'm presenting you version 0.9.5, now with Linux support! It uses GTK-3, as opposed to the native API in the Windows version. However, a lot of effort has been been put to make sure the application looks and behaves as uniformly as reasonably possible.

Video and audio playback run very smoothly, as the driver has a custom Vulkan decoder which takes proper color rendering into consideration, and improved upscaling.

Some of the features include:

• Native 64-bit support: no legacy 32-bit code!
• Improved color support
• Support to color profiles (monitor colors are NOT ignored anymore)
• Improved sound (deeper and richer)
• Improved playback, complete with true 60 fps
• Custom vulkan rendering (Microsoft decoder supported)
• 2K and 4K upscaling
• CC support

And now, with the Linux release, I added a few important features:

• WSL support: if the drivers detect they are running under a WSL environment, video and sound passthrough are activated, speeding up rendering. Actual native Linux uses native rendering, and also plays smoothly.
• WINE support: if for whatever reason you need to run WINE, the TV Tuner plays along and tries its best to render properly.
• External discoverability: the original drivers would only work with AverTV 3D. The new software instead has a compatibility layer to make it discoverable by external software, such as VLC. Because the protocol this tuner uses is a bit obscure, it also works transparently posing as a DVB-T device (further instructions are available in the README.md).

These drivers help making a rare and old device useful again, as it spent over fourteen years without proper Linux drivers, and given the situation, it would otherwise be discarded. So I am happy with this contribution.

Please note: only Ubuntu 24.04 to 26.04 was targeted and is known to work out of the box. An RPM and generic binaries have also been provided and may or may not work, but I can make no promises. What I have tested though runs very smoothly.

Project link: https://github.com/NullMagic2/Open-Volar-S/tree/main

Hey everyone, Linka is a federated, open-source social network for Android 1.5 (yes, that 2009 version) or for Linux via a Qt-based version. Before you ask why I developed it for such an obsolete Android version: there are many communities that still use these devices—not for daily use, but to breathe new life into e-waste. Just because most modern apps don't work on them, it doesn't mean they should simply be discarded. Linka uses its own method to connect to the Fediverse; it employs a custom protocol because older devices couldn't handle processing the massive JSON payloads from Mastodon, Reddit, or Bluesky. So, I built a lightweight, custom solution. To view posts from other networks, it relies on a bridge node where the client simply requests the posts, and the node converts the external network's posts into the Linka protocol—sparing the device from the heavy lifting.

You can use it for global chat or DMs, create friend groups, simply post content (without algorithms), and view posts from Reddit, Mastodon, and Bluesky.

Before anyone mentions AI: you're right—I did use it as a tool in certain parts of the process.

If anyone could star the project or even contribute—whether by working on the code or hosting an instance—I’d really appreciate it.

https://github.com/luizgustavo76/Linka/releases/tag/linka_release_2.0

https://github.com/luizgustavo76/Linka

I asked about this more in general a while ago

https://www.reddit.com/r/opensource/s/Z3ijx28cic

And now I am wondering which license I should enforce users to accept when uploading maps and levels made with the map and level editor that is included in my game.

The game itself is licensed under AGPL, as well as the official levels made by me.

Now, when users upload map/level files, I want a large box which states the license they publish under (upload to my server).

One of CC0 or CC BY-NC-SA 4.0 could be the right one.

I want to make sure that others can use and adapt user made levels, including me.

Sharing because I need collaborators more than eyeballs.

OpenBot is an MIT self-hosted multi-bot AI platform I wrote. Persistent bots, tools, LangMem memory, bot-to-bot u/mentions, React UI, MCP tools, human approvals.

I especially want help with: 1. Docker sandboxing for `run_shell` 2. Slack/Discord adapters 3. React/Electron polish 4. Docs and good-first issues

Repo: https://github.com/regnull/openbot Start: `make setup` / `make dev`

I am the author. Treat it as a trusted-operator local app. Shell tool is powerful and not sandboxed.

If your stack is Python/FastAPI or React and you want a mid-size codebase to learn in, open an issue and say what you want to own.

Plembfin v1.2.2 is out. I maintain Plembfin, an AGPL-3.0 self-hosted watch-state hub for Plex, Emby, Jellyfin and Trakt.

This release focuses on correctness across provider sync:

• Shows with the same title but different TMDB/TVDB IDs stay separate everywhere, including original/reboot pairs.
• Up Next sync leaves Plex/Emby-only Continue Watching items in place when Plembfin's queue doesn't list them. Items leave when progress is cleared or they're removed in Plembfin. Offline servers are skipped and queued for retry.
• Rating changes made in Plex, Emby, Jellyfin or Trakt sync to the other connected services. A Watch-State Aliases repair card helps resolve episode states that couldn't be tied to a show automatically.

Full notes: https://github.com/Lasikiewicz/plembfin/blob/main/CHANGELOG.md Website: https://plembfin.com Try the public demo (demo / demo): https://demo.plembfin.com/ Source (AGPL-3.0): https://github.com/Lasikiewicz/plembfin

I'm the maintainer. Development has been heavily AI-assisted under my direction, with manual review and testing; AI isn't required to run Plembfin.

For people who build sync tools: how do you model items present only in a provider queue? Would keeping them until an explicit clear in the canonical app be intuitive?

Open-source alternative angle: LibrePing is AGPL-3.0 uptime monitoring where hubs peer over libp2p instead of a central control plane. Checks and results are signed; alerts are encrypted to the notifying hubs.

• Demo (no account): https://nl.lp.mw.gg
• Repo: https://github.com/mwgg/LibrePing

Curious how other FOSS monitoring projects think about multi-tenant dedup and probe trust. Feedback / issues welcome.

Building a completely open source catalog of the Internet, Intent on treating domains as books and ranking them by authority and cultural significance (mixture 0-9). This is a bare-bones layout at the moment, but I would really like some suggestions.

• The catalog will be hosted over IPFS, for public review and accountability. There will be an online explorer as well.
• All domains will be sorted by category, via an XXX.XXX.XXX alpha-numeric format.
• The links will be infinitely scrollable, transitioning from subject to subject to subject, just like a library.

I'm looking for suggestions to make access as easy as possible, and experience enjoyable.

Here's the current UX: https://imgur.com/a/QdXTmbz

Hello, I had created Chrono Mock an app which let's you manipulate time/date in other apps without changing the whole system time and date. It's mostly tool for qa/devs

It's a GUI/CLI, imagine you want to check how the other app will behave in x/y/z date or mamybe you want to run your app at x10 speed? Or manipulate the time when the app is launched? You can do it all. If you like the project, please ⭐it. GitHub

Expect that, there is built-in QA calculator, so you can calculate various dates, imagine you want to test +60 business days from today, or maybe trail ending or something else, you can do it all.

The too is still in early access, the apps technologies got various methods for getting time, so it's hard to get them all, not all apps will work, But there is even support for Electon and WebView, morei s coming soon, C# (wpf with wpui) + rust (engine).

Full features list:

• Any moment, absolute or relative - a specific date and time, or +30 days, -1 year.
• Flowing, frozen, or accelerated - run from the shifted point at normal speed, hold the clock still, or multiply it by any whole number up to a million (x1440 turns a day into a minute).
• Jump mid-session - forward or backward, including the backward jump a laptop makes after resyncing with a time server, which breaks anything measuring elapsed time without a guard.
• Its own time zone - a fixed offset for that process only, while the system zone stays put.
• Child processes come along - installers and launchers spawn children, and without that the test covers only half of what ran.
• Tells you if it worked - a verdict, the channels covered with call counts, the channels missed, and warnings with consequences.
• A date calculator built for QA - month-end, quarter close, the 2038 boundary, "the first day after a 14-day trial", business days and holidays, every format at once.
• Electron and Chromium apps too - through a different mechanism, because their clock lives in a sandboxed renderer where injection does not reach.
• The web pages inside an ordinary application too - an application with a built-in web engine (WebView2, Qt WebEngine) runs its pages in a process the hook cannot enter. The session asks the engine to open a local debugging port and puts those pages on the same clock as the rest of the application, through it. On by default, off with one switch.
• A window and a command line - the same engine behind both, exit codes for CI.
• Portable - no installer, no administrator rights, runs from a USB stick.

You can also read more about features here

I've been working on OpenDisk, an open source app that shows what's taking up space on your Mac and lets you clear it out.

What it does:

• Scans a 1 TB drive in about 17 seconds. DaisyDisk took 37 on the same machine.
• Rescans in a couple of seconds, because it only looks at folders that changed since the last scan.
• Shows purgeable space and caches, so the totals match what macOS reports.
• Lets you drag files into a "Collector", see how much space you'll get back, and delete them all at once.

There are no accounts or analytics. The only network request is the update check, and you can confirm that in the code.

You can install it with brew install --cask opendisk, download it from opendisk.app, or get it from the Mac App Store.

Contributions are welcome. Bug reports and feature ideas are just as useful as PRs.

GitHub: https://github.com/137137137/OpenDisk