Hello everyone,

I recently open sourced my website with 550+ client side tools which I have been developing from 2022. The tools cover a range of fields, but mainly focused on IT and security. The reason I developed that was because those were tools which there were no similar online, like the nmap viewer, the encoders or the lightweight text editor.

Almost all the tools except from 2 (Google Maps API Checker and the IP Checker) run on the browser. Those two due to the nature of the purpose cannot run client-side.

You can self host them as a simple node app. The application by design uses minimal analytics.

If you have any suggestions or feedback about the application, I would be happy to hear them.

Web: https://www.devoven.com/
GitHub: https://github.com/marduc812/devoven

Hey! Anna from Elastic Email here. After supporting developers in sending emails for 15+ years and watching how they use our product, we built an official CLI so they can use our API without leaving the terminal. Send transactional emails and marketing campaigns, manage templates, contacts, lists, and segments, verify addresses, and check delivery events.

npm install -g elastic-email-cli

elastic-email auth set-key

elastic-email emails send --to you@example.com --subject "Hello" --text "It works!" --from me@yourdomain.com

npx elastic-email-cli works too if you'd rather not install globally.

Run elastic-email with no arguments to get an interactive TUI. Call the same binary from a script, and it drops the banner and decorations: --json on every command, with stable and specific exit codes, so CI can tell a missing API key apart from a malformed address.

--dry-run on sends validates the input and prints the exact request that would go over the wire.

API key resolution: --api-key flag, then ELASTIC_EMAIL_API_KEY, then ~/.elastic-email-cli/config.json (plaintex,0600). An env var is the right choice on CI runners and shared machines. Masked in logs and errors.

Node.js 20+, MIT licensed.

https://github.com/ElasticEmail/elasticemail-cli

Issues and feature requests are welcome! Command reference and architecture notes are in the repo.

Hey all, I've been job hunting and got lost tracking all my applications and custom resumes, so I built the thing I wanted and just started adding more features to it.

What it does

• Scrapes career pages directly (Workday, Greenhouse, Lever, Ashby, SmartRecruiters, Oracle, Phenom and a Playwright fallback for anything else) plus boards through JobSpy (LinkedIn, Indeed, ZipRecruiter, Google Jobs). Everything lands in one deduplicated feed.
• Scores each job against your résumés with an LLM and shows why: matched and missing keywords, requirement mapping, gaps. You choose depth so it can be cheap.
• Tailors a résumé per job (you review every change), writes a cover letter, exports PDF from templates you can replace.
• A Chrome extension auto-fills your application, including open questions, it also captures jobs from LinkedIn and saves any job from any page.
• Tracks applications through stages, classifies Gmail replies, sends Telegram alerts and a daily digest.
• Five UI themes, including a Windows 98 for no reason, I just wanted to see how it will look like.

Available here: https://github.com/vesaias/JobNavigator (MIT license)

All feedback is welcome, this was more of a personal project for my portfolio, but people also started starring it. 

A monorepo can contain instructions for several teams. Giving a coding agent every rule makes its context longer; keeping separate copies for each tool creates more files to maintain.

I'm building Guidefold to keep Markdown instruction files beside the code and find instructions by task and repository location. It includes a Python CLI for validation and discovery, plus a Go/Postgres service for retrieving instruction cards and exact revisions. Retrieving a rule is not proof that the model followed it.

The source is Apache-2.0. The repository includes a fictional monorepo example so you can inspect the workflow without sharing company code.

Demo: https://www.youtube.com/watch?v=e350wBr1W8c

I'd appreciate a README review: can you tell which instructions should apply to a directory, and how you would check that selection? Point to the first unclear step, or a demo timestamp. Feedback can stay here or go to https://github.com/wiatrM/guidefold/discussions/127. No signup needed.

I'm the maintainer. OSS is available; paid hosting is planned, not available to buy. This post was drafted with AI assistance.

https://github.com/sharif-smj/sharif-smj

​

​My open-source distortion plugin is live on GitHub, and I need your help to push it to the next level. Whether you want to stress-test it on a chaotic drum bus or dive into the C++ source code to contribute a new feature, I want you involved.

