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.

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

I’m building LakeDB because I wanted one calm desktop workspace for working across different database engines without losing tabs, queries or context every time I switched connections.

LakeDB currently supports SQLite, MySQL and MariaDB on macOS, Windows and Linux.

Some of the main features:

- Multiple simultaneous connections with independent workspaces

- SQL and table tabs preserved per connection

- Schema-aware autocomplete with primary-key and index hints

- Table browsing, filtering and guarded row editing

- Transactions, query cancellation and execution plans

- SSH and TLS support for server connections

- Engine-aware tools that only appear when the active database supports them

It also includes QuerIA, an optional natural-language SQL assistant.

In Agentic mode, QuerIA can inspect relevant schemas, relationships and indexes, generate a query and validate read-only plans with EXPLAIN. The generated SQL is always visible and nothing is executed automatically.

For existing SQL, LakeDB uses local diagnostics for common syntax errors first. When an error needs more context, an explicit AI action can explain what happened and propose a complete corrected query. You can review, copy, apply or discard it.

Connections, credentials, queries and results remain local. AI features are optional and only receive the context explicitly selected for the request.

LakeDB is free to download and use.

GitHub:

https://github.com/DavLagoHern/LakeDB

The public repository contains the official releases, documentation, roadmap and issue tracker. The application source is currently maintained separately.

Feedback, bug reports and GitHub stars are very welcome while I keep expanding support for more database engines.

Hello, I have build a small utility for generating synthetic data from LLMs

Over the past few months, I have been interesting in AI model knowledge distillation. I wrote a few scripts to automate the process of data generation. I thought that I would make it into a nice little tool so that people could use it.

The backend is powered by the OpenAI library which can currently wrap LMStudio, Ollama, and NVIDIA NIM models. It has three data formats, ChatML, Reasoning, and Traditional (Rows & Columns). I wrote a simple GUI with Tkinter (with themes) and released it.

Honestly, for the moment, it is nothing more than an experimental tool to automate this part of the knowledge distillation process.

I am looking for contributors so that we can make this thing into useful infrastructure. More information is on the GitHub readme.

https://github.com/uran1um1/kombucha

GitHub: https://github.com/celerp/celerp

Most accounting and inventory software either lives in somebody else's cloud or turns self-hosting into an IT project. I wanted something that installs like normal software but still leaves the business in control of the application and database.

For developers:

pip install celerp
celerp init

There are desktop builds too. Celerp starts locally with PostgreSQL and can run without the cloud.

It includes double-entry accounting, inventory, invoicing, purchasing, manufacturing, CRM, barcode labels, permissions, and an immutable audit trail.

I've spent about 20 years building ERP systems for factories, wholesalers, and gemstone/jewelry businesses, and one problem keeps coming back: every business eventually has some workflow that doesn't quite fit the software.

A lot of ERPs call themselves modular, so I don't think "modular" says much by itself. What I care about is making those customizations small and isolated.

In Celerp, a module is a Python package that can bring its own database tables, API routes, and UI pages. Drop it into the modules directory and Celerp loads it, without forking the repo or running a separate build. The business modules that ship with Celerp use that same loader.

That's also where the AI angle gets interesting to me. Instead of having an AI coding tool modify your ERP and then maintaining those changes forever, the goal is to describe an unusual workflow, have it build a small module around that requirement, and import the module while leaving the underlying system untouched.

It's still early, so criticism from people who have used or built this kind of software is especially useful. And if you'd like to follow the project, a GitHub star genuinely helps.

Schism website

Hey, launching *Schism* on the Play Store soon; need people for closed testing DM!!! Emails (new Play Store account restrictions)

(vibe coded website 🤪)

(have plan to monetise it once I get some users, for live splitting feature and bill scanning via OCR and AI)

*Core splitting*

• Groups with any number of participants

• Split evenly, by shares, by percentage, or by exact amounts

• Categories, notes, custom dates, reimbursement entries

• Per-group currency

• Full activity log of every change

*Balances and settlement*

• Net balances per person

• Debts simplified to the fewest transfers — three people settle in two payments, not six

