Link → https://github.com/whoissaaif/mycam

Hey everyone. I've been a YouTube creator for years, and I've always wanted to explore how plausible fully automated video production actually is. I'm not talking about stitching stock clips together, but research, script, voice, animation, review and publishing, end to end. With the models getting better every month, this felt like the time to find out, so a few months ago I started building it. It's called TubeMatic.

What it does

You give it a subject, say "Python Internals". On a schedule, an AI agent researches sub-topics inside it, proposes video ideas with a 1–10 score for how well each suits a short explainer, and writes the script in a style you pick (it can learn the style from public YouTube videos you like). Then it voices the script with ElevenLabs, generates the imagery, writes every scene as a React component rendered with Remotion, and renders a vertical mp4. Optionally Gemini watches the finished video, points out what's wrong, and the agent goes back and fixes it.

Then it publishes to YouTube, Instagram, TikTok and Facebook, now or on a schedule, and pulls the views back into its own analytics page.

You choose how hands-on you want to be

By default it stops at three checkpoints: before research becomes work, before voicing, and before anything goes public. You approve, request a revision, or reject. Or you put a project on Auto Pilot and it runs the whole loop with nobody at the controls (fully autonomous).

It works with the coding agent you already have (Claude Code, Codex or OpenCode) through your existing subscription, so there's no separate per-token API bill for the writing.

It is open source and self-hosted. Everything runs in Docker on any Linux machine.

I've been running it myself for about a month on three channels, two on Instagram and one on YouTube. They've passed 150K combined views in a month.

Give it a try!

Links

• Docs and install: https://docs.tubematic.ai
• GitHub: https://github.com/teja156/tubematic
• Walkthrough video: https://youtu.be/-y9zBSg8WEc

Over the past few years I've been searching far and wide for a wiki-style knowledge base that feels as modern as the big commercial tools. There definitely are some fantastic open-source wikis out there, but the established ones often feel dated, and the newer ones tend to be either too bare-bones or too sprawling.

So here's my contribution, or rather the beginnings of it. It's early and rough in places, which is why I'm looking for people to help shape it, but it's also fairly usable already.

Wikid is a self-hosted wiki and collaborative workspace:

• Nested pages, a block editor with / commands, live co-editing
• Databases inside the wiki: table, board and gallery views, filters and sorts
• Forms that submit straight into a database
• An optional compliance mode with workflows and an audit trail, for records that need one
• Search, dark/light themes, HTML/PDF/Markdown export

It's AGPL-licensed and runs with docker compose up. Built with Vue 3/Tiptap, NestJS, Postgres and Yjs.

I've marked each feature as stable, beta or experimental in FEATURES.md, and there's a roadmap (search is done; hardening and page history are next).

It's a party of one + Claude at the moment, so I'd love some feedback, and contributors – let's get this thing off the ground! There are good first issues if you want a way in...and it needs a favicon, since I don't have the time to be very creative these days 😪

https://github.com/LoopyDev/Wikid

I built it with heavy use of AI coding tools. I'm a systems engineer by trade, and every change is reviewed and backed by automated tests (unit, API and browser, run in CI on every change). AI-assisted contributions are obviously welcome too; just take care to understand and test what you submit.

I've been developing FableCut, an open-source video editor built around the idea that AI agents should be able to operate editing software directly, rather than only generating separate video files.

The project has a browser-based editor called FableCut Studio and a local version distributed through npm. Both are designed to support editing workflows, with MCP providing a way for compatible AI agents to interact with the project.

What it includes:

• Timeline editing: Three-point editing, ripple, roll, slip, slide, track targeting, markers, and keyboard shortcuts.
• Audio: EQ, compression, limiting, reverb, noise reduction, loudness normalization, and automatic ducking.
• Color grading: Scopes, color wheels, curves, and HSL controls.
• Motion and compositing: Masks, motion tracking, shape layers, parenting, motion paths, and motion blur.
• Speech editing: Browser-based transcription, transcript-driven cuts, word-timed captions, and silence removal.
• Project workflows: Multiple sequences, version history, proxies, offline media relinking, and batch export.

Studio exposes 16 tools through a remote MCP server, allowing compatible agents to modify a timeline in the browser. The relay carries tool calls and results, including project text and requested frames, but not the video media files themselves.

