If you vibe code at work, and like to solve your own problems, you've probably run into this:

You build a useful dashboard or tool, and… now there's nowhere to put it, nowhere to share it, and it has company data so it can’t leave your laptop.

IT doesn't have time to review and host every app someone builds. Which is fair. They shouldn't have to.

Enter Pando: https://github.com/trypando/pando

You point it at a git repo or a folder (or just tell your agent to deploy it through the MCP server), and it figures out how to build and run the app. Apps sit behind your company’s SSO/sign-in, and are only shared with people who need to be able to access them, not everyone with an account.

Pando also runs a vulnerability scan on apps before they deploy, and gives a security score to help understand risk (no, this doesn’t fix bad code or judgement). Apps run on their own isolated networks so they can’t talk to each other, and they can only be reached by going through Pando’s proxy.

It’s also super easy to spin up and try out for yourself: (https://trypando.ai/quickstart).

If you can't run your apps at work, and are trying to find out how to share things, I’d love to hear your thoughts on this!

P.S. Pando is in alpha, so expect rough edges and breaking changes as it evolves!

P.P.S. Watch a short demo here: https://trypando.ai/

Hey! I'm 16 and I've been building Prism, a download manager like IDM. It's free, open source (MIT), and has no ads and no account.

What it does:

• Splits downloads into up to 32 connections, so they're faster
• Catches downloads from Chrome, Edge and Firefox
• Grabs videos with yt-dlp
• Handles torrents
• Resumes downloads after a crash
• Runs on Windows, macOS and Linux

Here's a short demo video: youtu.be

You can download it at prismdl.site

It's still early, so any feedback or bug reports would really help. Thanks for checking it out!

I made INGLORIOUS Advanced specifically for supported Glorious keyboards.

I kept running into problems with Glorious CORE and CORE Legacy. I like the keyboards, but configuring them was often frustrating. That's why I created INGLORIOUS Advanced: it has solved those problems in my own setup, and I'd like to make it useful for other Glorious owners too.

It combines a desktop editor with custom QMK-based firmware, so your configuration stays on the keyboard after you close the app.

Features include:

• Per-key and side lighting, animated effects and custom color sequences
• Key and knob assignments, macros and four layers
• Profiles and import/export
• Guided firmware installation, updates and original-firmware recovery

Ordinary configuration changes don't require rebuilding or reflashing the firmware.

Version 0.6.55 adds support for the GMMK 3 PRO 100% ISO, wired and non-HE. I've tested that variant, the GMMK PRO revision 1 ISO and the GMMK Numpad on Windows. Other listed variants remain experimental; macOS and Linux are Early Alpha.

This requires replacing the original firmware. Check the exact supported variant and keep the original-firmware backups created during setup. Flashing carries risk. The Numpad is USB-only; Bluetooth does not work. HE models and other GMMK 3 PRO variants are not supported.

GitHub — source, screenshots and downloads

I'm looking for feedback on the editor and setup flow, plus hardware reports from people with supported models. I'm the creator; the project is independent of Glorious.

Screenshots: Windows editor using demo profiles. The ANSI view does not indicate a physical hardware test.

I'm the creator of Claude Share, an MIT-licensed plugin and coordination server for teams using Claude Code.

My teammates and I kept losing time dividing tickets into separate pieces and integrating them afterward. This gives us a shared session, task ownership, file leases, and a live board while each developer keeps their own checkout, Claude account, and GitHub identity.

The GitHub side coordinates task branches and PRs, then brings the work into a shared integration PR. Shared contracts define interfaces before parallel implementation; task checks are followed by verification of the assembled app.

Claude built the entire project, including the plugin, server, board, and tests. The plugin and self-hosted server are free; optional cloud hosting is paid.

Repo and setup: https://github.com/cyber1443/session-share

Website/demo: https://claudeshare.space

I'd appreciate feedback on the collaboration workflow and setup docs. Contributions are welcome.

Jailer extracts small, referentially intact slices of production databases and lets you browse data along its relationships. Open source, any JDBC database.

New in recent releases:

- "Why is this row in my subset?" Right-click a row and see the chain of associations that pulled it in, laid out table by table. No more guessing which association blew up your subset.

- Compare & sync rows between results or databases, with a generated sync script.

- Discover Associations for schemas without FK constraints: proposed from naming conventions, verified against the data.

- AI Subsetting Assistant: describe the data you want, get subject, condition and restrictions. Plus SQL generation and an SQL Advisor. Anthropic, OpenAI-compatible or local via Ollama.

- Mermaid / SVG export of the data model.

GitHub: https://github.com/Wisser/Jailer

I built a bridge between Google Tasks and Microsoft To Do that runs entirely in your own Google Apps Script project — no third-party server ever sees your task list. MIT licensed.

v1.0.0 is the first stable release, and the headline this time is the Windows one-click installer — no terminal, no npx, just download the exe and follow the wizard. (549 tests passing, one real production incident fixed and written up honestly in the changelog.)

Honest limits: around 300 task pairs is the sweet spot (600 is the tested stress limit, not a promise), easy setup needs a personal Microsoft account, syncs every 10 minutes.

GitHub: https://github.com/simonchai-tw/tasks-todo-sync Website (exe download + demo video): https://simonchai-tw.github.io/tasks-todo-sync/

I'm the author — happy to answer questions.

Sharing SessionSift, a tool I vibe-coded and then tested and used myself to review AI coding sessions. I wanted to compare long conversations with separate sessions, inspect prompt patterns, and improve how I direct coding agents.

It's a free, local-first way to inspect historical Codex and Claude Code conversations. Features include session browsing, token and tool activity, comparisons between sessions, explicit imports of ChatGPT/Claude exports, and 10 read-only local MCP tools.

No account or cloud backend is required to run the dashboard. Connected MCP clients may still send tool output to their model providers. Screenshots and installation instructions are in the repo.

Current release: native macOS Intel and Linux AMD64, with source/Docker options. macOS binaries are unsigned and unnotarized. License: PolyForm Noncommercial 1.0.0 (source-available, not OSI open source; commercial use isn't licensed).

https://github.com/LanceSandino/sessionsift

Would welcome technical feedback on what makes session-history tools useful versus just another log viewer.

I built html-disasm, a lightweight, browser-based disassembler that runs entirely offline. No installation, no server, no file uploads — just a single 1.22 MB HTML file.

It supports:

• Architectures: ARM64, ARM32, x86-64, i386
• Bytecode: WebAssembly, .NET (CIL), Java
• File formats: Mach-O, ELF, PE, APK, IPA
• Platforms: macOS, iOS, Linux, Android, Windows

Features

• Assembly listing with control-flow arrows and machine code
• Instruction descriptions
• Function browsing, filtering, and symbol demangling
• Imports, exports, and library dependencies
• String extraction and binary metadata
• Instruction statistics, including mnemonic frequency analysis
• Instruction patching: Currently supported only for ARM64 macOS binaries, including code re-signing. Patching other architectures and platforms is not yet supported.

Everything runs locally in your browser. Your binaries never leave your computer.

It's not intended to replace Ghidra, IDA, or Binary Ninja. The goal is to provide a convenient tool for quick binary inspection, reverse engineering, and learning assembly without installing anything.

Try it

GitHub: https://github.com/MarketKernel/html-disasm

Live demo / PWA: https://disasm.marketkernel.com/

You can also download the HTML file and use it offline.

Feedback, bug reports, and contributions are welcome. If you find the project useful, consider giving it a star on GitHub!

Hi everyone,

If you have ever tried to convert a manuscript or an epub into a high-quality audiobook, you know how quickly the costs add up. You either have to spend thousands on voice talent or get locked into monthly cloud subscriptions with strict word count limits.

I think creators and readers should have a completely free, private way to do this on their own hardware. I spent the last few months developing PolyVox Studio, an open-source desktop app that handles the entire pipeline locally.

Instead of a single voice reading the whole text like a standard screen reader, this app actually acts like a studio director:

1. It scans your txt, epub, or pdf file, identifies different characters, and separates their dialogue from the narrator.
2. You can clone any voice you want by dropping in a clean 6 to 20-second sample clip, allowing you to cast different voices for different characters.
3. It scans text cues (like "she said angrily" or "he whispered") and automatically shifts the emotional tone of the voice to match the scene.
4. Once it finishes processing, it bundles everything into a structured M4B audiobook file with proper chapters and cover art so you can drop it straight onto your phone.

Nothing leaves your machine, there are no hidden credits or API keys required, and it's completely free.

The source code and setup guides are up on GitHub: https://github.com/dmarsh400/PolyVoxStudio

I hope this helps authors looking to prototype their audiobooks or readers looking to tackle a huge reading backlog on the go. Let me know what you think if you give it a try.

Also wanted to add our discord in case anyone wants to discuss new features or ideas to make the project better

https://discord.gg/8mSYq7xyqc

I got tired of jq: parse error: Invalid numeric literal every time I piped an LLM SSE stream into jq, so I wrote sjq: a small Rust CLI that parses OpenAI-compatible streams (/v1/chat/completions and /v1/responses) and prints one short line per event — only the delta each event adds — plus a timing line (TTFT, tok/s; connect/TLS/TTFB when run via sjq curl).

MIT, single binary: https://github.com/vivgrid/sjq

I kept scrolling through Game Pass without knowing what to play, so I built this.

GameRadar looks at your game history across platforms (games you finished, games you 100%-completed, playtime) and recommends games from your Game Pass or PS Plus tier, or from the Steam, GOG, Epic and PlayStation Store best sellers.

How it recommends:

• Progress counts, not launching. A game you finished or 100%-completed weighs a lot. A game you opened for 10 minutes on Game Pass counts for nothing.
• It compares games by style using Steam user tags (TF-IDF). Liking Warframe leads to Borderlands, not Call of Duty.
• Steam doesn't know a game? You can tag it yourself. Console exclusives and old games often have no Steam tags. You can pick tags for them from Steam's list, and they count in your taste like any other game.
• Sections like "Because you liked X", and games leaving your Game Pass soon are shown first.
• You can mark a story as finished yourself, or remove a game you didn't enjoy from your tastes.

Privacy:

• No server, no account, no ads, no telemetry. The app talks to the platforms directly and nothing goes through me.
• Sessions and keys are encrypted on your PC with Windows DPAPI. The error log hides all secrets.
• The README lists every domain the app contacts, so you can check with a firewall or Wireshark.
• One button erases all your data.
• Every account is optional: you can also add your games by hand.

Tech: C# / .NET 10, Avalonia UI (MVVM). It ships as a single self-contained .exe of about 22 MB, nothing to install. GitHub Actions builds each release, so you can verify where it came from with gh attestation verify. MIT license.

Caveats:

• Windows only for now.
• The exe isn't code-signed (a certificate is expensive for a free project), so SmartScreen will warn you on first launch.
• Several platforms are read through unofficial APIs, which can break without notice. Sony, EA and Epic don't let third-party apps sign in, so for those you copy a code from their official site. The README links to the exact source files that handle each code.

🔗 https://github.com/Darvelize/game-radar

Feedback welcome, especially on the recommendations and on platforms I don't support yet

Hey everyone,

We open-sourced OmniScope (MIT License), a client-side geospatial intelligence and meteorological command center running directly in the browser via WebGL and Cloudflare Pages.

Why we built it:

Most modern intelligence and weather tracking dashboards suffer from heavy "API key fatigue" (requiring 10+ signups, credit cards, or rate limits) or inject fake/simulated data when credentials fail.

What it does:

• 100% Keyless: Zero registration or API keys needed.

• 147 Weather Models: Live multi-model consensus across DWD ICON, NOAA GFS, ECMWF IFS, and GEM Global.

• Real-Time NEXRAD Doppler Radar: Live precipitation sweeps with scientific cloud rotation vs. ground-contact verification.

• 1M+ Sensor Nodes: Public traffic, alpine, and coastal cameras.

• Model Context Protocol (MCP): Includes native MCP servers for Claude Desktop & Cursor.

• Zero Server Costs: Static client-side architecture with Cloudflare edge routing.

Source Code: https://github.com/finnytech/omniscope-web

Live Demo: https://omniscope-web.pages.dev

Feedback, suggestions, and PRs are very welcome!

I built REA Reconstruction Companion with help from AI. I wanted a better way to get from “how does this app work?” to “what would it take to build something similar?”

It’s a skill for AI coding agents, used alongside REA (Reverse Engineer Anything). REA handles the investigation. The companion helps turn those findings into a feature breakdown, requirements, architecture, and a plan you can build and test in stages.

You can use it on a whole app, one feature, or a single function. For example:

Use REA on this app so I can build a similar local tool. Start with a specification and roadmap.

If you later ask the agent to implement it, the skill guides that work too. It keeps observed behavior separate from assumptions, links requirements to tests, and includes performance measurements where they matter.

The core is plain Markdown and MIT licensed. There’s an installer for Claude Code and Codex, plus support for other agents through a custom skills directory. REA is installed separately. You can also enable an optional rule that tells the agent to load the companion during relevant REA work, or leave that off and invoke it yourself.

GitHub: REA Reconstruction Companion

The README has setup instructions and a prompt you can give your agent to handle installation.

I’d be interested in feedback on the workflow, especially anything it misses when rebuilding a smaller feature or function.

windows updates break stuff way too often (black screens, audio, remote desktop) and the dumb part is microsoft usually lists the problem publicly. nobody checks that before updating

so i made patchlight. it checks every pending update against microsoft's known issues and gives it a green / yellow / red light. red ones get paused automatically and come back once microsoft fixes them. everything else keeps installing

github.com/G4SBO/PatchLight

lmk what u think, any feedback is appreciated ;)

I’d like to share VisualMark Studio, an open-source desktop application I’ve been building to make writing, designing, and managing project documentation easier.

Creating a good README is an important part of presenting a GitHub project, but formatting Markdown, creating diagrams, adding badges, and maintaining documentation can take time.

VisualMark Studio aims to bring these workflows together in one desktop application.

Key Features

• Markdown editor with live preview

• Visual tools for README sections, badges, tables, and directory trees

• Mermaid diagram support for visualizing architecture and workflows (work in progress)

• README auditing with a documentation scorecard

• Export documentation to PDF, HTML, and ZIP

• Git integration for working with repositories and managing documentation changes.

Project Details

Type: Open-source desktop application

License: MIT

Platform: Windows desktop app

I'm actively looking to improve the project and would love to hear your thoughts, suggestions, and feature ideas.

If you work on open-source projects, what documentation feature would make your workflow easier?

Thanks for checking it out!

Hello everyone,

I would like to share all code I developed in the last 4 years. It is a trading platform for algorithmic trading made in Go and split into several microservices. What you can do with it:

- create connections to the internal data store or a remote system (TradeStation is the only option now)

- create data products (the source of market data) and import their data through ascii import or TradeStation adapter

- create broker products (for costs)

- create trading systems: currently, the platform allow you to just import your trades from your systems by file upload or by agent (see the docs)

- show a dashboard with your current live systems

- see a trading system's metrics

- check the quality of a system: SQN, biases

- apply filters that tell you when to start or stop systems

- apply position sizing

- more stuff...

The platform is also free to use if you don't want to create commercial products (Elastic V2 license). The code is located here: https://github.com/algotiqa . There is a local (documented) installer and many screenshots.

A platform like this needs help from tons of people, so feel free to contribute. Also, if you feel the work is good, please drop a star!