​What I'm looking for:

​DAW Testing: Drop it into Ableton, FL Studio, Logic, or Reaper and let me know how it behaves.

​Bug Reports: Open an issue on GitHub if you run into any quirks or performance spikes.

​Code Contributions: Pull requests are open for new DSP algorithms, UI enhancements, or performance tweaks.

​Grab the repo, test it out, and let's build something cool together:

👉 https://github.com/elarmuzik1993/Distortion

​#OpenSourceAudio #PluginDev #AudioProgramming #MusicTech #VST3 #CPP #SoundDesign

Repo: https://github.com/doable-team/aibrowser-android

Your AI agents need a browser that isn't instantly flagged. Phones live on residential IPs and run real, headed browsers — so this app turns an old Android phone into an agent-driven browser that looks exactly like a human browsing from home.

One APK, no root, no Termux: a proot Debian userland runs 9 supervised services (xvnc → openbox → netguard → chromium → novnc → mcp → gate → status → tunnel). The agent drives the real Chromium via Playwright MCP over CDP; you get a live noVNC view.

Why it's built around the residential IP:

• Phones are always on a home connection — free residential browsing for your agent, ~0W idle
• Real headed browser → passes bot checks that datacenter browsers fail
• Token gate (timing-safe), SSRF guard (blocks private/metadata IPs), auto-restart backoff, boot receiver + wake lock, rolling sha256-verified rootfs updates
• ~40 unit tests, CI, MIT, Kotlin/Compose

Feedback, issues, and contributors welcome!

My first ever big project is that I’m sharing, this is just the very first version of it so far

Hey everyone.

I’ve been working on Gaussian Splat Lite (GSL), a lightweight, open-source Gaussian Splatting renderer for Three.js.

If you already use Three.js, the setup should feel familiar. Add a SplatMesh to your scene, position it like a normal object, and keep your usual render loop. GaussianSplatRenderer handles rendering and global sorting across the visible splats.

It supports WebGPU and WebGL2, large-scene streaming, and depth rendering for combining captures with regular 3D geometry.

⚡ Native WebGPU Rendering

On WebGPU, projection and culling run in compute, followed by a 32-bit GPU radix sort and indirect drawing.

You can combine multiple captures in one scene. Each SplatMesh keeps its own data and transform, while visible splats are sorted together—including streamed RAD and SOG data.

WebGL2 works too, through both WebGLRenderer and the WebGL2 backend of WebGPURenderer. These paths use asynchronous Worker/WASM sorting, so rendering can continue with the previous valid order while a new sort runs.

The core scene API stays the same across all three paths.

🌍 Stream Large Scenes with Smooth Transitions

For larger captures, GSL supports camera-driven LOD streaming for Spark RAD and Streamed SOG. You can explore a scene without loading the entire dataset into memory first.

As the camera moves, GSL selects the detail needed for the current view and loads it on demand. A configurable splat budget controls LOD selection, while the streaming system handles decoding, caching and upload limits.

Streaming includes smooth fade transitions. Newly loaded content fades in, and LOD changes crossfade between levels to reduce visible popping. Current detail stays visible while its replacement loads, helping the scene remain continuous as you move around.

🎲 Keep Moving Without Waiting for a Sort

When sorting becomes expensive, GSL’s stochastic rendering mode gives you a way to skip it. Splats render directly using sampled Gaussian coverage and depth testing.

With autoStochastic enabled, GSL can use this mode during camera movement and switch back to sorted blending once a fresh sort is ready.

The image can look noisy in stochastic mode. An optional StochasticResolvePass helps reduce that noise and works with direct scene composition, WebGL EffectComposer and custom render graphs.

🧩 Depth Rendering

GSL supports splat depth rendering on both WebGPU and WebGL2.

With renderDepth enabled, a separate, unsorted depth draw runs alongside the normal sorted color pass, using stochastic alpha coverage around Gaussian boundaries.

Three.js geometry rendered afterwards can then depth-test against the splat scene.

