2025年8月29日 的 Show HN

I got tired of Claude hallucinating Swift APIs. It does a good job at Python and TypeScript, but ask it about SwiftUI and it's basically guessing.

The problem? Apple's docs are JavaScript-rendered, so when you paste URLs into AI tools, they just see a blank page. Copy-pasting works but... c'mon.

So I built something that converts Apple Developer docs to clean markdown. Just swap developer.apple.com with sosumi.ai in any Apple docs URL and you get AI-readable content.

For example:

- Before: https://developer.apple.com/documentation/swift/double - After: https://sosumi.ai/documentation/swift/double

The site itself is a small Hono app running on Cloudflare Workers. Apple's docs are actually available as structured data, but Apple doesn't make it obvious how to get it. So what this does is map the URLs, fetch the original JSON, and render as Markdown.

It also provides an MCP interface that includes a tool to search the Apple developer website, which is helpful.

Anyway, please give this a try and let me know what you think!

Hey HN. I created this website.

https://pj4533.com/hn-overlooked/

It's just a simple web app that discovers overlooked posts on Hacker News. I created it because I was often coming to Hacker News and realizing that I was missing a lot of stuff, and there just didn't seem to be an easy way to surface content that was interesting to me but just didn't bubble up to the top of the page. So I built this.

I got the idea a while back, one night when I was recording (you can watch it here, it's pretty funny: https://youtu.be/FDyDb4sX30w?si=E3rby-DaGWA6gy0R ). But I never really did anything with the idea. So I decided just to make it into a little single-page web app.

The Hacker News API is pretty cool because it doesn't require an API key, so you can just vibe code against it super easy. I just loaded up Claude Code and started talking to it. That first night when I was recording, it was just me with this repo, that I call 'thefuture' and I just put everything in there: scripts, whatever. Then i'll have Claude Code use OpenAI to talk to me and I'll just get bored and explore different APIs and see what I can come up with. That's all inside a single repo that Claude Code knows about, and just set it in YOLO mode and just go to town - it's super fun. It's kind of slow though, so that's the only downside. But if you put a script in there for Claude to talk to you, it can be pretty fun just to explore things.

This website is just one idea extracted from that one session of messing around with a Claude Code last month. I open sourced it, you can look at the repo here: https://github.com/pj4533/hn-overlooked

You ever just want to shrink a video… and suddenly you’re buried in flags, half-broken StackOverflow answers, and 10 tabs open just to figure out one command?

That’s been me. Every. Single. Time.

So I built FFmpeg Pages — a dead-simple collection of the commands I kept searching for. No fluff, no digging, just the stuff that actually works.

Hey HN! I’ve been building [Octarine](https://octarine.app/) for a little over 2 years. It started because I wanted a note-taking app that was:

- Lightweight (< 30MB, fast to launch, no Electron bloat).

- Opinionated (good defaults, clean UI, not a plugin bazaar).

- Yours (all plain Markdown, nothing proprietary).

---

- Command bar (Cmd/Ctrl+K) to navigate and run commands quickly.

- WYSIWYG editor (rich text without live preview jumping).

- Git sync built-in — backups to GitHub/GitLab, no plugins.

- Natural language dates (“yesterday”, “last week”).

- Multiple workspaces, templates, tags, graph view.

- Backup anywhere — iCloud, Dropbox, Syncthing.

- Tabs & Panes — split and rearrange notes/graphs like a code editor.

*Pro Features*

- BYOK for over 9 AI providers including OpenAI, Anthropic, Perplexity, Gemini and more!

- Ask Octarine — chat with your notes (RAG, embeddings done on-device).

- Writing Assistant — Sidebar assistant to help rewrite, improve or create.

- Focus Mode — distraction-free, sentence spotlight.

- Customisation — 30+ fresh themes, different paper types.

- Locked Notes — Disallow a note from editing.

- Folder Customisations — Add icons/colors to folders, have them manage their own unique sorting.

*FAQ*

- Free plan gets updates forever; some features are Pro.

- Pro is a one-time license (no yearly “updates tax”).

- Over 130+ releases shipped.

- iOS app is in development.

- Overlaps with Obsidian, but follows different methodologies about having less but baked in features, over an extensible plugin system (each work for different users)

---

Try it: [octarine.app](http://octarine.app)

Changelog: [octarine.app/changelog](https://octarine.app/changelog)

Documentation: [docs.octarine.app](https://docs.octarine.app)

I’d love your feedback - what works, what feels off, what’s missing? Always open to ideas (and criticism).

I made an open source, MIT license Typescript library based on some of the latest research that generates prompt injection attacks. It is a super minimal/lightweight and designed to be super easy to use.

Keen to hear your thoughts and please be responsible and only pen test systems where you have permission to pen test!

I built a small, self-contained K-Means implementation in pure PyTorch: https://gitlab.com/hassonofer/pt_kmeans

I was working on dataset sampling and approximate nearest neighbor search, and tried several existing libraries for large-scale K-Means. I couldn't find something that was fast, simple, and would run comfortably on my own workstation without hitting memory limits. Maybe I missed an existing solution, but I ended up writing one that fit my needs.

The core insight: Keep your data on CPU (where you have more RAM) and intelligently move only the necessary chunks to GPU for computation during the iterative steps. Results always come back to CPU for easy post-processing. (Note: For K-Means++ initialization when computing on GPU, the full dataset still needs to fit on the GPU.)

It offers a few practical features:

  - Chunked Computations: Memory-efficient processing of large datasets by only moving necessary data chunks to the GPU, preventing Out-Of-Memory errors
  - Cluster splitting: Refine existing clusters by splitting a single cluster into multiple sub-clusters
  - Zero Dependencies: Single file, only requires PyTorch. Copy-paste into any project
  - Advanced Clustering: Hierarchical K-Means with optional resampling (following recent research), cluster splitting utilities.
  - Device Flexibility: Explicit device control - data can live anywhere, computation happens where you specify (any accelerator PyTorch supports)

Future plans:

  - Add support for memory-mapped files to handle even bigger datasets
  - Explore PyTorch distributed for multi-node K-Means

The implementation handles both L2 and cosine distances, includes K-Means++ initialization.

Available on PyPI (`pip install pt_kmeans`) and the full implementation is at: https://gitlab.com/hassonofer/pt_kmeans

Would love feedback on the approach and any use cases I might have missed!

docustore's aim is to provide up-to-date, off-the shelf and plug-and-play context for LLMs from a curated list of frameworks/sdks. It has a 4 step pipeline: scrape the documentation - clean it - vectorize it - package it. My vision is to host it somewhere and develop an API/MCP around it so it will be development-environment agnostic.

Hi HN,

I’ve been working for the past 10 months on p2party, a TypeScript/C/WASM library which you can find at https://github.com/p2party/p2party-js and demo at https://p2party.com , that lets you spin up an encrypted peer-to-peer mesh with nothing more than a shared URL.

Why I built it: I wanted something between https://file.pizza and “ephemeral Signal chat”, but with my custom cryptographic idea (I know I know... WebRTC is already encrypted and it is easy to go wrong etc.). The project started as a toy for sharing large DAW files with my bandmates (and to flex some applied crypto skills), then grew into a general toolkit. It is also a nice side project to test LLMs as companion coders and to know where the world is at right now regarding this subject (personal opinion - super small and well-defined tasks ok).

The cryptography: The messages, either strings or files, get split and included into isomorphic chunks of 64kb which are stored in IndexedDB until they are sent. Each chunk has some metadata like file hash, name, Merkle proof etc., the actual information and then padding left and right with noisy data. The real info starts at random positions on each chunk. The whole thing is then e2e encrypted with ChaChaPoly1305 with sender ephemeral keys and sent in random order.

Inspiration: To an observer of the message traffic, every chunk is isomorphic and contains a lot of useless info and some real ones. But to analyze it they need to store all the junk. The inspiration came from a principle of counter-surveillance that I learned from the adblock tool https://adnauseam.io .

Caveat: Before sending the message, all the chunks need to be created so that the Merkle proofs can be calculated and the browser can send the chunks in random ordering.

The p2p: I could not find a good example online of how to create a WebRTC mesh network so I built a tool for myself. It works acceptably now so that's why I uploaded it here after 10 months of working on it (on and off) :D

The WASM: I had experience with compiling C to WASM when I developed this project in the past https://github.com/deliberative/crypto and I wanted the same efficiency gains here.

Status: It works, but it is not security-audited yet → don’t trust it with your deepest secrets. API is stable enough to embed in your own apps. Open-source under AGPL-3.0.

Try it here: https://p2party.com (open in two browsers or devices). Code is here: https://github.com/p2party/p2party-js.

I'd love your feedback on everything! Enjoy!

I built vr.dev as a lightweight network for people in the VR, XR, and AR development community to showcase demos, promote themselves, and find collaborators. It’s early, but usable for portfolios and discovery.

Example profile: https://vr.dev/erik

What’s live now:

- Profiles with vr.dev/[username] URLs

- Showcase a .glTF file

- Resume/experience with industry-specific signals

What’s coming:

- Options for more showcases and supported asset types

- Advanced searching on experience and skills

- Closer integration with GitHub

- Better discovery

I’d love feedback on what I can add to make this more useful for you!

I’ll be hanging out here all day but feel free to reach out — [email protected]

Hey HN,

I am launching kanto.ai and looking for early beta users.

This came out of my own experience. I was responsible for building and maintaining SOC-2 compliance for a Kubernetes application in GCP. The GCP Cloud Foundation Blueprints are a solid starting point, but they are difficult to set up and even harder to keep updated as requirements, policies, and cloud services evolve. Many aspects required for Soc2 are also not provided out of the box.

kanto.ai is a GitHub bot that bootstraps an enterprise-grade, multi-repo, git-ops first GCP deployment and automates ongoing maintenance. It watches GitHub issues and generates Terraform pull requests with best practices built in. Under the hood it uses GCP’s Cloud Foundation Toolkit modules for projects, networking, org policies, IAM, and more. The goal is to keep infrastructure SOC-2 ready out of the box.

Right now it is early with a landing page and working prototype. I would love feedback from anyone who has dealt with SOC-2, Kubernetes, or the Foundation Blueprints in GCP.

Does this solve a real pain you have felt? What blockers did you run into with SOC-2 in GCP? If you used the GCP Cloud Foundation Toolkit, what worked and what did not?

Thanks.

Last month I posted here about my extension called Monochromate, a greyscale extension I built because I spend most of my time in the browser and couldn’t find the right solution for my needs (https://news.ycombinator.com/item?id=44726807). Thanks to that post I got a ton of feedback, new contributors on GitHub, and we’ve now crossed 450+ users with a 5-star rating on both chrome webstore/firefox addons.

I’m back with a new and improved version that fixes a bunch of small things and adds some much-requested features:

Works on Firefox Android Shortcut keys Temporary disable (turn it off for a while, it re-enables automatically) Exclude media-only pages (like when you open an image in a new tab)

As before, I’d love any kind of feedback it’s been super helpful to iterate on this product and I am looking forward to do it even more

I built a simple simulation of a Dyson Sphere using C++ and OpenGL. It renders ~20,000 satellites orbiting a star, with adjustable parameters like satellite size, density, and distribution.

The goal was to explore graphics programming and visualize how such a megastructure might look. It’s still work in progress, but functional enough to share.

Code, screenshots, and instructions here: https://github.com/corvo001/DysonSphere

Hey HN

I’ve been working on Patio, a platform to make DIY & home improvement more community-driven. Just shipped a new feature: Clubs.

Clubs are like little hubs where you and your people can:

- Share tools & leftover materials (instead of letting them collect dust) - Lend/borrow in private groups (family, friends, coworkers) or public ones (like a neighborhood tool library) - Pin a location for your club - Share guides, plans, or helpful links

The idea: make it easier to share what’s already in your garage and cut down on waste. That half-box of tiles or extra paint? Could be exactly what your neighbor’s looking for.

We’re still early, would love your feedback on how this could work best for neighborhoods, families, and organizations.

Thanks and have a great day!

Julien

A benchmark I've maintained for a few years, tell me your scores.

This feed reader can fetch and display discussion threads from Hacker News and Lobste.rs, making it convenient to follow both articles and the conversations around them. It’s a fork of the original Yarr project, whose author considers it feature-complete and is no longer accepting feature requests.

Live extension analysis: Point us at a Chrome/Edge/Firefox extension (store URL or CRX). We spin up a safe sandbox and observe it in real time—permissions use, message passing, storage writes, network calls, remote code loading, and UI injections.

Package scanning: Paste an npm/package URL or code. We do quick static + dynamic checks: install/postinstall scripts, obfuscation/eval, exfil endpoints, suspicious APIs, and typosquat/reputation signals.

AI explainer: An LLM summarizes the behaviors and risk patterns in plain English (why it’s risky, what to verify, how to mitigate), and produces a shareable report.

Don't ask me where this idea came from. But a couple of years ago I had this crazy idea of writing a HTML to Javascript compiler. I went off it for a bit, but just started hacking back on it again and have something that actually works (demos and all). It's inspired a little by the early days of my development career writing Coldfusion.

Would you use this to build production apps? You'd probably be as crazy as I am for making this if you did, but still.

A fun little crazy experiment.

We originally built this because we needed a way to run MCP servers inside private clouds and on-prem. Most of the teams we work with can’t just punch a hole through the firewall to hit some external service. They need agents that can securely connect to databases, internal APIs, and legacy systems — all inside their own infrastructure.

Agentic systems like LangChain and LangGraph are powerful, but they need reliable tool access without a human in the loop. MCP is the right protocol for that, but actually deploying MCP servers was painful. Every one had different requirements (stdio vs HTTP), and scaling them in production was messy.

So we built NimbleTools Core:

* Team-Ready from Day One: multi-workspace support, RBAC, private registries.

* Universal Deployment: run stdio servers and HTTP servers with the same interface.

* Horizontal Scaling: MCP servers scale up/down automatically with demand.

* Community Registry: browse and deploy pre-configured servers, or publish your own.

* Kubernetes-Native: CRDs + operator pattern for lifecycle management.

Quick start (literally one command gets you running locally):

``` curl -sSL https://raw.githubusercontent.com/NimbleBrainInc/nimbletools... | bash ```

We’ve been using this for more complex customer deployments already, but wanted to give back by open-sourcing the core engine.

It’s still early — today NimbleTools Core gives you a solid runtime for deploying MCP servers on Kubernetes. Looking ahead, we’re experimenting with features outside the current MCP spec that we think will matter in production, like:

- Session management: keep context across multiple tool calls, not just one-off requests

- Smarter auto-scaling: more granular policies beyond just horizontal replicas

- Tool discovery & selection tools: helping agents automatically find, choose, and route to the right MCP server at runtime

We’d love feedback from the community on which direction matters most.

https://github.com/NimbleBrainInc/nimbletools-core

We just opened up a discord too (https://discord.gg/znqHh9akzj). Bit of a ghost town right now, but hoping to change that!

A resilient, rate-limited, one-file-per-second copier for CD/DVD data on low-power or unstable USB hosts (e.g., Raspberry Pi), designed to prevent optical drives from ramping to high RPM and brown-out resetting.

I created a small project called GraphXML. It uses an XML-based format to define charts and renders them using C + SDL2.

It can produce line and bar charts and export them directly to PNG without opening a window, which is handy for scripts or Termux setups.

The syntax is simple and easy to read. There are plans to add FFI support for Python and JavaScript/WebAssembly, which could make it easier to use in other projects.

The repository includes examples and a demo PNG: https://github.com/Ferki-git-creator/graphxml

It could be useful for people looking for a lightweight, programmatic way to create charts.

We built StripeMeter, an open-source usage metering platform that plugs directly into Stripe. It solves the classic SaaS pain of “why is my bill higher than expected?” by giving both developers and customers real-time usage tracking with live cost projections. Why it matters

- Transparency: Customers see exactly what Stripe will bill them (within 0.5% parity).

- Exactly-once guarantee: No double billing, ever.

- Fast & scalable: Sub-minute freshness with Redis + Postgres counters.

We’d love feedback from SaaS builders, especially if you’ve struggled with Stripe’s metered billing. Does this solve a real pain for you? What would you need before trusting it in production?

Hi HN!

I built Str-Plus, a lightweight and type-safe string utility library for JavaScript and TypeScript. It includes 80+ functions for common string tasks like capitalization, trimming, reversing, case conversion, validation, and more. Everything is fully typed, so it works seamlessly in TypeScript projects.

GitHub: https://github.com/ShahidKhanDev/str-plus

Would love to hear your thoughts or feature requests!

Cumul is a lightweight CLI tool that concatenates text files in a directory into a single file, optimized for providing context to Large Language Models (LLMs).

It respects .gitignore, filters out binaries and non-text files, adds path headers, and generates a summary report.

Key features:

Exclude patterns via options (e.g., -e .json,.md). Custom output prefix (e.g., -p my). Built in Zig for efficiency.

Install via:

curl -fsSL https://raw.githubusercontent.com/xcaeser/cm/main/install.sh | bash

Usage: cm [directory] outputs <directory-name>-cumul.txt.

Developed to streamline LLM workflows in development.

Feedback welcome.

Small tool to manage sub agents in projects. I do like to have sub agents cherry picked for what I need locally, and not have many of them potentially contaminating context - especially when used with PROACTIVELY flag.