The latest release adds transcription and text-based editing powered by Whisper running in the browser. The first transcription downloads a model of around 77 MB.

FableCut is released under the MIT license, and Studio is free to try. The local npm version is available with:

npx -y fablecut

I'm continuing to improve the project and welcome bug reports, feature requests, contributions, and technical feedback.

Studio: https://studio.fablecut.space/

Website: https://fablecut.space

Demo: Youtube

Repository: https://github.com/ronak-create/FableCut

Probably every guitar player knows the Axe-Fx III, but not everyone has the money to buy one (myself included). So I've decided to give it a shot and vibe clone it using Claude.

The idea is based on the same core principles: a Newton–Raphson electrical circuit solver, with amps and effects modeled from their actual schematics.

It works surprisingly well, for an amateur guitarist like me. 😄

[free, open source, GNU GPL-3.0]

https://github.com/Rikarin/cathode

Hey everyone!

We recently open-sourced OpenMHS, an independent project inspired by Anthropic's Model Hardware Standard (MHS) research preview.

The idea: AI agents can interact with software, but what if they could discover and interact with programmable hardware through a common, reliable interface?

So we built OpenMHS, a model-agnostic Rust runtime that bridges AI agents and hardware.

What we've built:

• MCP, CLI, and Python SDK interfaces
• Modbus TCP, MQTT, SCPI, and HTTP adapters
• Hardware discovery and capability-based permissions
• Command auditing, execution tracking, and readback verification
• Simulators and conformance tests

We've tested it with OctoPrint's Virtual Printer, protocol simulators, and emulated ESP32 firmware. Physical hardware testing is our next milestone.

Our goal is to make OpenMHS useful for robotics developers, research labs, hardware manufacturers, and the wider Physical AI community.

We're actively looking for contributors, early adopters, and engineers interested in testing new hardware integrations.

GitHub: https://github.com/KNambiarDJsc/Open-MHS

Website: https://openmhs.vercel.app

Would love your feedback, ideas, and contributions. ⭐

Credit first: openGym is by Duarte Santos, here is (his repo). His app, his work, AGPL license. I just train with it and wanted a version shaped like how I actually use it, so I forked it.

What I changed:
• Took out the gym check-in card and the AI coach. I never used them.
• Option 1: open the link, add it to your home screen, done. It is a static website, your data stays in your browser.
• Option 2: if you want sync between devices, plug in your own free Firestore and deploy on Vercel. No server to run. There is a deploy button and a short guide in the repo.

Everything else is his openGym: the logging, plans, stats, exercise library, all of it.

Live: https://opengym-lean.vercel.app/#/home
My fork: https://github.com/0xovo/opengym-lean

Feedback is welcome, mostly I want to know if the sync setup works for other people or breaks somewhere.

COBOL turns 67 this year, so I wanted to see if it could run a modern-looking web app with nothing in front of it. No Node, no nginx, no CGI wrapper.

How it works

Server: COBOL calls libc’s socket/bind/listen/accept directly and forks a process per connection. Forking turned out to be necessary because Safari opens connections in advance and then sends nothing on them, which would freeze a server that handles one request at a time.

Routing: an EVALUATE statement, which is basically a switch on method and path.

Rendering: server-side with STRING ... WITH POINTER, so every page is built from string pieces in COBOL. User input gets HTML-escaped. Typing <script>alert(1)</script> as a habit name just shows up as text.

Zero JavaScript: every button is a plain <form method="post">, and the server answers with a 303 redirect back to / (POST/redirect/GET), so refreshing never resubmits anything.

Styling: one CSS file. The progress ring is a conic-gradient, and each habit’s color comes from color-mix().

Data: two text files with fixed-width records. Dates use COBOL’s INTEGER-OF-DATE, which honestly beats JavaScript’s Date.

It’s about 650 lines including comments, and the page reloads fast enough that you barely notice there’s no JS. To be clear, this is an experiment, not something to deploy. It’s macOS only, listens on localhost only, and has fixed limits like 100 habits max.

📺 Video walkthrough: https://youtu.be/lbkTRdpedS0

💻 Code: https://github.com/nick-friedrich/cobol-web-app

Happy to answer questions. Which old language should I try next?

