Show stories

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

Hey HN,

For a while now, our team has been trying to solve a common problem: getting all the context needed to debug a bug report without the endless back-and-forth. It’s hard to fix what you can't see, and console logs, network requests, and other dev data are usually missing from bug reports.

We’ve been working on a new tool called Recording Links. The idea is simple: you send a link to a user or teammate, and when they record their screen to show an issue, the link automatically captures a video of the problem along with all the dev context, like console logs and network requests.

Our goal is to make it so you can get a complete, debuggable bug report in one go. We think this can save a ton of time that's normally spent on follow-up calls and emails.

We’re a small team and would genuinely appreciate your thoughts on this. Is this a problem you face? How would you improve this? Any and all feedback—positive or critical—would be incredibly helpful as we continue to build.

PS - you can try it out from here: https://jam.dev/recording-links

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’ve been working on automating bookkeeping tasks, and one big pain point was manually reconciling receipts with bank transactions. We built a system that runs in the background, parses receipts (including Gmail), suggests matches, and learns from confirmations to auto-match over time.

It's built into Midday and fully open-source.

Let me know if you have any questions!

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).

This article discusses the development of a WebAssembly-based text-based adventure game, exploring the potential of WASM for building interactive web applications and games.

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.

Envoy is a lightweight, background utility that logs your terminal commands. It's designed to be a simple and unobtrusive way to keep a history of your shell usage, which can be useful for debugging, tracking work, or just remembering what you did.

We built SwiftAI, an open-source Swift library that lets you use Apple’s on-device LLMs when available (Apple opened access in June), and fall back to a cloud model when they aren’t available — all without duplicating code.

SwiftAI gives you: - A single, model-agnostic API - An agent/tool loop - Strongly-typed structured outputs - Optional chat state

Backstory: We started experimenting with Apple’s local models because they’re free (no API calls), private, and work offline. The problem: not all devices support them (older iPhones, Apple Intelligence disabled, low battery, etc.). That meant writing two codepaths — one for local, one for cloud — and scattering branching logic across the app. SwiftAI centralizes that decision. Your feature code stays the same whether you’re on-device or cloud.

Example

  import SwiftAI
   
  let llm: any LLM = SystemLLM.ifAvailable ?? OpenaiLLM(model: "gpt-5-mini", apiKey: "<key>")

  let response = try await llm.reply(to: "Write a haiku about Hacker News")
  print(response.content)

Links

- GitHub (source, docs): https://github.com/mi12labs/SwiftAI

- System Design: https://github.com/mi12labs/SwiftAI/blob/main/Docs/Proposals...

- Swift Package Index (compat/builds): https://swiftpackageindex.com/mi12labs/SwiftAI

- Discord https://discord.com/invite/ckfVGE5r and slack https://mi12swiftai.slack.com/join/shared_invite/zt-3c3lr6da...

Not all improvements come from adding complexity — sometimes it's about removing it.

PageIndex takes a different approach to RAG. Instead of relying on vector databases or artificial chunking, it builds a hierarchical tree structure from documents and uses reasoning-based tree search to locate the most relevant sections. This mirrors how humans approach reading: navigating through sections and context rather than matching embeddings.

As a result, the retrieval feels transparent, structured, and explainable. It moves RAG away from approximate "semantic vibes" and toward explicit reasoning about where information lives. That clarity can help teams trust outputs and debug workflows more effectively.

The broader implication is that retrieval doesn't need to scale endlessly in vectors to be powerful. By leaning on document structure and reasoning, it reminds us that efficiency and human-like logic can be just as transformative as raw horsepower.

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 — hn@vr.dev

PasteVault is an open-source project that provides a secure and easy-to-use platform for sharing text and code snippets. It offers features such as syntax highlighting, expiration of pastes, and anonymous posting to enable secure and efficient sharing of information.

Mobile first open-source RSVP platform. Alternative for meetup.com / eventribe for small companies and groups. If you have a small group and don't want to pay for services you can easily selfhost this solution. Open for improvements and for feedback, ofc.

- One-Click Sharing - Each event gets a unique, memorable URL. Share instantly via any platform or messaging app. - No Hassle, No Sign-Ups - Skip registrations and endless forms. Unlike other event platforms, you create and share instantly — no accounts, no barriers. - Effortless Simplicity - Designed to be instantly clear and easy. No learning curve — just open, create, and go.

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!

Hey HN, I built Yoink AI to solve my biggest frustration with AI tools: they constantly break my workflow. I was tired of copy-pasting between my apps and a chatbot just for simple edits.

Yoink AI is a macOS app that brings the AI to you. With a simple hotkey (⌘ Shift Y), it works directly inside any text field, in any app. If you can type there Yoink can write there

Key Features: - Automatically captures the context of the text field you're in, so you dont have to manually prime it

- Create custom voices trained on your own writing samples. This helps you steer the output to match your personal style and avoid generic, robotic-sounding text

- Yoink doesnt just dump text and run. It delivers suggestions as redline edits that you can accept or reject, keeping you in full control.

It's less of a chatbot and more of a collaborative writing partner that adapts to your workflow, not the other way around.

There's a free tier with 10 requests/month and we just launched a pro trial, which will get you 100 requests for the first 7 days to try it out!

I'm here to answer questions and would love to hear what you think - like all early stage start ups, feedback is always deeply appreciated

Kubbo is a cloud-based collaboration platform that enables teams to create, organize, and share information. It offers features like real-time collaboration, task management, and file sharing to help streamline remote and hybrid work workflows.

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!

Hey HN, I wanted a grammar checker that didn’t send my writing to someone's servers, so we built Grammit, a Chrome extension that runs grammar checks locally using an LLM. Your text never leaves your computer during checking.

