Features: 3 oscillators, Moog ladder filter (24dB/oct), dual ADSR envelopes, LFO, glide, noise generator, 4 multitimbral channels, 19 presets, rotary
knob GUI, virtual keyboard with mouse + QWERTY input, and MIDI support.
No external GUI frameworks — just tkinter, numpy, and sounddevice.It’s different than existing approaches: mesh VPNs (Tailscale, ZeroTier, etc.) create flat overlay networks where ACL and IP space management becomes complex at scale and every device can talk to every other device, while corporate ZTNA solutions (Zscaler, Cato, Netskope etc.) are closed-source and add latency by forcing traffic through a central server.
Pangolin takes a resource-centric approach. You deploy lightweight connectors that bridge to specific resources (private web apps, SSH, databases, CIDR ranges). Admins delegate resource-access to specific users and roles. It uses WireGuard with NAT hole-punching for peer-to-peer connections and traffic goes directly between the user and connector instead of through a central server. It supports native clients (Mac/Windows/Linux/iOS/Android) plus identity-aware, browser-based access when a client isn’t required.
Pangolin has a cloud and is optionally self-hosted. The Community Edition is AGPLv3. The Enterprise Edition is also open-source under the commercial license which enables free personal/small business use.
Everything, from the server to the clients, is fully open-source and you can even self-host the whole stack. We’d love to hear what you think and I'm happy to answer any questions!
I run a generative AI infra company, unified API for 600+ models. Our team started deploying AI agents for our marketing and lead gen ops: content, engagement, analytics across multiple X accounts.
OpenClaw worked fine for single agents. But at ~14 agents across 6 accounts, the problem shifted from "how do I build agents" to "how do I manage them."
Deployment, monitoring, team isolation, figuring out which agent broke what at 3am. Classic orchestration problem.
So I built klaw, modeled on Kubernetes: Clusters — isolated environments per org/project Namespaces — team-level isolation (marketing, sales, support) Channels — connect agents to Slack, X, Discord Skills — reusable agent capabilities via a marketplace
CLI works like kubectl: klaw create cluster mycompany klaw create namespace marketing klaw deploy agent.yaml
I also rewrote from Node.js to Go — agents went from 800MB+ to under 10MB each.
Quick usage example: I run a "content cluster" where each X account is its own namespace. Agent misbehaving on one account can't affect others. Adding a new account is klaw create namespace [account] + deploy the same config. 30 seconds.
The key differentiator vs frameworks like CrewAI or LangGraph: those define how agents collaborate on tasks. klaw operates one layer above — managing fleets of agents across teams with isolation and operational tooling. You could run CrewAI agents inside klaw namespaces.
Happy to answer questions.
I've been building this solo for about three and a half years. I kept trying every new project/notes tool (Notion, Asana, Trello, etc.) and always ended up back in a plain text file. I wanted something that felt like a text editor on first touch but could grow into real structure when you needed it.
The tech stack is Laravel, MySQL, Redis, and hand-rolled JavaScript on the client. No frameworks like React/Vue/etc. ~270 lines of jQuery (out of 80k+ total LOC) for a few legacy DOM utilities, plus IndexedDB for local persistence. Real-time collaboration uses a hybrid approach: HTTP/2 POST for resilient ops + WebSockets via Laravel Reverb for live cursors, presence, and edits.
This is a pre-release stress test, not a launch. Lightwave will be a paid product. Right now I'm opening it up because no amount of solo testing replicates getting punched in the mouth by real traffic.
The link above has a button to create a test account in 1 click.
Known rough edges: the cursor and selection system are built from scratch (like VS Code, not a contenteditable wrapper), so there's a lot of surface area. Some keyboard shortcuts may be missing. Desktop only, accessibility not yet implemented. I'm shipping fixes in real time.
There's a "Submit Bug or Feedback" button inside the app if something breaks. Happy to answer any questions about the architecture, or anything else.
Some highlights:
- Paste markdown in, get native blocks. Copy blocks out, get markdown back.
- Hierarchical document, structure. Hierarchichal file manager.
- Live collab with shared cursors, selection, and presence.
- Code blocks with syntax highlighting. LaTeX math blocks.
- Full data export: markdown, JSON, and attachments. No lock-in.
- Full undo/redo with cursor restoration.
Target auditory - self hosted cicd systems with devops using general programming languages instead of yaml
Link to the article - https://github.com/melezhik/DSCI/blob/main/introduction.md
Disclosure - Feel free to ask me any questions or provide constructive feedback - I am the tool author
Thanks
I wanted a simple UI for notes and observations around my neighborhood (e.g. this garden has beautiful poppies, this coffee shop has excellent espresso, etc.) and built this. It’s open and free to use, I hope you enjoy it as much as I do!
Feedback welcome.
You know what you want to do, move this commit over there, undo that thing you just did, split this big commit into two smaller ones. Git Navigator lets you just... do that. Drag a commit to rebase it. Cherry-pick (copy) it onto another branch. Click to stage specific lines. The visual canvas shows you what's happening, so you're not guessing what `git rebase -i HEAD~3` actually means.
The inspiration was Sapling's Interactive Smartlog, which I used heavily at Meta. I wanted that same experience but built specifically for Git.
A few feature callouts:
- Worktrees — create, switch, and delete linked worktrees from the graph. All actions are worktree-aware so you're always working in the right checkout. - Stacked workflows — first-class stack mode if you're into stacked diffs, but totally optional. Conflict resolution — block-level choices instead of hunting through `<<<<<<<` markers.
Works in VS Code, Cursor, and Antigravity. Just needs a Git repo.
Site: https://gitnav.xyz
VSCode Marketplace: https://marketplace.visualstudio.com/items?itemName=binhongl...
Open VSX: https://open-vsx.org/extension/binhonglee/git-navigator
The idea is airlines hedge jet fuel, starbucks hedges coffee beans - as GPU compute becomes critical infrastructure the same hedging tools should exist. Not sure if anyone actually needs this but it was interesting to build.
How it works: - Pulls live H200 spot prices from Vast.ai every 15s into a tradeable index - Full perp mechanics: funding rates, mark price calc, real-time P&L - Event-driven Rust backend with supervisor pattern and circuit breakers - Next.js frontend with TradingView charts, real-time WebSocket updates
What's real vs simulated: - Real: Index construction, funding rate engine, forward curve, state persistence - Simulated: Order book depth and trade matching (its a single-client demo)
The backend is the part I'm most proud of - isolated tasks coordinated by a supervisor, each has it's own state machine so if one component fails it doesn't take down the others. Tried to build it with production patterns in mind even though its just a demo.
Also made a 15-page derivatives pricing doc that covers the economic model and hedging scenarios. Basically: rental prices = f(CAPEX, utilization, depreciation) so futures pricing reveals market expectations about GPU supply/demand.
GitHub: https://github.com/zacharyfrederick/compex
Would love feedback on the architecture or if the market mechanics actually make sense. First time building something like this.
I built DocSync because every team I've worked on has the same problem: documentation that was accurate when it was written and never updated after.
DocSync uses tree-sitter to parse your code and extract symbols (functions, classes, types). On every commit, a pre-commit hook compares those symbols against existing docs. If you added a function without documenting it, the commit is blocked.
How it works:
1. `clawhub install docsync` (free) 2. `docsync generate .` — generates docs from your code 3. `docsync hooks install` — installs a lefthook pre-commit hook 4. From now on, every commit checks for doc drift
Key design decisions: - 100% local — no code leaves your machine. Uses tree-sitter for AST parsing, not an LLM. - Falls back to regex if tree-sitter isn't installed - Uses lefthook (not husky) for git hooks — it's faster and language-agnostic - License validation is offline (signed JWT, no phone-home) - Free tier does one-shot doc generation. Pro ($29/user/mo) adds hooks and drift detection.
Supports TypeScript, JavaScript, Python, Rust, Go, Java, C/C++, Ruby, PHP, C#, Swift, Kotlin.
Landing page: https://docsync-1q4.pages.dev
Would love feedback on the approach. Is doc drift detection something your team would actually use?
So I built Ingglish — English where every letter always makes the same sound. "ough" alone makes 6 different sounds (though, through, rough, cough, thought, bough). In Ingglish, every letter has one sound, no silent letters, no exceptions.
- Paste text to see it translated instantly
- Translate any webpage while preserving its layout
- Chrome extension to browse the web in Ingglish
- Fully reversible — Ingglish text can be converted back to standard English (minus homophones)
I'd love your feedback! Thanks.
I’ve been developing and maintaining a network management tool called TWSNMP for about 25 years. This new version, "FK" (Fresh Konpaku), is a complete modern rewrite.
Why I built this: Most enterprise NMS are heavy, server-based, and complex to set up. I wanted something that runs natively on a desktop, is extremely fast to launch, and provides deep insights like packet analysis and NetFlow without a huge infrastructure.
The Tech Stack: - Backend: Go (for high-speed log processing and SNMP polling) - Frontend: Svelte (to keep the UI snappy and lightweight) - Bridge: Wails (to build a cross-platform desktop app without the bulk of Electron)
I’m looking for feedback from fellow network admins and developers. What features do you find most essential in a modern, lightweight NMS?
Documents are .md files on disk. Images are regular files. Exports to standalone HTML with Tufte CSS baked in — my use case is writing essays and uploading them directly to my personal site.
Zero dependencies, no npm install, no accounts, no build step. Just `node server.js`. ~7 files total.
Full disclosure in the README: I'm a researcher, not a JS developer, and the code was AI-generated. Contributions and code review welcome.
xt_string scales linearly (O(N)), causing massive slowdowns with many rules. Strider uses Aho–Corasick for O(1) matching.
Key Features:
O(1) Algorithmic Complexity: Uses a compact, double-array trie-based Aho–Corasick automaton, sustaining above 1 Gbps when matching 3,000 patterns, while xt_string (KMP) drops below 2 Mbps.
Lockless Datapath: RCU-protected lookups ensure zero locking overhead on the packet processing hot path.
Correctness: Never misses patterns spanning across IP fragments (unlike xt_string’s fast Boyer–Moore mode).
lineark takes a different approach: it's a CLI your agent calls via Bash. The full command reference (lineark usage) is under 1,000 tokens.
It's also just a nice CLI for humans — human-readable names instead of UUIDs, auto-detected output format (outputs tables in terminal/interactive session, JSON when piped).
Under the hood: the SDK is fully generated from Linear's GraphQL schema via a custom codegen pipeline (apollo-parser → typed Rust). The CLI consumes the SDK with zero raw GraphQL — just typed method calls. You can also create your own lean return data types and validate them against Linear's schema at comptime.
MIT Licensed.
Happy to answer questions. Thanks!
Also includes the fix for the "did not find a proper configuration for key id" error that everyone hits in Cloud Shell.
GitHub: https://github.com/ekadetov/oci-terraform-retry-script
amazon.deThat one-liner is aimed at software engineers, but I've spent my career helping cross-functional teams collaborate, and that's really what this is about. AI agents make powerful workflows very plausible, but only if teams can grow them incrementally without losing control - no vendor lock-in, no discipline silos, no blind trust in outputs.
The site tries to meet different audiences where they are, with mostly practice over theory: tool comparisons, minimal approaches, and freedom to work at whatever level of complexity serves you - whether that's Claude Code with Agent Skills, local models, or custom Python agents.
As a fun "eat your own dog food" experiment, I use the site itself as the reproducible cookbook ("eval-ception") [2]. It's the quickest way to feel what different eval tools are actually like in practice.
I welcome feedback, contributions, or stories. More on the project and what's coming [3]. It's a rewarding area once you realize you can keep control and move methodically - doesn't matter if it's the smallest model or a swarm.
DepGuard is a single tool that wraps native package manager audit commands (npm audit, pip-audit, cargo audit, govulncheck, etc.) and adds license compliance on top.
Why I built it: I was tired of running different audit commands for different projects and having no unified view of license risk. Snyk solves this but sends your data to the cloud. I wanted something local-only.
What it does: - Detects your package manager automatically (supports 10: npm, yarn, pnpm, pip, cargo, go, composer, bundler, maven, gradle) - Runs the native audit tool for each - Scans all dependency licenses and categorizes them (permissive/copyleft/unknown) - Generates CycloneDX SBOMs for compliance - Git hooks that block commits modifying lockfiles with critical vulns - Auto-fix by upgrading to patched versions
Design decisions: - Uses native audit tools, not a proprietary vulnerability database - Everything runs locally — no code or dep lists sent externally - License validation is offline (JWT, no phone-home) - Free: one-shot scan + license check. Pro ($19/user/mo): hooks + auto-fix. Team ($39/user/mo): SBOM + compliance.
Install: `clawhub install depguard`
Landing page: https://depguard.pages.dev
Curious if license compliance is something you've been asked about by legal/compliance teams. That's been the most requested feature in my experience.
How it works:
- Extracts frames using change detection (not just every Nth frame), with periodic capture for slow-evolving content like screen shares
- Filters out webcam/people-only frames automatically via face detection
- Transcribes audio (OpenAI Whisper API or local Whisper — no API needed)
- Sends frames to vision models to identify and recreate diagrams as Mermaid code
- Builds a knowledge graph (entities + relationships) from the transcript
- Extracts key points, action items, and cross-references between visual and spoken content
- Generates a structured report with everything linked together
pip install planopticon
planopticon analyze -i meeting.mp4 -o ./output
Example: We ran it on a 90-minute training session: 122 frames extracted (from thousands of candidates), 6 diagrams recreated, full transcript with speaker diarization, 540-node knowledge graph, and a comprehensive report — all in about 25 minutes.
Python 3.10+, MIT licensed. Docs at https://planopticon.dev.
Agents keep re-learning the same debugging patterns each run (tool/version quirks, setup issues, framework behaviors). ChatOverflow is a shared place where agents post a question (symptom + logs + minimal reproduction + env context) and an answer (steps + why it works), so future agents can search and reuse it. Small test on 57 SWE-bench Lite tasks: letting agents search prior posts reduced average time 18.7 min → 10.5 min (-44%). A big bet here is that karma/upvotes/acceptance can act as a lightweight “verification signal” for solutions that consistently work in practice.
Inspired by Moltbook. Feedback wanted on:
1. where would this fit in your agent workflow 2. how would you reduce prompt injection and prevent agents coordinating/brigading to push adversarial or low-quality posts?
It also lets you estimate cumulative results from current CGPA, completed credits, and expected semester grades. It’s free, no sign-up, and mobile-friendly.
I’d really value feedback on:
missing grading scales or country systems confusing parts of the UX features that would make this more useful for students/counselors
The whole thing runs in your browser. No accounts, no data storage, API calls go to OpenAI but nothing persists. Built with Next.js on Vercel.
It started as a personal tool to help me job hunt, and I kept adding stuff. Figured others might find it useful.
I'd love feedback on the tools themselves and what else would be useful to add.
Market moves can be very different depending on your approach. Your risk tolerance, time horizon, what you already own, or what you’re trying to achieve. That’s why we think personalisation is the right approach to money management.
What we’ve built so far is a personalised feed of stock picks, portfolios you can interpret, and a chat interface to get the answers you need.
We’re curious what the community thinks. Feedback and recommendations welcome.
Twitter: https://x.com/warrenaiapp