Give it a video and a target language, get back a narrated voice-over, the mixed video and subtitles. Python, faster-whisper, LLM translation with a review pass, ElevenLabs voices, AGPL. Native speakers' language notes and help with how names are spelled in each language are the most welcome contributions.

I kept running into the same little annoyance on Windows: I'd copy something, switch to another task, and then have to interrupt what I was doing to find it again.

Windows already has clipboard history, so I didn't want to build just another version of the same panel. I wanted to try a different interaction.

That turned into Noxra — a free clipboard manager that opens from the edge of the screen. The idea is to make copied items easier to reach without relying on a keyboard shortcut every time.

I'm the developer, and the project is available on GitHub:
https://github.com/aa27259/Noxra

I'd genuinely appreciate feedback on the interface. Does accessing clipboard history from the screen edge make sense to you, or would you rather stick with Win + V?

Hey everyone! 👋

Creating short-form coding content for YouTube Shorts and TikTok is super tedious. Writing the solution, recording voiceovers, highlighting code line-by-line, syncing kinetic subtitles, and editing video takes hours for just a 30-second clip.

To automate this, I built a programmatic video pipeline using **Next.js 14**, **Remotion**, and **Google Gemini**: you type *any* coding challenge or DSA prompt, and it generates a fully-rendered, animated video with neural voiceover, syntax-highlighted code tracing, and synchronized captions in seconds.

🎬 **Here is a sample 30-second Short completely generated by the app:**

