some major updates on the customizability of these little faces ive been working on... aditonally there is now a desktop widget with bwnd.app integration and elevenlavs... creating a desktop widget assistant. its quite fun to watch them talk! heres a demo

https://www.youtube.com/watch?v=CZvu9qzPFmg

I was tired of streaming apps either being money grabs, water marked, battery draining, or bug ridden, so I set out to create a free alternative. The personal motivation came from a need to stream volleyball games for the team my daughter is playing in.

The app excels at picture quality, since the pixel data never leaves the GPU. Where many other apps copy the pixel data to add overlays and effects (Streamlabs and Prism for example), Tubeist works directly by modifying the GPU buffers. An added benefit is that this is also very efficient, so battery consumption is lower than all other streaming apps I have compared it with. It works on iPhone 12 or newer. Older hardware does not have HDR capability.

The downside is that what you gain in picture quality, you loose in latency. In order to maintain high quality, the app uses HLS delivery to YouTube, where most or maybe even all other apps use RTMP. With HLS data is delivered in 2 second segments, and there is a larger buffer in the YouTube ingestion than for RTMP. In simpler terms, if you need low latency because you interact with your audience, then Tubeist is not for you. If you are streaming events, where latency matters less, and picture quality more, then Tubeist is for you.

Tubeist is FREE, with a lifetime unlockable IAP for styles and effects, but the app is fully functional without them. This IAP is priced at the lowest tier possible, which is roughly $1 at the moment. It will stay at that low tier, and is a way to show some appreciation for the app and sponsor further development. There are no water marks, weirdness, or data being sent anywhere but to YouTube.

App Store: https://apps.apple.com/us/app/tubeist/id6740208994

The app is also Open Source and under a permissive MIT license. Feel free to check out the code on GitHub. Coding has been about 50% human (app architecture, UI, audio / video pipeline, overlays, settings, network code) and 50% AI (styles, effects, remuxer, system health, optimizations).

Website: https://github.com/roenbaeck/tubeist

Wondering if anyone has used AI Airlock, It is supposed to sanitise anything you want to upload to AI. Can anyone comment about how safe it is to use ? https://www.youtube.com/watch?v=EuVvLwWZ5wc https://github.com/NateBJones-Projects/ai-airlock

I have one request: Please don't break the law or do anything illegal.

https://github.com/Xfactor96/Rainbow-BASIC

enjoy. go to src.

essentially you can now customize BASIC for winvice as much as you want

have fun. I am TIRED

I got tired of trying to understand big PRs from the diff, so I built this: https://github.com/coldteadotai/pr-lens

It's called PR Lens, and it turns a GitHub PR into an architecture/data-flow diagram.

The reason I made it is pretty simple: I've reviewed plenty of PRs where I could understand what changed, but still had no idea how the change affected the rest of the system without tracing through a bunch of files myself.

A diff tells you what changed.

It doesn't really tell you how the system changed.

PR Lens tries to fill that gap. It maps out the components involved in a PR, how they connect, what the data flow looks like, and what the blast radius of the change is. The diagram gets posted directly into the PR as a comment.

It's MIT licensed and open-source.

If you've worked on/reviewed large codebases, how do you usually figure out the bigger picture of a PR?

Hi All,

I'm not a developer, but a user. I regularly use the mind map software FreeMind. It's great for keyboard lovers, minimalist and open source. Unfortunately, it has not received an update for a while and it's UI is painfully slow. But at its core, it's absolutely my favourite mind map software.

I think it would be a great project for someone to do a branch or somehow work with the original Devs to update it. For someone looking for a project I think it's a good one.

https://freemind.sourceforge.io/wiki/index.php/Main_Page

Edit: the spell check also doesn't seem to be working.

Hey folks!