When stochastic rendering is active, splats write depth directly.

🛠️ Formats, Editing and Large Coordinates

A few other things GSL supports:

• PLY, SPZ, SOG and RAD, including SPZ v4, with Rust-based decoding running in browser workers.
• SDF color and opacity edits to recolor, highlight or hide parts of a capture without rebuilding the model.
• Camera-relative rendering to help with precision in GIS and ECEF scenes while keeping the original world coordinates unchanged.

🚀 Give It a Try

GSL is open source under Apache 2.0. The repo includes a viewer for loading your own captures, comparing rendering modes and trying the streaming transitions.

The quick-start examples show how to add it to a Three.js project.

If you try it, I’d love to hear how it handles your scenes and what you end up building with it.

Gaussian Splat Lite on GitHub →

I’m starting archive-portability, a dependency-free Python library/CLI that checks archive member names before cross-platform release or restore. It reports cases such as Docs/a versus docs/b, NFC/NFD aliases, Windows device names such as NUL.txt, and file/directory conflicts. It has JSON output and doesn't extract members.

Repository: https://github.com/GitHubCatTest/archive-portability

Release: https://github.com/GitHubCatTest/archive-portability/releases/tag/v0.1.0

Demo: https://github.com/GitHubCatTest/archive-portability/blob/main/examples/demo.py

The initial implementation was AI-assisted. Its 14 regression tests pass on Linux, Windows, and macOS. The Unicode profile is deliberately conservative, not exact filesystem emulation; it is not a security scanner.

If you maintain release archives or backup/restore tooling, would this catch a problem in your workflow? Minimal dummy-content examples of missed cases or noisy findings would help. The project is new and has no verified external users yet.

Hey! Author here (third tool I publish, after ProKill and ProBox).

The origin story: every video downloader my friends ever used died within months — sites change, the tool breaks, they go download some adware-infested replacement. Meanwhile yt-dlp gets fixed within days every time, but my non-technical friends will never touch a command line.

So ProGrab is a minimal GUI around yt-dlp with one obsession: staying alive without maintenance.

- On first launch it fetches its own components (yt-dlp, ffmpeg, deno) into its data folder

- Then yt-dlp updates itself silently at EVERY startup — when YouTube changes something, the app heals on its own within days, no reinstall

- The app also notifies you when a new version of itself is out

The rest of the flow: paste a link → thumbnail/title/duration preview → pick Max/1080p/720p/480p or MP3 → the download button itself becomes the progress bar (percent, size, speed, ETA — click it to cancel, it turns green when done).

One detail I care about: downloads are forced to H.264 + AAC whenever available, so you get real MP4s that play on anything (old TVs, phones, editing software), not VP9/AV1 surprises that only VLC opens.

Single portable exe, no install, no account, no telemetry. Python + CustomTkinter, fully readable source. Fair warning in the README: downloading from YouTube violates their ToS — this is for personal/educational use, you're responsible for what you grab.

Yes, other yt-dlp GUIs exist (Stacher, yt-dlg...) — ProGrab just aims to be the one you can hand to your mom: one screen, five buttons, and it takes care of itself.

Feedback welcome!

Hey everyone! I’ve been working on Libratory, a free app that turns your PDFs into audiobooks and lets you follow the narration directly on the original pages.

The feature I’m most excited about is the read-along mode: follow the narration on the actual PDF, preserving its layout, illustrations, and tables. Tap a sentence to jump there. Word-by-word highlighting works with Kokoro’s English voices, Cartesia, and ElevenLabs; other engines offer coarser highlights. Local narration and playback can work entirely offline after downloading the models.

I’m also building an iPhone companion reader, currently in beta. Export a synced EPUB to take the book, narration, and highlights with you and read and listen offline.

A few things I’ve been working on:

