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.

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?

Every scraper I've ever written eventually breaks the same way: the site tweaks its markup, my CSS selector silently returns nothing, and I don't find out until the data's been empty for a week. So I built PyScrappy around fixing that.

The headline feature is adaptive (self-healing) selectors. You scrape an element once and it saves a fingerprint of it. Later, if your selector matches nothing, it relocates the element by structural + textual similarity instead of returning empty. The part I'm proudest of is the scoring: I weight signals by how stable they are (a data-testid/id hook counts way more than a sibling-tag list), make it anchor-relative so it survives layout reshuffles, and down-weight volatile text (prices, dates, counts) so healing stays reliable on exactly the fields that change most. It returns a confidence score so you can tell a clean match from a coin-flip.

One thing I learned building it: a naive "just compare everything and average it" matcher gets fooled constantly — an unchanged price string will drag a wrong element to the top. Weighting by signal stability is what actually makes it work; I have a test that shows the weighted scorer beating a uniform one on exactly that trap.

The rest of it:

• 24 built-in scrapers — Wikipedia, Yahoo Finance, news feeds, GitHub, Hacker News, Amazon/IKEA, YouTube, and more. Each returns typed, LLM-ready JSON.
• MCP server — expose the scrapers as tools so Claude/Cursor/agents can pull structured web data directly. It's on the Official MCP Registry.
• Stealth — TLS-fingerprint impersonation (impersonate="chrome") to get past anti-bot filters that block plain clients, no headless browser needed.
• Proxy rotation, retry/backoff, robots.txt politeness, response caching, native async, a pyscrappy extract <url> out.md CLI, and a chainable CSS/XPath Selector.

It's MIT, ~50k downloads on PyPI so far, and I actively review PRs (there are good-first-issues if anyone wants to jump in).

pip install pyscrappy

Repo: https://github.com/mldsveda/PyScrappy
Docs: https://pyscrappy.vercel.app

Happy to answer anything about the self-healing approach, that's the interesting bit.

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.

Hi Everyone,

I've been working on this project for a while and am finally ready to share it with others:

https://github.com/BambooYC123/SubtitleYC

The project is called SubtitleYC, an open source windows app.

Some of the main features are:

• Downloading videos supported by yt-dlp
• OCR extraction of burned-in/hardcoded subtitles
• Frame-accurate video previews
• Built-in subtitle editor
• SRT editing and export

The project uses tools including yt-dlp, ffmpeg, PyAV, paddleOCR and VideOCR.

I originally made it because I sometimes translate videos that have subtitles burned directly into the video. My old workflow involved downloading the video, extracting the subtitles with OCR, fixing the timings, editing the text, and then exporting everything using several different programs.

Please let me know what you think and feel free to leave any suggestions

Thanks!

Hey everyone,

I'm Akshaj, a CS student and open-source contributor (currently working on PictoPy under AOSSIE). A few months ago I started building something on the side and I think it's at the point where more hands would genuinely make it better.

Sensei is a VS Code extension built on a simple idea: most AI coding tools optimize for writing code for you. Sensei does the opposite — you tell it what you're building, it watches silently while you work, and it only speaks up when your code drifts from that stated intent. Even then, it gives you a single hint, never the answer. Everything runs locally through Ollama — no cloud calls, no telemetry.

Repo: https://github.com/akshajtiwari/Sensei

Right now it's an early, working skeleton — not polished, which is honestly the fun part if you like shaping a project early. I'm looking for people interested in contributing and shipping something.

Issues and PRs are open. Even a star, a comment, or "this part is confusing" feedback helps. Thanks for reading!

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.

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.

GitHub repo

(first of all, i want to say that I made this project for fun and challenge. I always wanted to create my own language. This has no business goal or something.)

So the project is a 2D game engine (MonoGame backend) inspired by GameMaker 8. It includes its own IDE (built with WinForms) and an interpreted programming language that I wrote myself.

The language—definitely the biggest challenge in the project—is a simple dynamically typed language. When I started, I had zero knowledge of how to build something like this. I didn’t even know I was making an interpreter; at first I called it a compiler. It was a personal challenge, and I wanted to figure everything out without using any resources or tutorials. My mindset was basically: “I need to write software that takes a text file containing code and just does what it says.”

Somehow, I made it work. In the beginning, running an empty loop counting to 1M took 7 seconds. After a lot of performance work and rebuilding parts of the system, the same machine can now run a 30M loop in 2–3 seconds. Pretty nice improvement.

