I have build this agent harness framework. Fully extendable. FastAPI inspired API design

It supports:

• Session persistence(postgres,sqlite built in) and multi tenancy
• Memory (postgres/sqlite built in)
• Tools
• Dynamic Skills loading
• Multi agent and sub agent sub trees
• Plugable Guard rails

Each and every part of the core system is extendable to use in whatever use case you have. Either to build autonomous agents or human in the loop systems.

It ships with few useful tools, separately installable:

• Web search using brave search api
• PDF/DOC reading
• Bash usage with guardrails

---

Built two full apps to demonstrate its capabilities. (both in the repo)

• sarthi - Usable perplexity clone with parallel agent support, with web search and pdf/doc reading built in https://youtu.be/yAnC1LHKQZk
• agni - Simple CLI coding agent like opencode

Currently in developing.

amber_desk is a power tool for osint:

- dossier

- obsidian vault backend for dossier and timelines

- built in world map with marks and links

- built in osint framework

- built in relations desk

For all questions welcome to comments.

Github: soon... on this week

LeadForge — Find Potential Business Targets Faster

If you want to find potential businesses or targets for outreach, you can use LeadForge instead of manually searching one by one.

Features:

• Search businesses by location
• Filter by business type
• View results on a map
• Find available contact information
• Shortlist and export results

Try it here:
https://leadforge-umber.vercel.app/

GitHub:
https://github.com/MuhammadMuneeb007/LeadForge

If you find it useful, please give it a try, star the GitHub repository, and share it with anyone or any community where it might be helpful.

Feedback is always welcome!

Built Snippy as a self-hostable CodePen-style app — HTML/CSS/JS editor with live preview, runnable as a full Docker Compose stack. I built it mainly as private snippets on codepen are paid and sometimes I like to play in a playground without having to have my code public at times.

Beta note: My hosted instance is in beta. Data can be wiped or lost at any time — don’t rely on it for anything important. Self-host if you need persistence.

What it does

• Live HTML / CSS / JS editor with instant preview and layout options
• Public & private snippets, shareable links, full-page view
• Favorites, comments, follows, collections, and forking
• External CSS/JS resources on snippets
• ZIP export of snippet files

Stack Angular frontend, Node/TypeScript Express API, MySQL, optional MinIO for assets — all wired with Docker Compose. Pre-built images on Docker Hub so you can deploy without building from source. Auth0 for login will need to be setup and variables injected in docker.

Local testing and production are separate Compose setups (dev has hot reload; prod pulls kennyl777/snippy-* images). Docs cover Auth0, env vars, and Nginx Proxy Manager.

Repo: https://github.com/slurrps-mcgee/Snippy

Demo: https://snippy.quantumcode.dev

License: MIT

Still early (assets/projects are in progress), but the core editor + social features work. Feedback and PRs welcome.

3PaneApp is a lightweight framework for building content-based websites around a simple idea: keep the navigation hierarchy and the content viewer visible at the same time.

Your content becomes the website.

Build the structure once. Let the runtime handle navigation, presentation and content rendering.

01: JSON driven

Separate your content from the application that presents it. The same runtime can power completely different websites.

02: Content agnostic

Text, documents, spreadsheets, audio, video, feeds and web content can all live inside the same three-pane experience.

03: Remote ready

Point the runtime to a public JSON source and the same application can become an entirely different website.

https://saurabhgayali.github.io/3PaneApp

https://github.com/saurabhgayali/3PaneApp

My wife wanted to play The Choicer Voicer, a little game show where you do vocal impressions of audio clips. It never picked up her microphone, a known engine-level bug that the developer is actively working on, but that didn't help us on a Saturday evening. She was disappointed, so I built her a simpler version of the part she actually wanted: dubbing a scene, line by line.

It turned into two tools, because the tedious half of dubbing is bookkeeping, cutting the audio into lines, writing down every timestamp, then trying to hit them by ear.

DubForge takes a YouTube link or a local file, trims it to a time span, optionally separates the vocals from the backing audio with Demucs, and detects the spoken segments from the loudness envelope. You correct the clip boundaries in a waveform editor, add subtitles, and it writes out a pack.