Here’s a 2-minute overview: https://www.loom.com/share/baf501ee6cf14a919a7384128246ed67

Because it uses an LLM, it catches more than spelling and grammar. For example, it can correct some wrong statements like “The first US president was Benjamin Franklin.”

Grammit also includes an in-page writing assistant that can rephrase or draft new text. It also uses the local LLM.

We used many new web features to build this, such as:

- Chrome’s new Prompt API to talk to the local model.

- Anchor Positioning API to place the UI with minimal impact on the DOM.

- CSS Custom Highlights API for inline error marking.

- The new CSS sign() function to create CSS-driven layout with discontinuities.

Part of the fun of being early adopters of bleeding edge tech is we’re discovering new Chrome bugs (e.g., https://issues.chromium.org/issues/428354426, https://issues.chromium.org/issues/428039224).

I’d love your feedback on:

- Where the UX feels rough

- What do you think of the corrections and suggestions

Happy to answer questions about the tech or the Prompt API. Thanks for trying it out!

Chrome Web Store extension link: https://chromewebstore.google.com/detail/grammit-the-ai-gram...

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

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)

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

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!

Hey all, I just released v2.0.0 of FilterQL, a query language and TypeScript library. This version adds support for Operations, which allow you to transform the data after filtering.

If you think this would be useful in a project you're working on, give it a try and let me know what you think!

Hey HN! We've run our privacy-focused open-source inference company for a while now, and we're launching a flat monthly subscription similar to Anthropic's. It should work with Cline, Roo, KiloCode, Aider, etc — any OpenAI-compatible API client should do. The rate limits at every tier are higher than the Claude rate limits, so even if you prefer using Claude it can be a helpful backup for when you're rate limited, for a pretty low price. Let me know if you have any feedback!

A while ago I was looking for information on a obscure and short lived British computer.

I found an article[1] in the archives of BYTE magazine[2] - and was captivated immediately by the tech adverts of bygone eras.

This led to a long side project to be able to see all 100k pages of BYTE in a single searchable place.

[1]: https://byte.tsundoku.io/#198502-381

[2]: https://news.ycombinator.com/item?id=17683184

Hi HN,

To truly understand how operating systems and network protocols work, I decided to combine two classic learning tools: the xv6 teaching OS and a from-scratch TCP/IP stack.

I'm excited to share the result: my own from-scratch TCP/IP networking stack running directly inside the xv6-riscv (https://github.com/pandax381/xv6-riscv-net) kernel.

The project uses a modern virtio-net driver, allowing it to run seamlessly in QEMU and communicate with the host machine.

Key features:

- From-Scratch Stack: The core is powered by microps (https://github.com/pandax381/microps), a TCP/IP stack I originally wrote to run in user-space as a personal project to learn the low-level details of networking.

- Kernel Integration: This project ports microps from user-space into the xv6-riscv kernel.

- Socket API: Implements standard system calls (socket, bind, accept, etc.) to enable network application development.

- User-level Tools: Comes with a simple ifconfig command, plus tcpecho and udpecho servers to demonstrate its capabilities.

This has been a fantastic learning experience. My goal was to demystify the magic behind network-aware operating systems by building the components myself.

I'd love to hear your feedback and answer any questions!

Hi, I’m Mikkel and I’m building Async, an open-sourced developer tool that combines AI coding with task management and code review.

What Async does:

  - Automatically researches coding tasks, asks clarifying questions, then executes code changes in the cloud
  - Breaks work into reviewable subtasks with stack diffs for easier code review
  - Handles the full workflow from issue to merged PR without leaving the app

I’ve been working as a developer for over a decade now. I’ve tried all sorts of AI tools out there including Cline, Cursor, Claude Code, Kiro and more. All are pretty amazing for bootstrapping new projects. But most of my work is iterating on existing codebases where I can't break things, and that's where the magic breaks down. None of these tools work well on mature codebases.

The problems I kept running into:

  - I'm lazy. My Claude Code workflow became: throw a vague prompt like "turn issues into tasks in Github webhook," let it run something wrong, then iterate until I realize I could've just coded it myself. Claude Code's docs say to plan first, but it's not enforced and I can't force myself to do it.
  - Context switching hell. I started using Claude Code asynchronously - give it edit permissions, let it run, alt-tab to work on something else, then come back later to review. But when I return, I need to reconcile what the task was about, context switch back, and iterate. The mental overhead kills any productivity gains.
  - Tracking sucks. I use Apple Notes with bullet points to track tasks, but it's messy. Just like many other developers, I hate PM tools but need some way to stay organized without the bloat.
  - Review bottleneck. I've never shipped Claude Code output without fixes, at minimum stylistic changes (why does it always add comments even when I tell it not to?). The review/test cycle caps me at maybe 3 concurrent tasks.

  - Forces upfront planning, always asks clarifying questions and requires confirmation before executing
  - Simple task tracking that imports Github issues automatically (other integration coming soon!)
  - Executes in the cloud, breaks work into subtasks, creates commits, opens PRs
  - Built-in code review with stacked diffs - comment and iterate without leaving the app
  - Works on desktop and mobile

You've probably seen tools that do pieces of this, but I think it makes sense as one integrated workflow.

This isn't for vibe coders. I'm building a tool that I can use in my day-to-day work. Async is for experienced developers who know their codebases and products deeply. The goal is to make Async the last tool developers need to build something great. Still early and I'm iterating quickly. Would love to know what you think.

P.S. My cofounder loves light mode, I only use dark mode. I won the argument so our tool only supports dark mode. Thumbs up if you agree with me.