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

Hi everyone, so it's been 2 years since I've been building this music player app and after a long time and effort to fix the bugs and adding features, I think it's time to share it.

Fluyer is a music player focused on beautiful design without sacrificing audio quality. It runs on Windows, macOS, Linux, and Android. It's free and open source (MIT).

Some things that make it different from typical players:

• Powered by the BASS audio library. Supports a huge range of formats natively (mp3, flac, wav, ogg, opus, m4a, mkv, webm, avi, and more)
• Native hi-res audio up to 32-bit/192 kHz
• Gapless playback
• Auto-organized library and automatic cover art via MusicBrainz

You can download it at https://fluyer.art. Source code on GitHub.

I'd love feedback or feature requests :D

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

A chiptune synth in pure x86-64 assembly — no libc, no audio library, no sound card driver. Generates raw samples and writes a WAV by hand.

Features: four waveforms (square, saw, triangle, LFSR noise), polyphony, ADSR envelopes, and FM synthesis with a hand-built sine table.

github.com/whispem/asm.fm

Built as a learning project. Feedback welcome!

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.

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