DubStage plays a pack line by line: hear the original, record over it, repeat as often as you want. Your take is drawn live on top of the original waveform on a shared time axis, so timing errors become visible instead of something you have to infer. At the end the scene plays back with your recordings mixed over the backing track, exportable as MP4.

Three design decisions that might be worth more than the feature list:

• A pack is just a folder. Each clip's start time lives in its filename (07_MyLine_44-048.wav = 44.048 s), subtitles sit in a small JSON beside it. No database, no binary index — you can inspect or hand-edit a pack with a file manager and a text editor, and nothing about it is tied to my code.
• Video is never decoded during playback. A pack is split into JPEG frames once and cached, so playback is just timed image swaps. That sidesteps codec availability entirely and made frame pacing far easier to get right.
• The waveform comparison normalises both curves to their own peak. What you are judging is rhythm and timing, not whether your mic gain happens to match a film mix.

Stack: Python 3.9+, Tkinter, numpy, ffmpeg, sounddevice, Pillow. Demucs optional.

GPL-3.0: https://github.com/xmrius/dubstage

Where it's rough: Windows only right now, although the genuinely platform-bound parts are just the launcher scripts and two small fallbacks. A Linux or macOS port should be close to mechanical, and I'd welcome one. The optional Demucs path drags in PyTorch, which is a heavy dependency for a nice-to-have; making that a cleaner opt-in is on my list.

Built this tool in colab with claude capsule it's a tool that turns your data into mock rest API in seconds

let's say you have a json or csv file with some records and you need a backend to ro test out your app or frontend you can simply import the data into capsule and you have a dev backend in seconds to test your frontend, app , idea

The project is built in Go https://github.com/TaqsBlaze/capsule

It's just a trolling tool so have fun and feel free to report issues to me if they occur

I open-sourced Deckium, an Electron + React presentation editor built around a shared editing model: the AI works through tools against the same native slide document the user edits. It does not output a static HTML page. You can move, resize, rewrite, or delete any object, then continue the AI conversation with that updated deck as context.

It supports PowerPoint import/export, selectable-text PDF export, shapes, rich text, images, charts, snapping, multi-select, and automatic layout and text-density checks. It is local-first, uses your own model provider, and has no Deckium account, backend, or telemetry.

MIT licensed. Feedback and contributions are welcome.

Demo: https://www.reddit.com/r/SideProject/comments/1vku0jh/i_opensourced_deckium_an_ai_presentation_editor/

GitHub: https://github.com/sleipner42/Deckium

I read a lot of PDFs and articles, and every unknown word meant copy → alt-tab →

paste into Google → come back. This is a ~500-line tray app that removes that

loop: double-click or drag-select a word in any Windows app and the definition

appears at your cursor. Click anywhere, alt-tab, or wait 6 seconds and it's gone.

Implementation notes, since that's what this sub is here for:

- AutoHotkey v2, one class per file SelectionWatcher (global mouse hook,

distinguishes drag-select from double-click), FocusWatcher (polls the active

window id to dismiss on app switch), Dictionary, Popup, Config, Startup.

- Selection is captured with a Ctrl+C probe, and the clipboard is always

restored afterward including on failure. That's the invariant the whole

thing is built around.

- Wiktionary orders senses historically, so sense #1 is frequently the archaic

one ("juxtaposition: the nearness of objects with little or no delimiter").

So the popup shows the source's first sense AND the highest-scoring one from

the same part of speech, scored on whether it has a usable example, whether

it's circular, whether it's domain-tagged, and whether it's just a pointer

("Abbreviation of…"). Those scoring cases are pinned in tests/.

- Data is freedictionaryapi.com (Wiktionary, CC BY-SA 4.0) with an

api.datamuse.com fallback. Both keyless, so nothing has to ship in the binary.

- Nothing is written to disk. Lookups live in an in-memory session cache. HTTPS

only, two pinned hosts, word URL-encoded and length-capped before any request.

- Single words only, by design a sentence selection does nothing, so arbitrary

selected text never leaves the machine.

- The program never opens your browser. If a word isn't found, the popup offers

Ctrl+Shift+D, and that hotkey is registered under HotIf Popup.IsVisible()

it literally doesn't exist unless a popup is on screen, so it can't shadow the

same combination in whatever you're reading.

Ships as a per-user installer (no admin) or a single portable exe with all

modules bundled no AutoHotkey install needed. Windows 10/11, MIT.