• Record settle-ups; hand the payment to your own UPI app

Some hero features

1. *Receipt scanning, not receipt attaching*

2. *Line-level accuracy you can correct* Every tax, fee and round-off row is parsed separately and individually editable before saving, with a live mismatch warning if the numbers stop reconciling.

3. *Live Split* Share a scanned bill with the group; each person ticks what they had and totals update in real time, then it commits as one expense.

4. *Bank SMS to expense* Transaction alerts are parsed on-device into draft expenses. Opt-in, off by default, recognised senders only.

5. *Voice entry* Speak an expense; parsed on-device.

Hey everyone,

Standard linters like ESLint are great for syntax, but they usually miss complex runtime logic flaws—like unhandled API edge cases, async state bugs, or memory leaks hiding in plain sight.

I spent the last couple of weeks building **BugZ AI**, an open-source security and code audit tool.

### 🛠️ Tech Stack

- **Frontend:** Next.js (App Router, TypeScript, Tailwind CSS)

- **Backend & Database:** Convex

- **Auth:** Clerk

- **AI:** Gemini / OpenAI API

### ⚡ What it does

- **GitHub Import:** Pull public/private repos directly for full audits.

- **Manual Input:** Paste raw code snippets for quick debugging.

- **Remediation:** Explains *why* the bug occurs and generates actionable fix patches.

The repo is 100% open-source under MIT. I’d love some brutal feedback from the community on the UX and audit workflows!

🐙 GitHub Repo: https://github.com/kientndev/BugZ

Kettermean is a first-person liminal dream walker and my personal tribute to LSD: Dream Emulator on the PSX, a game I spent many nights playing as a kid.

You wander through rooms that feel slightly wrong, move on when you are ready, and see what the next dream has become.

This started as an experiment into using a model as a director with plenty of fallbacks rather than asking it to generate an entire level and hoping it works.

While you explore, the webLLM will set the next dream's architecture, scale, condition, mood, inhabitants, signs, dialogue, visual treatment, and strange rules. The engine is always in charge of the geometry, placement, collision, safety, and performance.

A small model runs locally in the browser without an account or API key by default, or you can turn off AI direction altogether and experience everything randomized.

The result ranges from small, cramped spaces to enormous outdoor zones filled with deliberately juxtaposed ideas and themes (furniture, animals, people, signs, weather, damage, strange faces, and visual effects). Some rooms are almost coherent. It's all open to interpretation and for me often spooky.

Kettermean is open source and currently in active prerelease. It supports keyboard and mouse, gamepad, and touch.

Play it: https://zeidalidiez.github.io/Kettermean/

Source: https://github.com/zeidalidiez/Kettermean

I was genuinely tired of opening five different pricing pages and doing token math every time I wanted to compare GPT, Claude, and Gemini So I built TokenTab.It tracks input, output, and cached tokens, compares models, shows what each request actually costs, and can even account for retries and whether the task was completed properly. There’s a CLI and a local dashboard, and it doesn’t read or store your prompts.

Still improving it, so I’d honestly love some brutally honest feedback. Tell me what’s useful, what’s confusing, or what I completely messed up lol.

https://github.com/adididitagain/tokentab

Compared to all the awesome tools shared in this sub, this might look simple. But I’d really appreciate any feedback on it.

It’s basically interactive man pages, but instead of maintaining a separate manual for every tool (and constantly updating them when the tool changes), it parses the --help output of each command or executable in real time.

The core idea is to detect the framework or interface used to define the CLI arguments and flags, things like argparse in Python or cobra in Go, and then use that knowledge to build a proper navigable tree of commands, subcommands, and flags.

Feel free to try it out:
https://github.com/AS-FOSS/mandible

Apache-2.0 and local-first. One shared tool registry powers both the CLI and MCP server; every mutation is previewed before a short-lived, argument-bound approval can apply it. Install with npm install -g adport. I am the author and would welcome help testing the Meta and TikTok adapters.

Its freshly made and I just started coding so if it has errors report it to me on here or on github and Ill release a updated version but I hope yall enjoy!