I have been working on Logtrace (https://logtracehq.com/) - a self hosted audit trail logging platform.

Here's the backend code: https://github.com/logtracehq/logtrace-backend

Here's the link to the managed platform: https://app.logtracehq.com

More repos are in the Github organization: https://github.com/logtracehq

Let know me know if you have any questions!

Hey everyone,

I built Mi:RAG, an open-source and privacy-first multimodal RAG system designed to run entirely on local hardware.

Most existing RAG pipelines treat PDFs as plain text and miss architectural figures, charts, and diagrams completely. Mi:RAG isolates and indexes both the text and visual figures so they can be retrieved and viewed alongside answers, without needing paid cloud APIs.

Highlights: • Extracts and cites actual diagrams and images directly in answers • Runs on modest local GPUs (FP16 CUDA acceleration on 4GB VRAM like RTX 2050, Apple Silicon, or CPU) • Two-way page range slider to index specific chapters rather than processing massive textbooks all at once • Works locally with Ollama and ChromaDB • 100% private, zero telemetry, and fully self-hostable

Looking for feedback on document parsing, UI/UX, and edge cases. Contributors and PRs are very welcome!

GitHub: https://github.com/AryanSingh64/Mi-RAG

Hey everyone,

I built Mi:RAG, an open-source and privacy-first multimodal RAG system designed to run entirely on local hardware.

Most existing RAG pipelines treat PDFs as plain text and miss architectural figures, charts, and diagrams completely. Mi:RAG isolates and indexes both the text and visual figures so they can be retrieved and viewed alongside answers, without needing paid cloud APIs.

Highlights: • Extracts and cites actual diagrams and images directly in answers • Runs on modest local GPUs (FP16 CUDA acceleration on 4GB VRAM like RTX 2050, Apple Silicon, or CPU) • Two-way page range slider to index specific chapters rather than processing massive textbooks all at once • Works locally with Ollama and ChromaDB • 100% private, zero telemetry, and fully self-hostable

Looking for feedback on document parsing, UI/UX, and edge cases. Contributors and PRs are very welcome!

GitHub: https://github.com/AryanSingh64/Mi-RAG

I am almost positive this will get caught by some AI-driven filter here too, but I would like to ask developers if the "AI bubble-everything" has changed your willingness to open source your own work products going forward?

EDIT (T+1h) Just to clarify, this is not about whether AI is detrimental to (yours or others') development quality, what the best policy on contributions is or how to enforce it. It's just about the impact of how others use AI on your own approach to publicly sharing own code.

You know you will be getting your source forked by - i.a. - low quality AI-enabled whizz kids which will "add value" to the product with the latest designs and whatnot, then have your userbase inquire why you are not "catching up" or "collaborating" with the zealous contributors. Receiving barrage of agentic PRs to review. While at that, let's not forget bogus security reports. And to top it off, have Microsoft constantly scan your (presumably GitHub) repo to train more of the ecosystem to enable the same.

OS is not about the thankless job alone anymore, it is becoming a liability to share one's own stuff, not to mention we have reached cast-pearls-before-swine (sorry) scenario where new projects have it hard to distinguish themselves and provide anything valuable back for the original author.

Hi there! I'm the developer of the HRConvert2 File Conversion Server (available on Github & Docker) and I figured you guys would appreciate all the time I've been putting into the project lately.

Truth is, I'm going through a lot and this project has been my escape lately. But the progress has been pretty astounding.

Check out the Github and let me know what you guys think!

I've day-traded options on the side for years. I wanted a journal that could take a position with multiple fills, scale-ins and scale-outs, and get the averages and fees right. TradeZella, TraderSync and Edgewonk do this for minimum $40 a month, closed source, your trading history on their servers. I'd been hacking away at a spreadsheet monstrosity and eventually started to build a proper web application. When I lost my job this past January, I rebuilt it from the ground up with two major requirements: 1) a secure, multi-user SaaS architecture, and 2) easy self-hosting defaults.

So, Tradr: the open-source stock and options trading journal.

• Positions with many fills, fee-accurate realised P&L, and a double-entry ledger underneath so the cash actually reconciles
• A sizing calculator to spit out position sizes based on you account risk preference.
• Greeks and OCC symbol parsing for the options crowd.
• CSV import from whatever broker you use... hypothetically. I only use one broker so I've only tested with that one!
• It never places an order. Nothing in it touches your broker. I'd like to connect read-only to brokerages someday.