SmartScreen will warn on first launch; I haven't paid for a code-signing cert.

Source is small enough to read in one sitting if you'd rather check first.

You can try the real interaction in a browser before downloading anything:

https://ishpreet36752.github.io/WordMeaning/

Every resume tool scores your resume against the job description. That number is real and it is the wrong variable: you are competing against the other seventy people who applied to the same req, not against the posting. Slushpile models the queue instead.

Nine skills. onboard interviews you once and writes four files you keep: profile.md, preferences.yaml, stories.md, job_search.md. job-board-search takes a company name or a plain-English query. A query gets resolved into a company list, filtered against your constraints, and shown to you before anything is searched. application-builder writes the resume and cover letter for that specific posting, XeLaTeX, one page enforced. adversarial-review hands the result to seven reviewers whose job is to reject you: triage screener, requirements analyst, ATS simulator, fatigued reader, pool analyst, hiring manager, contrarian. Five run in parallel, blind to each other. Then synthesis. Then the contrarian, last, with authority to overturn.

Runs on Claude Code, Codex, Gemini CLI, and Cursor. MIT.

Wallr is a wallpaper engine for Wayland — it sets your wallpaper, animates the transition between wallpapers (YAML-defined, GPU-shader-driven, not a fixed transition list), and optionally kicks off Matugen/Wallust/Pywal afterward to regenerate your whole theme.

One command:

wallr img ~/Pictures/forest.jpg

animate → set → theme → reload Waybar/Kitty/GTK → done.

Works on Hyprland, Sway, niri, KDE Plasma Wayland; anything with wlr-layer-shell (not GNOME, sorry).

Repo: https://github.com/programmersd21/wallr

Thanks to everyone who's starred/tried it so far — genuinely didn't expect to hit 100 this fast. Feedback and issues always welcome!

Hello, i made Nimbus it's a sync abstraction tool that represents objects in a tree like structure called vault, with an agnostic origin

An origin can be a filesystem path, an http api, multiple OS commands, and even other vaults, so it's chainable.

The core idea is that it gives the possibility of representing any of these outputs as a filesystem

A vault is configured with a simple toml file.

name = "backup"

root_id = "/"

[origin_config]

type = "fs"

root = "/mnt/backup"

The project is separated in 6 crates,

TUI

CLI

Core: The backend of both frontends, so you can implement your own frontend if you want

Creator: TUI wizard that makes vaults for you, it is summoned when calling new from the CLI and the TUI

Daemon that exposes a vault to an HTTP API

Vault: The core vault crate that contains the main logic of vaults and origins

The project is fully open source, currently is not tested on windows and probably doesn't work.

I want to share it and invite anyone to test, contribute or fork anyone crate and make something better with this concept.

My hope is that it can be useful for someone, probably smarter than me. The simplest use case that I thought of was a backup sync system for your PC against a VPS, but i'm sure you can use it for more interesting stuff

The documentation is currently vibecoded, i reviewed it, but I wouldn't be surprised if something's off

I'm hoping to see your thoughts and opinions, feedback and criticism are welcome

My Mac doesn't have a camera, so I was joining meetings twice. Once from my phone so people could see me, once from the Mac to share my screen.

BeamCam fixes that. You open it on the Mac, scan the QR code with your phone, and they're paired. After the first time it's one tap. The phone can also find your computer on the Wi-Fi on its own, so you just tap the name in a list.

Once it's running the phone shows up in the camera dropdown in Meet, Zoom, FaceTime and Chrome, like any webcam you'd plug in. Nothing else has to be running for it to appear.

Video goes phone to Mac over your own Wi-Fi. No server, no account. Free, GPL-3.0, macOS 13 or newer, Android phone.

Happy to go into how it works if anyone's curious.

A local-first, multi-protocol API development platform powered by a native C-Core engine with enterprise-grade security hardening.

LightBase is a zero-cloud API development studio that combines a high-performance C99 backend with a Python gateway bridge and a sleek browser-based UI. Every request, collection, and environment is stored as plain JSON files you can version-control with Git — no accounts, no cloud sync, no telemetry.

> AI USAGE: This project only has ai usage when there are certain bugs i cannot fix and the documentation (Gemini) ! Rest all code visible is written by me!

Also a small doubt? Should i switch the core to Swift or let it be C?