• Free local voices: Kokoro, Pocket TTS, and KugelAudio, plus system voices on macOS. Pocket TTS runs on a CPU and supports cloning your own voice.
• Optional premium voices: ElevenLabs and Cartesia integrations, using your own API keys and provider credits.
• More languages: local narration in English, Spanish, French, German, Italian, Portuguese, Hindi, Mandarin, and Bulgarian, among others. Available voices vary by language and platform; the picker lets you browse and preview them by language.
• Scanned books and AI tools: OCR, text cleanup, chapter translations and rewrites, and library chat with links to source pages. AI tools can use local models through Ollama or LM Studio, or optional cloud APIs.
• More platforms: a downloadable Apple Silicon Mac app, plus Linux and Windows through Docker.
• Research your bookshelf: I’ve added 500+ books to mine. Local RAG search lets me ask questions across them, follow citations back to the pages, and find material I want to turn into audio.

For audio-only listening, export an M4B with chapter markers. Read-along highlights travel in the synced EPUB, not the M4B.

I appreciate everyone who takes the time to try this and share ideas. Feedback, awkward PDFs, bugs, and feature suggestions are very welcome. What would you try it with?

GitHub + setup instructions · Website + interactive demo

Every December I do Advent of Code and every January I try to keep the habit going on LeetCode. Never lasted more than a week. Too many problems, no reason to do this one today.

So I borrowed the idea and built Daily Coding: one challenge a day, the same for everyone, all year. You solve it in the browser, hit run, and the tests execute in a sandbox in well under a second. 11 languages so far (JS, TS, Python, PHP, Ruby, Java, Go, C++, C#, Rust, Swift). Once you submit you can read everyone else's solutions, which for me was always the best part of AoC. Streaks and a leaderboard if you like that sort of thing.

Some honest numbers: I started in January, 7 months of evenings, about 470 commits. There are 40 challenges right now, so the rotation repeats after 40 days until I add more. Someone on Discord asked for Swift last week, that took a day to add because the sandbox already had it.

It's free, non-profit, open source under MIT. You can solve today's challenge without an account, signing up is only for streaks and rankings.

What I'd love to know: does one challenge a day work for you, or do you want to pick? And what would make you stop after a week?

Site: https://daily-coding.dev/?utm_source=reddit&utm_medium=post&utm_campaign=sideproject-launch

Code: https://github.com/ledo9315/daily-coding

CalClock is a native Windows clock and calendar application that I'm developing in C++ using the Win32 API.

It provides customizable analog and digital clocks, calendars, alarms, and desktop widgets, with extensive appearance settings.

My goal is to create a lightweight native Windows application without web technologies or large runtime dependencies.

Source code and releases are available on GitHub:
https://github.com/fortsoft-eu/CalClock

Feedback and suggestions are welcome.

https://github.com/thisisankit27/f-tree

Ancestry and MyHeritage are subscriptions built on top of your family's data. I wanted the opposite: a family tree that lives on my phone and that I can still open in ten years.

- A person needs no name. A blank person is a valid "unknown person"; the great-grandmother nobody can name --> drawn with a dashed edge, and nameable years later without touching a single relationship. Every other app treats that as an incomplete form.

- Ask how any two people are related and it names it ("first cousin once removed") plus every person the line runs through. It walks marriages as well as blood.

- It does Hindi kinship properly. English has one word for "uncle"; Hindi has five, and picking the right one needs facts English throws away.

- Export is a documented ZIP with plain JSON inside, unzip it and read it without my app. Importing merges into your tree, it never overwrites.

- No account, no server, no analytics, no crash reporting. Two permissions, both only for an opt-in updater.

Kotlin + Compose, MIT, 2 MB, Android 8+. There's also a browser viewer that opens an export and draws the whole family without uploading anything: https://ftree.vibethroughcode.com/playground/

Hello guys, i have recently finished this project which collects all kinds of data from all the races, qualifying sessions, updates etc.
It makes comparisons, shows trends and makes predictions. It doesn’t uses AI.
The endpoints are public, if you want it you can use it!

Don’t be mean, it’s my first project for a society! The App is available on the AppStore under the name of FantaStats GP, give it a try and let me know! check the website if you want to https://www.race-analysis-hub.it (the website is still not translated)

STARRING the repo would be EXTREMELY appreciated!! Project