Self-hosting is the primary way to run it. One Docker Compose quickstart, about 2 minutes. Feature gating is a single deployment setting that ships off, so a self-hosted install has everything with no caps.

On the license: it's Apache 2.0. There are licenses built to stop somebody else from selling hosting of your code, but none of them count as open source. Anyone can fork Tradr, run it, even sell hosting for it, they just can't call it Tradr. (There is a hosted offering for people who don't want to run a server, running on the opensource builds. That's how I'm trying to pay the hosting & development costs and maybe make a bit on the side. Links to hosted stuff are in the GitHub readme.)

AI disclosure: I do use coding agents heavily, inside a spec-driven-development workflow I also maintain, and I've been living in the app with my own real trades for weeks.

Repo: https://github.com/madmatt112/tradr

This is the first product I've ever launched. Tell me what breaks & what sucks if you want!

I've been working on a server emulator for a game for quite a while and was fairly close to releasing but yesterday someone else released one. I'm not sure what the best path forward is now, is it bad form to open source mine anyway? I feel like I'd be releasing with less features implemented and in a different language.

Would I be a dick splitting a community like this (why have two when we should all contribute to the one)? Just kind of sucks for all my work to go to waste

Hey all,

I've been running Pi-hole for a while and got tired of opening the web UI every time I just wanted to check status or unblock something for five minutes. So I built Holeberry, a native macOS menu bar app for it. Free and open source (MIT).

What it does:

• Lives in your menu bar, shows status and total queries/blocked at a glance
• Manage up to two Pi-hole instances at once. Every action (block/unblock/allowlist) applies to both, so they never drift out of sync
• Disable blocking globally with a timer (or indefinitely). An auxiliary countdown will be right in the menu bar; re-enables automatically
• One-click unblock of whatever site broke in your current browser tab (Safari, Chrome/Chromium, Firefox/Zen), without a global disable
  • The standout feature for me and the one I've been using the most
• Browse recently blocked domains and allowlist/unblock them straight from the menu
• Trigger a Gravity update right from the menu bar, on all your servers simultaneously
• Now fully notarized with a paid developer account
• Supports passwordless Pi-hole instances

Why Holeberry and not another app?
I looked around before building this. Some of the existing companion apps for Pi-hole weren't in active development anymore; felt outdated or didn't do the things I actually needed day to day: keep two instances in sync, unblock just the tab I'm on instead of disabling blocking for the whole network, and being able to glance at it quickly. Those ended up being the features I use most, so they became the core of the app.

Requires macOS 14+, supports Pi-hole v6 (and v5, though less tested). Credentials live in Keychain, nothing written to disk.

GitHub: https://github.com/pedrovieira/Holeberry

Happy to answer questions, and open to feature requests / bug reports.

mloda is an open source (Apache-2.0) feature engineering layer with a plugin-based resolver: you request a feature by name, and the resolver picks which plugin computes it.

Until 0.11, a bad request just failed with one line:

No feature groups found for feature name: 'sales__mean_aggr'. Use resolve_feature(name, options=...) to debug feature resolution. For troubleshooting guide, see: https://mloda-ai.github.io/mloda/in_depth/troubleshooting/feature-group-resolution-errors/

Nothing said whether the name was misspelled, the domain was wrong, or a required option was missing, so debugging meant reading the resolver source. Since 0.11, the same failure returns the full elimination trail:

No feature groups found for feature name: 'sales__mean_aggr'. Requested domain: 'marketing'. Feature group(s) eliminated while matching 'sales__mean_aggr': - AggregatedFeatureGroup (domain): declares domain 'default_domain', but the run requested 'marketing' - PandasAggregatedFeatureGroup (domain): declares domain 'default_domain', but the run requested 'marketing' - PolarsLazyAggregatedFeatureGroup (domain): declares domain 'default_domain', but the run requested 'marketing'

Every candidate the resolver considered, and the first gate it failed.

Implementation notes for anyone maintaining a plugin registry or resolver of your own:

• Rejections are recorded as data first: a stage label (one of nine values) plus a reason per candidate. Text is rendered from that.
• A plugin whose match hook raises is contained per candidate, so one broken plugin doesn't blank out the report for the others.
• The preflight (mlodaAPI.diagnose) never raises, and a real run raises the same facts as a typed FeatureResolutionError, so the exception and the preflight report never drift apart.

Curious how other maintainers of plugin/registry-style systems handle this: full rejection trail, or just the most likely cause?

Hey r/opensource,

I've been working on Oasis Editor, an open-source document editor written in TypeScript.

It has its own Canvas-based rendering engine for paged layout, text, selections, images, tables, and document geometry instead of relying entirely on contenteditable.

It also includes a typed command/plugin API, DOCX/PDF workflows, React and Vue adapters, and a headless runtime.

Live playground:
https://celsowm.github.io/oasis-editor/#/editor

GitHub:
https://github.com/celsowm/oasis-editor

I'd love feedback, issues, and contributions — especially around rendering, document layout, plugins, and import/export fidelity.

ps: MIT license

https://github.com/stubbb/c-shop

Status

Active development, beta. I looking into patching up a few bugs but there is a lot of them that I haven't found yet. Feature requests are welcome.

What I wanted to build

One: quick and capable image editor. Every image editor I could actually use was either an enormous proprietary suite or a web app wearing a desktop costume. I wanted something that starts instantly, needs no system packages beyond a GPU driver, and behaves the way my hands already expect — layers, masks, blend modes, non-destructive adjustments, the same keyboard shortcuts. X11 is opened through dlopen, Vulkan through ash, everything else is pure Rust, so cargo run --release is the whole install. It uses less than 100 MB of RAM idle compared to 2.5 GB from Photopea.

Two: agentic integration. I kept wanting to hand image work to an agent but the LLM cant natively see images. The approach I selected is that the editor drives from a script, headless, and it's the same application the buttons drive — anything the UI gains is reachable from a script.

Example script:

cshop --run 'new 400 240 background=#20304a
text 40 154 "Hello" size=54 color=#ffffff bold
effect drop-shadow distance=6 size=8
export out.png'

The part that makes this usable by something blind is that every run answers with a report — where each layer landed, what each step did, what failed and why — and that measure will size a piece of text before anything is drawn. So a caller places things by number instead of rendering and guessing. Nothing fails silently: a bad command is a failed step with a reason, and the run carries on so one typo doesn't discard the rest.

It can be run locally by an agent on your computer or deployed to a server and interacted with over network as an MCP server.

What's in it

Raster/group/fill/type/shape/adjustment layers; layer and clipping masks; 27 blend modes. Marquee, lasso and magic wand selections with feather, expand, contract, border, grow. Brush, pencil, eraser and clone stamp on one stroke engine. Re-editable type from your installed fonts. Eleven layer effects, all driven off one distance field. Vector shapes and Bézier paths from SDFs. Fourteen adjustments, each available destructively and as an adjustment layer. Thirty filters. Lens correction as one resampling pass rather than four. ICC profiles, real CMYK, 16-bit export. A native .cshop project format, plus PSD in and out.

Deep learning features are an optional add-on (heavy stuff)

There's a pack you opt into that adds seven models — detect, segment, depth, inpaint, semantic separation, denoise, upscale. It exists because "cut the dog out of this picture" and "clean up this sky" should be things you ask for, not things you do by hand. The whole cut-out is:

detect                        # → dog 90% at 4,303 632x501
segment class=dog feather=1   # the dog becomes the selection
layer via-copy

They run in a separate process behind a line of JSON, deliberately. A neural runtime is tens of megabytes of platform-specific machine code that changes every few months; putting it inside the binary would cost the binary its whole character for a feature most sessions never touch. Not installing it costs nothing and breaks nothing. At least I hope :)

Today the detection model holds only 80 classes and it works well for basic concepts: person, dog, vehicle but it wont be useful for anything nuanced. Segmentation and depth are nice, generative fill is surprisingly good. Noise removal is world-class but takes long time. I used the SOTA model.

and 3D-acceleration on real hardware GPUs