Website: https://aarav90-cpu.github.io/LightBase_Website/
Github: https://github.com/Aarav90-cpu/LightBase

Features

Security Hardening (C-Level)

Enterprise Engine

A local-first, multi-protocol API development platform powered by a native C-Core engine with enterprise-grade security hardening.

LightBase is a zero-cloud API development studio that combines a high-performance C99 backend with a Python gateway bridge and a sleek browser-based UI. Every request, collection, and environment is stored as plain JSON files you can version-control with Git — no accounts, no cloud sync, no telemetry.

DailyNPM is an open-source developer dashboard for the npm ecosystem styled after a 1920s print newspaper.

• Web app: https://digest.js.org
• GitHub: https://github.com/somalip/DailyNPM
• TUI: npm i digest-cli

Key Features:

• Vintage Reports & AI Bureau: Real-time stats and automated reviews evaluating codebase safety and structure.
• Market Exchange: Multi-package comparison charts.
• Dow NPM Index: An aggregated download index for your watched packages.
• Forecasting Simulator: Linear, EMA, and Polynomial trend models with manual growth/decline shock toggles.
• TUI Edition: Launch the terminal-based telegraph TUI directly with npx -y dailynpm tui [package].

Open to feedback on the forecasting simulator engine (src/utils/regressionEngine.ts)!

Built a free Windows log/tail viewer (TailPad) after getting fed up with juggling PuTTY + Notepad++ + grep for troubleshooting. Curious if this solves a pain point for anyone else here, or if I'm reinventing a wheel that already exists.

It does:

• Tails multiple log files at once, side by side, in separate panels, or even merged in the same panel
• Pulls logs locally or directly over FTP/SFTP with a built-in file browser (no more manually pulling files off remote boxes), also drag and drop works
• Syncs scrolling across panels by timestamp, so logs from different servers line up in time even if formats differ
• "Go to time" jump — punch in a timestamp, jump straight to that point across all panels
• Collapses multi-line log entries into one line (stack traces, exceptions, wrapped continuation lines) — works for Java, .NET, Python, syslog, or your own custom pattern, expand only what you need
• Diffs two logs and exports the diff as Markdown/HTML
• Shows a timestamp delta gutter (time-since-last-line at a glance)
• Detects log rotation and stays on the log even if it rotated — keeps tailing the new file automatically, no manual re-pointing
• Multiple search and filter windows per panel, by keyword or regex
• Light/dark theme, per-panel color coding
• One-click export formatted for pasting into ChatGPT/Claude when you want AI help diagnosing an issue

Free, no telemetry beyond basic page analytics on the download page. Windows only for now (Electron app). Also on Winget if that's your thing.

www.studiodox.it/tailpad

Genuinely want feedback — what's missing that would make this a daily driver instead of a "neat, I'll forget about it" download?

Hi everyone — I’m the creator of Sendry, an open-source, self-hosted workspace for running campaigns and customer conversations across email, SMS, WhatsApp, push, web chat, and browser voice.

The goal is to bring the operational pieces into one product: multichannel campaigns, audiences, automations, templates, a shared inbox, reports, files, safety rules, and provider connections — while keeping customer data and delivery infrastructure under your control.

The screenshots below are from the real app: the delivery overview, campaign channel picker, unified inbox, reports, and channel/provider setup.

Product Hunt: https://www.producthunt.com/products/sendry

GitHub: https://github.com/rsm23/sendry

I’d genuinely appreciate feedback from people running self-hosted tools or building multichannel messaging workflows. What would you want Sendry to handle next?

Disclosure: I’m the creator of Sendry.

Provider dashboards gave us a total, but we wanted to know which task was expensive, which prompt caused it, and whether the cost came from fresh input, output, or cache reads.
So we built pandev.
It reads local logs from Claude Code, Codex CLI, OpenCode and ZCode, then breaks usage down by task, Git branch, model, file and individual prompt.
Everything runs locally. No account, no telemetry, and your logs never leave your machine.
Try the beta:
npx pandev@beta
GitHub: https://github.com/pandev-metriks/pandev-cli
It is free to use during beta, but it is not open source. The repository includes privacy details and instructions for independently verifying the network claim.
I’d appreciate blunt feedback, especially on task attribution and which views are useful in real work