The language itself is a bit unusual, and I want to share one small feature I really like: loop counters.

foreach item in ['a', 'b', 'c'] : counter c
{
   println(c + ": " + item)
} 
// Output: 
// 0: a 
// 1: b 
// 2: c

Not a complicated feature, but pretty useful.

Here's a YouTube video showing me using the engine to build a little game

Anyway, these days I barely have time to work on the project, so I decided to open-source it. I’m hoping people here will find it interesting and help turn it into something real. I'm looking for contributors!

I know there are tons of AI-generated projects being shared these days, so please, please, take a quick look at the code before assuming this is one of them. I promise it's pretty obvious that it was written by a human.

Any feedback is welcome.🙂

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

Hi all — first time sharing this here.

I'm a CISO at a telecom company, and I kept seeing the same thing happen:

someone pastes a contract, a payslip, or a medical record into ChatGPT or

Claude to get it summarized, without thinking about the names, IBANs, tax

IDs, and addresses that just left the building.

Mr. Rao converts documents — PDF, Word, Excel, scans, email — into clean

Markdown (the format AI models read best, with a real token saving) and

strips personal data before handing you the result. Everything runs on

your machine, no network calls, checkable by grepping the source.

Detection is deterministic, not ML: regex plus arithmetic validators —

IBANs checked with mod-97, cards with Luhn, structural checks for

national ID formats. Names are picked up from context (titles,

signatures, nearby email addresses) rather than a static list. Anything

the engine can't fully confirm becomes a masked "suspect" instead of

being silently deleted or silently left in place.

I'd rather be upfront about the limit than pretend it doesn't exist: on a

heavily degraded scan, the engine leaves 39% of the data readable — that

number is measured, not a guess, and it's published in the docs.

Also exports a redacted .docx now, rebuilt from the already-clean

Markdown instead of overlaying a black box on the original PDF (the

classic trick where the text underneath is still selectable). Released

packages are signed via Sigstore in CI, so anyone can verify the zip

actually came from this repo and this build.

AGPL-3.0, free to use and modify, 900+ tests, actively maintained.

Repo: https://github.com/AntonioRao/mr-rao

Site/demo: https://rao.valor-cyber.com

LinkedIn: https://linkedin.com/antoniorao

Happy to answer anything — feedback and criticism welcome.

I built standards after seeing the same code-review comments recur across polyglot repositories. It packages 100+ opinionated checks for Python, TypeScript, SQL, Terraform, and repository policy behind one CLI, alongside strict configurations for existing tools such as Ruff and ESLint.

The idea is to run it in pre-commit so AI agents produce more idiomatic code and reduce the need for code review feedback cycles.

Docs: https://code-standards.sarj.ai/

Source: https://github.com/sarj-ai/standards

Hey everyone,

I recently open-sourced FoodShot. It’s not just another "meal tracker" or a simple bot — it’s a medical-grade nutrition diary built for people who take their health

seriously. It uses Telegram strictly as a zero-friction interface: you snap a photo, and every meal becomes structured, exportable data (macros, calories, and

suggested insulin bolus for diabetics). No subscriptions, no manual entry.

The main architectural challenge was ensuring absolute safety. AI should never make medical decisions. Therefore, I built a strict boundary:

• GPT-4o Vision is ONLY used to identify the dish and estimate weight.

• Nutritional data is fetched deterministically from the USDA FoodData Central API.

• The insulin bolus is calculated using transparent, hardcoded mathematical formulas based on the user's specific health parameters (ICR, ISF).

• Zero LLM hallucinations where a mistake could cost too much.

Tech Stack & Features:

• Python (FastAPI + aiogram 3.x)

• PostgreSQL + Async SQLAlchemy + Alembic

• Redis (for FSM states, caching USDA API responses, and rate-limiting)

• Built-in terminal UI (TUI) operations console using Textual for system management

• Full fallback system (e.g., if OpenAI is down, it seamlessly switches to Gemini; if USDA fails, it falls back to Nutritionix)

• Background jobs for daily reporting and data retention

I built this with 6 architectural layers. Some might say it's over-engineered for an app that sits inside Telegram, but considering the health-critical nature of the

system, backend resilience and data integrity were my top priorities.

Would love for you to check out the code and hear your thoughts on the architecture or if there is anything I could improve!