👉 **[Watch on YouTube Shorts](https://www.youtube.com/shorts/ZJpOMq6or9I)\*\*

---

### 🚀 What it does:

1. **Prompt-to-Video with Gemini AI**: Enter any algorithm (e.g. *"Valid Anagram"*, *"Merge Sort"*, *"LRU Cache in O(1)"*). Gemini generates the clean JavaScript solution, optimal Big-O time & space complexities, and a structured multi-scene narration script.

2. **Dual Video Modes**:

   - **YouTube Shorts (15s–60s)**: 1080×1920 (9:16 vertical) designed for Shorts, Reels, and TikTok.

   - **Full Video Tutorials (2–5 minutes)**: 1920×1080 (16:9 widescreen) in-depth tutorial with detailed walkthroughs.

3. **Programmatic Video with Remotion**:

   - Real-time in-browser canvas player preview.

   - Code panel with automated line-by-line highlight tracing.

   - Word-by-word kinetic subtitles cleanly positioned beneath the content.

   - Floating Picture-in-Picture webcam avatar with randomized procedural 3D motion (Cyberpunk glitch, Energetic beat, Smooth flow, Live streamer).

4. **Local Neural Speech (TTS)**: Synthesizes high-quality voiceover audio and multiplexes it directly into the MP4 container via FFmpeg.

5. **Zero Disk Storage Bloat**: Because Remotion embeds the audio stream directly into the final MP4 container, temporary narration audio files are automatically cleaned up upon downloading the video.

### 🛠️ Tech Stack:

- **Framework**: Next.js 14 (App Router), React, TypeScript

- **Video Engine**: Remotion 4.0, Chrome Headless, FFmpeg

- **AI**: Google Gemini API (`gemini-2.5-flash`, `gemini-flash-lite`) with multi-model quota fallback

- **Voice Synthesis**: Edge-TTS & Windows SAPI

- **Styling**: Tailwind CSS & Vanilla CSS

Check out the sample Short here: https://www.youtube.com/shorts/ZJpOMq6or9I

I’d love to hear your feedback, thoughts on the video pacing, and ideas for what features to add next!

With the original 90s/early 2000s version not working on my PC anymore, I decided I wanted a modern version with the same simplicity, but high refresh rate support.

There are three versions:

1. Windows screensaver (<270KB)
2. macOS screensaver (<230KB unzipped)
3. HTML version (can also be used as a PWA on Android/iOS/ipadOS)

Take a look at https://github.com/waschmittel/starfield and tell me if it works well for you :-)

Hey everyone, Over the past months, I’ve been building Thread, a new statically-typed, compiled programming language designed to rethink how parallelism works in modern software.

The Core Idea: Automatic parallelism without the plumbing

In Thread, you don’t spawn threads, manage worker pools, sprinkle async/await, or guard memory with mutexes. Instead, the compiler analyzes data flow, proves memory disjointness and loop independence, and parallelizes safe operations automatically. Programs remain completely deterministic, so running the same code with the same inputs produces identical results, eliminating data races and nondeterministic synchronization bugs by design.

What the Language Looks Like

Thread combines modern ergonomics (value semantics, expressive pattern matching, traits, and strict exclusivity) with a clean syntax:

struct Point {
    var x: double
    var y: double
}

fn computeDistances(points: Array<Point>) -> Array<double> {
    // The compiler proves iterations are disjoint and parallelizes automatically
    return points.map(fn(p) {
        return (p.x * p.x + p.y * p.y).sqrt()
    })
}

fn main() {
    let pts = [Point(x: 3.0, y: 4.0), Point(x: 5.0, y: 12.0)]
    let dists = computeDistances(points: pts)
    print(dists)
}

Current State & Roadmap

Thread is currently in early active development. The core compiler driver (trc) and Language Server (trls) are operational on Linux (x86_64), alongside an IntelliJ / RustRover IDE plugin.

• Note on Source Code: The compiler is closed source for now. Development has been moving very quickly, and the internal codebase simply isn't at a standard of code quality that I'm comfortable sharing publicly yet. Pre-built binaries and editor tooling are provided for testing.
• Networking features (sockets, HTTP, and async I/O primitives) are actively being designed and implemented next.
• Bugfixes & stability improvements are ongoing as standard library coverage and edge-case testing expand.
• macOS (Apple Silicon) support is currently in preparation.

Testers & Feedback Welcome!

Development is very active, and I’m at the stage where real-world testing, bug reports, and syntax/design feedback are incredibly valuable. If you're on Linux (or WSL) and want to try it out, you can install the compiler and language server with the following command:

mkdir -p ~/.local/bin && \
  curl -fsSL https://download.lschreiber.eu/latest/trc-linux-x86_64 -o ~/.local/bin/trc && \
  curl -fsSL https://download.lschreiber.eu/latest/trls-linux-x86_64 -o ~/.local/bin/trls && \
  chmod +x ~/.local/bin/trc ~/.local/bin/trls

(Ensure ~/.local/bin is in your $PATH)

• Website: https://lschreiber.eu/thread/
• Downloads & JetBrains Plugin: https://lschreiber.eu/thread/download
• Documentation & Manual: https://lschreiber.eu/thread/docs/start/first-program I’d love to hear your thoughts and hear what features or benchmarks you'd like to see next!

Author here. The goal: one app for watching at home, set up once and run from the TV remote, instead of a torrent client, a media server, series and movie managers and a request app wired together. Torsher does those jobs in one container, with one SQLite database and one interface.

• Pick a title on the TV, press Watch, and playback starts while it downloads, only a window ahead of the playhead
• Keep moves it into a library Jellyfin, Plex and Kodi can read; on one volume it's a hard link and keeps seeding
• Follow a series and new episodes arrive on their own
• Bring any Torznab indexer (Prowlarr, Jackett); no sources included, no telemetry

Stack: Node 24 + Fastify + SQLite/Drizzle, a Go torrent engine on anacrolix/torrent, a Vue TV app that runs on LG's 2020 browser engine (Chromium 68), a Nuxt control panel. One signed image for amd64 and arm64, AGPL-3.0.

Docs and install: https://torsher.app

rv is a security runtime that sits between autonomous AI agents and everything they can touch: shell, files, secrets, MCP tools, and the network. Same category as NVIDIA OpenShell, but open source (Apache 2.0). Coding agents are the first market and what ships today.

What's in it:

• Rule packs + a policy layer. 95 deterministic packs (git, filesystem, disks, cloud CLIs, Kubernetes, databases, Terraform, and more); three are on by default. On top: typed rules in policy.toml at machine and repo level with revision history, allowlists, rule pinning, and normal/strict safety where strict always wins. Every decision is allow, deny, or indeterminate, and indeterminate never allows.
• A small judge model for the gray area. When packs allow something, a local CoreML judge can score it and send risky actions to review. A pack deny is a floor the judge can't lower. There's an observe mode that logs would-be verdicts without blocking.
• Secrets. Agents get placeholders, never values; a loopback gateway swaps in the real value. Sources include Keychain, 1Password, Vault, AWS Secrets Manager, Infisical, Bitwarden, GCP, and Azure. Reads and edits of secret paths (.env, SSH keys, cloud credentials) are blocked, and there's a git pre-commit secret scanner.
• MCP gateway. rv mcp serve runs approved servers behind a policy gateway. Tool calls marked ask pause until you approve, upstream secret values are scrubbed from responses, and rv mcp check flags servers that bypass rv or haven't been reviewed.
• Sandboxing. Contained workspaces use Seatbelt on macOS and Landlock on Linux, and fail closed if the sandbox can't be set up. Credentials aren't staged into a workspace unless you authorize a resource profile.
• Network egress control. A credentialed CONNECT proxy with per-grant tokens, SNI checks, and binary-pinned policy. Blocked requests become proposals in an rv egress review queue.
• Package-script inspection. For npm/pnpm/yarn/bun test/build/lint, rv reads the actual pre/body/post scripts in package.json and evaluates them, not just the command you see.
• Hash-chained audit log. Each line in audit.jsonl carries the SHA-256 of the previous one. rv audit verify finds the first break; export to OCSF 1.3.0 or forward to a SIEM.
• Offline session replay. rv scan goes back through past sessions from Claude, Codex, Cursor, Grok, Hermes, OpenClaw, OpenCode, and Pi and shows what would have been blocked.
• Signed org policy for fleets. Ed25519-signed, restrict-only policy.json (users can't loosen it) with anti-rollback serials and key rotation. rv report emits posture for MDM or fleet collection.
• Agent hosts. Hooks for Claude Code, Codex, Cursor, Grok, OpenCode, Pi, Hermes, OpenClaw, and Antigravity, wired by rv setup.

One small example of the shell layer, from the README:

$ rv test 'git reset --hard'
{"decision":"deny","pack_id":"core.git","reason":"git reset --hard destroys uncommitted changes","rule_id":"core.git:reset-hard","schema":"rv.test.v1"}

When an agent hits a deny, it gets a short code that only you can redeem from your own terminal (rv allow-once). The agent can't approve itself.

Install (macOS 15+ on Apple Silicon, or Linux):

curl -fsSL https://rykanv.com/install | sh
rv setup
rv doctor

Disclosure: I'm Chris, and I build rv. I'd like to hear what's missing for running agents unattended, what it blocked that it shouldn't have, and what it let through that it should have caught. If it's useful, a star helps other people find it.

Tabame is a customizable Windows launcher and productivity toolbox built to make everyday actions faster and easier to reach.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

It originally started as a simple alternative to the Windows taskbar: a small popup where I could see my open windows, control audio and quickly launch the things I use most. Over time, I kept adding tools I wished Windows had built in, and Tabame grew into something much bigger.

Today, Tabame brings a launcher, window management, screen capture tools, clipboard history, audio controls, reminders, file utilities, plugins and many smaller productivity tools together in one app.

The idea is simple: instead of opening a different application for every little task, press a hotkey and get to what you need.

The QuickMenu gives you fast access to your open windows, pinned apps, audio devices, media controls, tray icons, system information and your favorite actions. It can replace or complement the normal Windows taskbar, and its layout, appearance and behavior can be customized to fit the way you work.

The Launcher lets you search apps, files, open windows, browser tabs, bookmarks, commands and more from one text box. It also includes quick tools for calculations, currency and unit conversions, translations, timers and system commands.

Tabame also includes:

- QuickSnap for arranging windows into custom screen zones.
- QuickClick for controlling the mouse from your keyboard.
- FancyShot for taking screenshots and annotating them immediately.
- Screen Draw for drawing directly over your desktop during presentations or explanations.
- Screen Recording with region, monitor and window capture.
- Clipboard History for finding things you copied earlier.
- Audio controls for switching devices and adjusting individual application volume.
- Timers and reminders that can stay active between sessions.
- Color Picker, OCR, Emoji Picker and QR Scanner for common everyday tasks.
- File utilities for batch renaming, folder size scanning, project statistics, image tools and more.
- Custom hotkeys that can trigger one or several actions from a single shortcut.

One of the most useful parts of Tabame is its plugin system.

Plugins can add completely new functionality directly to the Launcher. They can be written using Python, Node.js or Bun and don't require compiling Tabame itself. If you use an AI coding assistant, Tabame also provides a documented plugin specification that makes it possible to describe the tool you want and have the assistant build much of the plugin for you.

This means Tabame doesn't have to be limited to the features included with the app. You can adapt it to your own workflow and create integrations for the services and tools you actually use.

Despite the number of features, Tabame is designed to stay out of the way. Most tools only appear when you call them with a hotkey, and you can enable, disable and rearrange features depending on what you need.

The interface is highly customizable too, with multiple designs for both the QuickMenu and Launcher, custom colors, light and dark modes, layouts and keyboard shortcuts.

Tabame is built for Windows, completely free and open source.

It is mostly a collection of things I wanted on my own computer — packaged into one app so I don't need ten separate utilities running just to make Windows work the way I like.

---

List of main features:

QuickMenu - Taskbar Replacement

Launcher - Open Files, folders, bookmarks, cli, notion, Obsidian + Unlimited features through Plugins

QuickSnap - Create custom layouts for windows and snap them (Fancyzone alternative)

QuickClick - Control Mouse through keyboard

Fancyshot - Capture Images and videos. You can create Stylized presets.

Color Picker - Pick colors from screen and get your custom format.

Emoji Picker - Custom built in emoji picker that appears next to the caret.

Quick Actions - 91 Quick Actions

Music Player - Built in music player for local or Navidrome/Jellyfin server.

Advanced Hotkeys - Customize actions based on movement and pressed time + active window.

Vaults - OTP Authenticator, Locked Vault for your API keys.

Screen Tools - Draw on screen, Spotlight (hide whole screen except focused app), QR Scanner, OCR Scanner.

Plugins - 81 Plugins

Browser Plugin Connection - You can use Claude API free directly from Tabame with Browser extension.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

I mostly use GitHub Stars as bookmarks, but sometimes I want to save a repo without starring it publicly. I also wanted to keep its description and README in case it gets deleted or becomes private later.

So I made a small tool called Starkive for myself.

It lets you save and organize repos, add notes, and keep a copy of their metadata and READMEs. Everything is stored in your own private GitHub repo, and the web dashboard runs on Vercel without a separate database.

Thought I'd share it here in case anyone else finds it useful.

GitHub: https://github.com/xorespesp/starkive

Works with local audiobooks or supports import from audible via Librisync. Each book is transcribed on your phone, and then the text follows along as you listen.

https://github.com/lukeherc-cpu/ReadAlong/releases/latest

Free and open source, no ads, no account, GPL-3.0 License

Blue Bear is my open-source Windows host reconnaissance tool, built around a simple idea: bring useful system and security context together in one place.

It explores things like process metadata, loaded DLLs, token privileges, integrity levels, domain information, and network connections.

This project has been a way for me to go deeper into Windows internals and low-level development instead of sticking to high-level scripts.

I'm sharing it here because I'd genuinely like feedback from people who work with Windows security.

🐻 GitHub: https://github.com/KernelPhantom-010/blue-bear-Red-Teaming-Host-Recon-Tool

What would make this more useful for your workflow?

I got tired of waiting for Google to implement "AI mode" well for Google Docs, so I ended up writing it myself.. because you can! The result is https://mcpdocs.freeflow.im . It comes as both a local app for local file viewing/Office doc editor (like traditional Office), and a deployable web app. It also includes: Markdown preview, editing/signing PDFs, OCR scan of PDFs to markdown, and image editing including background removal. Sort of combines like 4 or 5 separate tools into one.

All the editing tools are exposed through MCP, so you can "AI edit" either via a built-in assistant or by connecting your own MCP client (Claude Code, Codex, etc...) My biased opinion is that the AI mode works better (faster, more functional, supports multiple models) than Google's. I haven't used Copilot much so I can't compare to MSFT.

I would love people to try it, give me feedback, contribute to OSS if you want. Even just raising Issues (bugs or feature requests) would be awesome. Or fork it and customize it for what *you* need.

I personally think it's amazing that you can build your own very, very good software like this. This is already becoming a trend - people vibe coding apps to scratch their own itch. I'm realistic that this isn't solving some huge market problem. But I think we are entering sort of a golden period where you can break your dependence on Big Tech and build the stuff you need - break out of the "you are the product" trap.

EXIF dies on WhatsApp; this doesn't. Apache-2.0, one documented format, three engines that read each other's marks.
https://github.com/thevijayparmar/Ghostmark-Image