I built a self-hosted alternative to Google's Video Intelligence API after spending about $450 analyzing my personal videos (MIT License)

Hey r/opensource !

I have 2TB+ of personal video footage accumulated over the years (mostly outdoor GoPro footage). Finding specific moments was nearly impossible – imagine trying to search through thousands of videos for "that scene where "@ilias' was riding a bike and laughing."

I tried Google's Video Intelligence API. It worked perfectly... until I got the bill: about $450+ for just a few videos. Scaling to my entire library would cost $1,500+, plus I'd have to upload all my raw personal footage to their cloud. and here's the bill

(https://preview.redd.it/i-built-a-self-hosted-alternative-to-googles-video-v0-lzejfn9i3gxf1.png?width=607&format=png&auto=webp&s=0ed90647a9832c0c469a4cabdb4864f0a959ca3b)

So I built Edit Mind – a completely self-hosted video analysis tool that runs entirely on your own hardware.

# What it does:

Indexes videos locally: Transcribes audio, detects objects (YOLOv8), recognizes faces, analyzes emotions
Semantic search: Type "scenes where u/John is happy near a campfire" and get instant results
Zero cloud dependency: Your raw videos never leave your machine
Vector database: Uses ChromaDB locally to store metadata and enable semantic search
NLP query parsing: Converts natural language to structured queries (uses Gemini API by default, but fully supports local LLMs via Ollama)
Rough cut generation: Select scenes and export as video + FCPXML for Final Cut Pro (coming soon)

# The workflow:

1. Drop your video library into the app
2. It analyzes everything once (takes time, but only happens once)
3. Search naturally: "scenes with "@sarah" looking surprised"
4. Get results in seconds, even across 2TB of footage
5. Export selected scenes as rough cuts

# Technical stack:

Electron app (cross-platform desktop)
Python backend for ML processing (face_recognition, YOLOv8, FER)
ChromaDB for local vector storage
FFmpeg for video processing
Plugin architecture – easy to extend with custom analyzers

# Self-hosting benefits:

Privacy: Your personal videos stay on your hardware
Cost: Free after setup (vs $0.10/min on GCP)
Speed: No upload/download bottlenecks
Customization: Plugin system for custom analyzers
Offline capable: Can run 100% offline with local LLM

# Current limitations:

Needs decent hardware (GPU recommended, but CPU works)
Face recognition requires initial training (adding known faces)
First-time indexing is slow (but only done once)
Query parsing uses Gemini API by default (easily swappable for Ollama)

# Why share this:

I can't be the only person drowning in video files. Parents with family footage, content creators, documentary makers, security camera hoarders – anyone with large video libraries who wants semantic search without cloud costs.

Repo: https://github.com/iliashad/edit-mind
Demo: https://youtu.be/Ky9v85Mk6aY
License: MIT

Built this over a few weekends out of frustration. Would love your feedback on architecture, deployment strategies, or feature ideas!




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

I built a simple Discord bot that notifies you of new GitHub issues/PRs (and lets you filter by label and type)

https://github.com/Easonliuuuuu/Github-issue-discord-bot.git

I built it to be useful for everyone. For people who just started contributing to open source, you can set up a personal tracker for "good first issue" labels across all your favorite repos. For seasoned developers, you can set it up in your team's channel to monitor all new PRs, or just filter for issues with a specific "bug" or "needs-review" label.

It's a Python bot, and it's 100% open-source.

Invitation Link

Let me know what you think!

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

I built a free tool to visualize your Google Timeline data (100% in your browser, no data uploaded)

TL;DR: Export your Google Timeline data, drag it into this tool, and see all your location history on an interactive map. Everything runs in your browser - your data never leaves your computer

I'd attach a screenshot, but this sub unfortunately doesn't allow it. Here's a link to the screenshot though: https://pbs.twimg.com/media/G3dTDt6WQAAtynK?format=jpg&name=4096x4096

# Why I built this

Google recently killed their web-based Timeline viewer and started limiting how long they keep your location history. When you export your data, you just get JSON files that are basically useless without a way to visualize them.

I mean, I already have Dawarich that could do pretty much the same, but it heavily relies on backend processing, so for a browser-based quick viewer, I had to rebuild it from scratch.

So, my Timeline Visualizer can:

Handle massive files (tested with 600k+ GPS points)
Not send my location data to yet another server
Actually work without crashing my browser

# How it works

Drop your Google Timeline JSON files into the browser. The tool:

1. Auto-detects the format (Records.json, Semantic Timeline, Location History, etc.)
2. Processes everything locally in JavaScript
3. Streams points to an interactive map in batches
4. Shows your location history with activity paths

For a 170 MB file with 630,000 points, it takes about 7-8 seconds to process on my MacBook Pro M1 Pro.

# Privacy first

Your data never leaves your browser. No uploads, no tracking, no servers. All processing happens in JavaScript on your device. Close the tab and your data is gone.

It's open source too, so you can verify exactly what it does: [GitHub](https://github.com/dawarich-app/site/blob/main/src/components/TimelineMap.js)

# Features

Year filtering \- Too many points? Filter by year. The tool defaults to showing just your earliest year (usually 40-60k points instead of 600k+)
Visits \- Side panel shows only actual visits/places, not every GPS ping
Activity paths \- See your routes on the map
Auto-zoom \- Switch years and the map automatically fits to that data
Dark mode \- Because of course

# Supported formats

Everything Google exports:

Records.json (raw GPS pings)
Semantic Timeline (YYYY_MONTH.json files)
Location History (newer phone exports)

# Getting your data

Instructions are on the tool page, but basically:

Google Takeout \- takeout.google.com (doesn't work for everyone anymore)
Android \- Google Maps → Settings → Location → Location Services → Timeline → Export
iOS \- Google Maps → Settings → Personal Content → Export Timeline data

# Limitations

Bigger files take time to process. I personally have a Records.json file size of \~170 MB with 630,000 points and it worked well and fast, but it always depends on your hardware and file size. Older computers with limited RAM might struggle with multiple huge files.

Try it: dawarich.app/tools/timeline-visualizer

Code: GitHub

Since I created Dawarich, I'm already familiar with the JSON files schema, but still, I used locationhistoryformat.com to double-check some details about the different formats Google uses. It misses schema for the newer phone exports, though, so I used jq to inspect those files directly.

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

Gisia: An Open Source Lightweight Self-Hosted DevOps Platform for Your Projects
https://github.com/gisiahq/gisia

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

I built an open-source Steam automation tool (Steam Game Idler) as an alternative to ArchiSteamFarm, Steam Achievement Manager, and Idle Master

**TL;DR:** Created [Steam Game Idler](https://github.com/zevnda/steam-game-idler) \- a modern, user-friendly tool for farming Steam trading cards, managing achievements, and boosting playtime. Fully open-source, no telemetry, uses official Steam APIs.

# The Problem

If you're a PC gamer, you know Steam's trading card system is tedious. You need to idle games for hours to get card drops. For 500+ game libraries, that's impractical.

Existing solutions like **ArchiSteamFarm** are powerful but complex (JSON configs, CLI-heavy, designed for headless servers). **Idle Master** was great but abandoned in 2016 and **Idle Master Extended** has its bugs too.

# The Solution

I built **Steam Game Idler (SGI)** to be:

* **Modern stack:** Tauri + TypeScript + Rust (lightweight, fast, native)
* **User-friendly:** Actual GUI, no config files needed
* **All-in-one:** Card farming, achievement management, and playtime boosting in one app
* **Security-first:** AES-256-GCM encryption, official Steamworks SDK, zero telemetry
* **Fully open-source:** [Audit the code yourself](https://github.com/zevnda/steam-game-idler)

# Features

* Idle up to 32 games simultaneously (Steam's limit)
* Auto-unlock achievements with human-like timing
* Manually lock/unlock any achievement
* Trading card inventory manager
* Playtime booster
* Real-time notifications for card drops

# Why Open Source Matters

Steam automation tools have a bad rep - some are malware, others are sketchy. I wanted full transparency:

* Anyone can review the source code
* Build from source if you don't trust binaries
* Community contributions welcome
* No hidden telemetry or data collection

The project has 300+ GitHub stars and active issues and discussions.

# Tech Stack

* **Frontend:** TypeScript + React (NextJS)
* **Backend:** Rust (via Tauri)
* **APIs:** Official Steamworks SDK (not reverse-engineered hacks) and a custom C# tool
* **Security:** Custom XOR-based obfuscation for local credential storage
* **Platform:** Windows

# Current State

* ✅ Stable release (v2.1.20)
* ✅ Active development
* ✅ Full documentation at [steamgameidler.com](https://steamgameidler.com)
* ❌ Linux/Mac support

# Lessons Learned

Building this taught me a lot about:

* Working with proprietary APIs (Steamworks is... interesting)
* Balancing power-user features with beginner UX
* Security best practices for local credential storage
* Why Tauri is awesome for desktop apps (smaller bundle size than Electron, native performance)

# Get Involved

* **GitHub:** [github.com/zevnda/steam-game-idler](https://github.com/zevnda/steam-game-idler)
* **Docs:** [steamgameidler.com](https://steamgameidler.com)
* **Issues/PRs welcome!**

Happy to answer questions about the tech stack, Steam APIs, or anything else. Also open to feedback and feature requests.

**Note:** This is a personal project I use myself. Steam's ToS is vague on automation, so use at your own risk. No bans reported in 10+ years of similar tools existing, but YMMV.

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

GitHub - timeplus-io/proton: Fastest SQL pipeline engine in a single C++ binary, for stream processing, analytics, observability and AI.
https://github.com/timeplus-io/proton

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

built an app that tracks the world’s top artists

hey everyone,
i’ve been working on a small project called world's top artists: it tracks the world’s top 500 artists, updated daily, with insights, real-time stats and discovery features.

the data comes from both spotify and apple music, aggregated into one place.
it includes a bunch of cool views:
– a world map showing top cities for listeners
– a constellation graph showing how artists are connected (based on related artists)
– a “former 500” page that keeps track of artists who dropped out of the chart
– artist and music discovery features based on daily trends

right now the app pulls the top 500 from **kworb.net**, but I also keep a separate file of around 15,000 potential artists who could enter the top list.
I chose this approach because for now it’s a showcase / mvp, and I didn’t want to do heavy scraping.
if the app shows potential and people enjoy it, I plan to move it to a proper server and domain.
I already have an algorithm that can fetch the top 500 directly from spotify without relying on other sources.

the interesting part is that the whole thing is fully client-side, so no backend at all.
all data is stored as static json files on github, and a noscript runs every 24h via github actions to rebuild and push the new data.
it’s fast, lightweight, and surprisingly capable for something that’s just html, json and javanoscript, thanks to next.js export optimization :D

link: https://music.eduardlupu.com
github: https://github.com/EduardLupu/spotify-artists

i’d really love to hear any kind of feedback: things you’d add, improve, or explore.
I want to keep working on it, but I’m kind of short on new ideas at the moment.
what features do you think would be fun or interesting to see next?

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

🌱 Just released my first small web dev project — still learning, but proud of how it’s coming along!

👋 Hey everyone!

I’ve been learning web development for a while (still a student, trying to get better every day), and I finally decided to share one of my first small projects.

It’s a simple web page I built to practice HTML, CSS, and JavaScript — nothing huge, but it helped me understand layouts, responsive design, and a bit of interactivity.

The project isn’t perfect (far from it 😅), but I’d love to get some feedback or suggestions from more experienced developers — especially on how to structure my code better or make the design more modern.

🔗 GitHub repo: https://github.com/SplashyFrost/Urban-Threads-Streetwear

I’m really open to learning and improving, so any comment or tip would mean a lot 🙏
Thanks for taking the time to check it out!

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

Lightweight, minimalist/customizable software for writing?

I work better on paper, however it is wasteful and my wrist resents me.

For notes, I use notepad++ with everything stripped down so its nothing but a blank window, but I dont quite feel compelled to write there. Libreoffice lags the hell off in my pc (3000g,8gbram) past a few dozen pages, and while I like gdocs, specially because it works on the cloud, it also underperforms past a certain point and sometimes also feel a bit clunky.

I dont need a lot of formatting options, what I want is

\- Reliable autosave (notepad++ has failed me more than ocne in several diferent ways)

\- Lightweight (I like how notepad++ allows me to just instantly scroll up and down a txt with several mb under its belt with no issue)

\- Sanity (basically nothing breaking down if I copy paste it from on to it)

\- No distractions/clutter

Any advice?

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

Best open source video editor for hierarchical video clip management between multiple subfolders

There are two folders below my main project folder:

Folder01 contains it's own separate project file named “project01” with it's own clips.

Folder02 contains “project02", a separate project file that only contains a few clips and nothing else.

We need to include project01 as part of project02's timeline and integrate that file into our project's timeline before exporting it as one single mp4 file as part of our greater project. Is there a way to do this without having to export project01 first under specific open source video editing programs like shotcut, kdenlive, and openshot?

Which one of these open source video editing programs might help us achieve complex video editing task involving two or more subfolders like these (by importing, I mean being able to include a project file and treat it as it where one single clip from our timeline's perspective)?

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

Project Built a TypeScript validation library with features the market leader doesn't have - MIT licensed

Hi r/opensource! 👋

I've been working on an open source TypeScript validation library called lite-schema-check and wanted to share it with this community.

Why I Built This

I was frustrated with existing validation libraries (mainly Zod) missing key features that developers keep requesting. Their #1 requested feature (FormData validation - 60+ votes) has been open for over a year with no implementation.

So I built it myself, and made it open source from day one.

What Makes It Different

Features the competition doesn't have:

✅ FormData validation with automatic type conversion
✅ Partial validation (return valid data even if some fields fail)
✅ Built-in JSON Schema export (no external packages)
✅ File validation (size, MIME types)
✅ XOR support (exactly one of multiple fields)
✅ Chainable string/number refinements
✅ Schema denoscriptions and metadata
✅ Mixed sync/async validation
✅ Circular/recursive schema support
✅ Reversible transforms (codecs)
✅ Clearer optional/nullable/nullish API

Technical Details:

Zero dependencies
\~3KB minified
Full TypeScript support with type inference
60+ passing tests
Works in Node.js and browsers
MIT licensed

\## Code Example

typenoscript

import { v2 } from 'lite-schema-check';
// Automatic FormData validation with type conversion
const schema = v2.object({
name: v2.string(),
age: v2.number(),
email: v2.string().email(),
avatar: v2.file({ maxSize: 5_000_000, mimeTypes: ['image/jpeg', 'image/png'] })
});
const result = v2.validateFormData(formData, schema);
// All types automatically converted: "25" → 25



\## Project Status

📦 Published on npm: `lite-schema-check`
🔗 GitHub: [https://github.com/YOUR\_USERNAME/lite-schema-check](https://github.com/YOUR_USERNAME/lite-schema-check)
📝 MIT License
🧪 60+ tests passing
📚 Full documentation
🤝 Open to contributions

\## Looking For

**Code reviews** - Always room for improvement
\*Contributors** - Especially for Angular/React integrations
\*Use cases** - What features would you need?
\*Feedback** - Be brutally honest!
\*Security audits** - Fresh eyes welcome

\## Contributing

I've set up:

[CONTRIBUTING.md](http://CONTRIBUTING.md) with guidelines
CODE_OF_CONDUCT.md
Issue templates
PR templates
Clear coding standards

This is a genuine open source project - not a company product, not trying to sell anything. Just solving a problem I had and sharing it.

Would love to hear your thoughts, especially on:

1. Is the API intuitive?
2. What features would make it more useful?
3. Any concerns about the approach?

Thanks for reading! 🙏



Links:

\- GitHub: https://github.com/toozuuu/lite-schema-check
\- npm: [https://www.npmjs.com/package/lite-schema-check](https://www.npmjs.com/package/lite-schema-check)
\- License: MIT

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

🌍 GlobalCVE — Unified CVE Data from Around the World

Hey folks 👋

If you track vulnerabilities across multiple CVE databases, check out GlobalCVE.It aggregates CVE data from NVD, MITRE, CNNVD, JVN, CERT-FR, and more — all in one searchable feed.

It’s open-source (GitHub), API-friendly, and built to reduce duplication and blind spots across fragmented CVE listings.

Not flashy — just a practical tool for researchers, analysts, and anyone who wants a clearer view of global vulnerability data.

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

What's your favorite OPEN SOURCE Chromium-based browser with MV3 and vertical tabs?

Hi r/opensource, I've been a heavy user of the zen browser ever since it came out, and as such I really want a browser with similar features (proper ad block, vertical tabs, containerized workspaces) BUT I want it to be chromium-based, as just in the past week I ran into five websites that did not work on firefox (broken dropdowns, registration buttons doing nothing, important elements not appearing), and it is hard to continue using it.

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

Built a package manager to compile & install packages directly from their git repository
https://github.com/phukon/sprout

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

Lightweight Python Implementation of Shamir's Secret Sharing with Verifiable Shares

Hi r/opensource!

I built a lightweight Python library for Shamir's Secret Sharing (SSS), which splits secrets (like keys) into shares, needing only a threshold to reconstruct. It also supports Feldman's Verifiable Secret Sharing to check share validity securely.

**What my project does**

Basically you have a secret(a password, a key, an access token, an API token, password for your cryptowallet, a secret formula/recipe, codes for nuclear missiles). You can split your secret in n shares between your friends, coworkers, partner etc. and to reconstruct your secret you will need at least k shares. For example: total of 5 shares but you need at least 3 to recover the secret). An impostor having less than k shares learns nothing about the secret(for context if he has 2 out of 3 shares he can't recover the secret even with unlimited computing power - unless he exploits the discrete log problem but this is infeasible for current computers). If you want to you can not to use this Feldman's scheme(which verifies the share) so your secret is safe even with unlimited computing power, even with unlimited quantum computers - mathematically with fewer than k shares it is impossible to recover the secret

Features:

* Minimal deps (pycryptodome), pure Python.
* File or variable-based workflows with Base64 shares.
* Easy API for splitting, verifying, and recovering secrets.
* MIT-licensed, great for secure key management or learning crypto.

Comparison with other implementations:

* pycryptodome - it allows only 16 bytes to be split where mine allows unlimited(as long as you're willing to wait cause everything is computed on your local machine). Also this implementation does not have this feature where you can verify the validity of your share. Also this returns raw bytes array where mine returns base64 (which is easier to transport/send)
* [This](https://github.com/thedanhub/shamir-secret-sharing) repo allows you to share your secret but it should already be in number format where mine automatically converts your secret into number. Also this repo requires you to put your share as raw coordinates which I think is too technical.
* Other notes: my project allows you to recover your secret with either vars or files. It implements Feldman's Scheme for verifying your share. It stores the share in a convenient format *base64* and a lot more, check it out for docs

**Target audience**

I would say it is production ready as it covers all security measures: primes for discrete logarithm problem of at least 1024 bits, perfect secrecy and so on. **Even so, I wouldn't recommend its use for high confidential data(like codes for nuclear missiles) unless some expert confirms its secure**

Check it out:

* PyPI: [https://pypi.org/project/shamir-lbodlev/](https://pypi.org/project/shamir-lbodlev/) (pip install shamir-lbodlev)
* GitHub: [https://github.com/lbodlev888/shamir](https://github.com/lbodlev888/shamir-lbodlev) (README with examples)

\-Feedback or feature ideas? Let me know [here](https://github.com/lbodlev888/shamir/issues)!

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

Unlocking the Sony PSP's Second CPU

Hey all!

The PSP may be an old device, but it still holds plenty of mysteries and possibilities for tinkering!

So I started this open-source project earlier this year with the goal of taking advantage of the Sony PSP's Media Engine, specifically its second MIPS CPU core, which has essentially the same capabilities as the main one.

However, it has no direct access to main system functions. It runs its own 'factory' core with functions stored in a kernel memory space, which hasn't been fully reverse-engineered yet.

- This project comes as a library that maps as many functions as possible from the Media Engine's core to make them accessible to homebrew developers

- It provides a custom initialization system and utility functions to simplify working with the Media Engine.

- It handles interrupts, suspend events, stack and local memory optimization, and thread management which is in WIP.

It's designed to make it easier for PSP homebrew developers to ease the integration and communication with the Media Engine. It's a work in progress, and contributions are welcome!

Available on GitHub: mcidclan/psp-media-engine-custom-core

Enjoy !

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

I built Flowcraft, a lightweight, zero-dependency alternative to heavy workflow platforms like Temporal/Airflow/Vercel
https://github.com/gorango/flowcraft

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

What if Goldman Sachs made Slang open source?
https://youtube.com/shorts/wm5-vujv0FQ

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

[R] Adaptive Sparse Training on ImageNet-100: 92.1% Accuracy with 61% Energy Savings (Open-source, zero degradation)

**TL;DR**: Implemented **Adaptive Sparse Training (AST)** on ImageNet-100 with a pretrained ResNet-50. Trains on \~37–39% of samples per epoch, cuts energy by \~61–63%, gets **92.12%** top-1 (baseline **92.18%**) with **no meaningful drop**; a faster “efficiency” variant reaches **2.78×** speedup with \~1–2 pp accuracy drop. **Code + noscripts open-source** (links below).

# Key Results

**Production (best accuracy)**

* **Top-1:** 92.12% (baseline: 92.18%) → Δ = **+0.06 pp**
* **Energy:** **–61.49%**
* **Speed:** **1.92×** over baseline
* **Activation rate:** 38.51% of samples/epoch

**Efficiency (max speed)**

* **Top-1:** 91.92%
* **Energy:** **–63.36%**
* **Speed:** **2.78×**
* **Activation rate:** 36.64%

# Method: Adaptive Sparse Training (AST)

At each step, select only the most informative samples using a significance score combining **loss magnitude** and **prediction entropy**:

significance = 0.7 * loss_magnitude + 0.3 * prediction_entropy
active_mask = significance >= dynamic_threshold # selects top K%


* Trains on **\~10–40%** of samples per epoch after warmup.
* **PI controller** keeps the target activation rate stable over training.

# Setup

* **Model:** ResNet-50 (pretrained on ImageNet-1K, 23.7M params)
* **Data:** ImageNet-100 (126,689 train / 5,000 val; 100 classes)
* **Hardware:** Kaggle P100 GPU (free tier) — fully reproducible

**Two-stage schedule**

1. **Warmup (10 epochs):** 100% samples (adapts features to 100-class subset)
2. **AST (90 epochs):** adaptive selection, 10–40% active

**Optimizations**

* **Gradient masking** → single forward pass (vs double) for \~3× reduction in overhead
* **AMP (FP16/FP32)** on both baseline and AST
* Dataloader tuning (prefetch, 8 workers)

# Why it matters

* **Sustainability**: \~61–63% less training energy
* **Iteration speed**: **1.9–2.8×** faster ⇒ more experiments per GPU-hour
* **Accuracy**: Production variant matches/slightly outperforms baseline (transfer setting)
* **Drop-in**: Works with standard pretrained pipelines; no exotic components

# Notes & comparisons

* **Baseline parity**: Same ResNet-50, optimizer (SGD+momentum), LR schedule, and aug as AST; only sample selection differs.
* **Overhead**: Significance scoring reuses loss/entropy; <1% compute overhead.
* **Relation to prior ideas**:
* Random sampling: no model-aware selection
* Curriculum learning: AST is **fully automatic**, no manual ordering
* Active learning: selection **per epoch** during training, not one-shot dataset pruning
* **From scratch?** Not tested (this work targets transfer setups most common in practice).

# Code & Repro

* **Repo**: [https://github.com/oluwafemidiakhoa/adaptive-sparse-training](https://github.com/oluwafemidiakhoa/adaptive-sparse-training)
* **Production noscript (best acc)**: `KAGGLE_IMAGENET100_AST_PRODUCTION.py`
* **Efficiency noscript (max speed)**: `KAGGLE_IMAGENET100_AST_TWO_STAGE_Prod.py`
* **Guide**: `FILE_GUIDE.md` (which version to use)
* **README**: complete docs and commands

# Discussion

1. Experiences with **adaptive sample selection** at larger scales (ImageNet-1K / beyond)?
2. Thoughts on **warmup→AST** vs training from scratch?
3. Interested in collaborating on **ImageNet-1K** or **LLM fine-tuning** evaluations?
4. Suggested **ablations** (e.g., different entropy/loss weights, alternative uncertainty metrics)?

**Planned next steps**: full ImageNet-1K runs, extensions to BERT/GPT-style fine-tuning, foundation-model trials, and curriculum-learning comparisons.

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

FlexingUSB is a New, Blazing-Fast, & Safe Terminal Utility for Creating Bootable USBs on macOS (Faster than dd/Etcher)
https://github.com/Goenvim/FlexingUSB

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

The OSI is seeking its next Executive Director, responsible for advancing its mission, growing and diversifying its funding base, and fostering a global, inclusive community of stakeholders.
https://opensource.org/blog/open-source-initiative-now-accepting-your-application-for-executive-director

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