Show HN за 6 августа 2025 г.

Most site blockers work by blacklisting distractions. That never worked for me, the internet is too big, and there’s always something new to waste time on.

I wanted the opposite: allowlist‑only browsing. Block everything by default, and explicitly allow only what I need.

So I built Sinkzone: a local DNS forwarder with two modes:

Monitor mode: lets all traffic through, but logs every domain so you can decide what to allow.

Focus mode: only allowlisted domains resolve; everything else is blocked (NXDOMAIN).

It’s open source, written in Go, and runs locally on macOS, Linux, and Windows. Works a bit like Pi‑hole, but instead of blocking ads, it blocks everything unless you say otherwise.

I’m curious if this would be useful in your workflow. If you try it, please let me know what breaks, what works well, and what you’d improve.

Hi HN! I've been working on BookWith, an open-source e-book reader that integrates AI as your reading companion.

The problem: Traditional e-readers are passive. When you encounter something unclear, you have to context-switch to search for it. Your highlights and notes remain isolated, and you can't easily connect ideas across different books.

My solution: BookWith embeds an AI that maintains full context of what you're reading. It features:

- Context-aware AI chat: Ask questions about the current page/chapter and get instant answers - AI podcast generation: Automatically converts book content into conversational podcasts using Google Cloud TTS - Multi-layer memory system: Short-term (last 5 conversations), mid-term (summarized every 20), and long-term (vector search) memory that maintains continuity across reading sessions - Smart annotations: 5-color highlighting system that AI can reference and analyze

Technical stack: Built as a fork of Flow (epub reader), with added LLM integration and vector database for semantic search. Supports multiple LLMs and languages (EN/JA/ZH).

I was frustrated with the existing caltrain websites / apps, so I made a super minimalist one to answer the actual question I have: how long until the next train?

If you're in SF it grabs the next southbound trains, otherwise, the next northbound.

Hi,

I've been watching the rise of AI agents with a mix of excitement and dread. We're building incredible tools that can browse the web, but we're forcing them to navigate a world built for human eyes. They scrape screens and parse fragile DOMs.

We're trying to tame them to act like humans. I believe this is fundamentally wrong. The goal isn't to make AI operate at a human level, but to unlock its super-human potential.

The current path is dangerous. When agents from OpenAI, Google, and others start browsing at scale and speed, concepts like UI/UX will lose meaning for them. The entire model of the web is threatened. Website owners are losing control over how their sites are used, and no one is offering a real solution. The W3C is thinking about it. I decided to build it.

That's why I created AURA (Agent-Usable Resource Assertion).

It's an open protocol with a simple, powerful idea: let website owners declare what an AI can and cannot do. Instead of letting an agent guess, the site provides a simple aura.json manifest.

This gives control back to the site owner. It's a shift from letting AIs scrape data to being granted capabilities. We get to define the rules of engagement. This allows us to increase what AIs can do, not by letting them run wild, but by giving them clear, structured paths to follow.

A confession: I'm not a hardcore programmer; I consider myself more of a systems thinker. I actually used AI extensively to help me write the reference implementation for AURA. It felt fitting to use the tool to build its own guardrails.

The core of the protocol, a reference server, and a client are all open source on GitHub. You can see it work in 5 minutes:

Clone & Install: git clone https://github.com/osmandkitay/aura.git && cd aura && pnpm install

Run the Server: pnpm --filter aura-reference-server dev

Run the Agent: (in a new terminal) pnpm --filter aura-reference-client agent -- http://localhost:3000 "list all the blog posts"

You'll see the agent execute the task directly, no scraping or DOM parsing involved.

The GitHub repo is here: https://github.com/osmandkitay/aura

I don't know if AURA will become the standard, but I believe it's my duty to raise this issue and start the conversation. This is a foundational problem for the future of the web. It needs to be a community effort.

The project is MIT licensed. I'm here all day to answer questions and listen to your feedback—especially the critical kind. Let's discuss it.

Hi HN! Together with contributors, we've been making a small template language for a year now, which, in our opinion, can replace HTMX and Alpine.js. It is a mix between EJS and Handlebars, that is, you can make a request with a familiar syntax to the server in HTML right in the markup.

Requests are made via fetch and are configured via javascript almost entirely, which is what is needed today to work with the server.

The very essence of the template language comes down to minimizing the size of the bundle of the original web application by moving the components to the server and then storing them there. Thus, on the client we get a framework, where we insert components from the server brick by brick.

We showed this template language a long time ago, but it was not so mature then, so people had a lot of questions: https://news.ycombinator.com/item?id=41204552

Thank you very much to everyone for your attention! Please tell me what you think about the project? It will be interesting to know!

I've made an open-source microframework for creating command-line (CLI) applications in the Zig programming language.

It's called Chilli, and it currently provides the following features:

- A declarative API for defining nested commands, flags, and positional arguments.

- Type-safe parsing of arguments from the command line and environment variables.

- Automatic generation of formatted `--help` and `--version` output.

- Support for command aliases, persistent flags, and other common CLI patterns.

You can find the project on GitHub: https://github.com/habedi/chilli

I was tired of sending videos one by one, so I've built a Chrome extension to send video notes from YouTube to NotebookLM in one click.

Here's how it works:

Open any channel, playlist, search result, or video on YouTube.

Click on the NotebookLM button and choose an existing notebook or create a new one.

The extension sends all available videos to NotebookLM up to the limit.

It is free to use and available for Chrome. I would love to hear your feedback!

Hi, I’m Sam, the cofounder/CEO of Mastra, the Typescript agent framework. I wrote a book on building agents and wanted to share it with HN.

The book is called Principles of Building AI Agents. Right now it has 34 chapters and 148 pages covering LLMs, prompting, agents, workflows, RAG, evals, multi-agent, tracing, deployment, MCP, tool use, and a few other topics.

The backstory here is that last October when we started working on Mastra we knew very little about AI engineering, and had to learn as we were building.

In January, we started going to local AI meetups. We met a lot of people who were where we’d been. Somehow, we turned from students to teachers. Whenever an explanation seemed to stick we’d go home and put it in our docs or blog.

One day my cofounder Shane turned to me and was like, what if you wrote a book on this stuff?

I was initially skeptical, but I tried writing an outline and it was pretty natural. So I spent the next couple weekends trying to hammer our posts into book form, and fill in the gaps. Surprisingly it worked. The initial version was 92 pages, in 27 very short chapters.

We were going to call it Principles of AI Engineering but a founder author friend convinced me to use the word Agents instead, so Principles of Building AI Agents it was.

The first reaction we got was surprise. We handed it out at the same meetups we’d gone to earlier.

We started seeing people post book reviews on social media. A couple founder friends told us the book changed their agent architecture or their interface design. An engineer turned videographer came to our office and shot a mini-documentary.

People asked us a lot how we’d keep the book up to date. We didn’t really know. Then MCP and Studio Ghibli happened, and we knew we needed to update it.

I sat down in May to write for another weekend. I ended up with another 50 pages. In addition to MCP and image gen, there was a lot of stuff to write about web browsing, workflow streaming, code gen, agentic RAG. We republished the book as the 2nd edition.

The single thing that people comment on the most is a page where I give a partial excerpt from the leaked Bolt.new system prompt. It’s the first time many people have read a production-grade prompt.

The book has become pretty popular recently. We've given out thousands of copies at AI meetups and conferences, and it's even gone viral on LinkedIn (of all places).

In terms of actual mechanics, I wrote the book in Notion, then pasted it into a desktop app called Vellum, which spits out ePubs and PDFs. Amazon’s KDP lets you upload those and publish your book (they’ll print it for you). Having a nice CI/CD helped, as did having docs and blog posts as sort of intermediate artifacts in a content pipeline. It meant that when I was writing I could pull from a warm cache. The process felt O(n) rather than O(n log n).

Enjoy reading, and please let me know what you think! (You probably just want to download the book and read it in your favorite reader, rather than use Github's PDF reader)

I’ll be starting on a third edition soon, and I want to know what topics feel like they’re missing, if anything feels outdated, and so on.

I was inspired by two video I had recently watched to DIY a NAS system.

The first one was Jeff Geerling's video where he sets up a NAS with Radxa Penta SATA HAT & Raspberry Pi 5. The second one is from Micheal Klements in which he makes a nice enclosure for the same setup.

I wanted to push the design a bit further and give some extra capabilities.

My tentative plan is to:

- Add some NAS specific features to the GUI to monitor storage, navigate file system with the GUI,

- open image files & show them on the display, delete files,

- copy/move files around (e.g. from USB drive)

Hardware specific feature to include:

- Build an aluminum enclosure for this eventually,

- Add USB-PD power,

- Internal UPS (Uninterruptible Power Supply), which could potentially power another Pi with a USB Power out option, - Internal 3D printed structure to support the drive and battery pack from sudden movements

This is a work in progress and I have managed to work on the enclosure design and have made the design available here:

https://github.com/ubopod/ubo-mechanical/tree/main/nas-enclo...

The base tray design is also available below:

https://github.com/ubopod/ubo-mechanical/tree/main/bottom_co...

The PCBs are harder to DIY. You need to purchase the Penta SATA HAT and the sideboard. The sideboard is my own open source design and I have a small number available on my indie shop.

Check out the reddit post regarding the sideboard here:

https://www.reddit.com/r/raspberry_pi/comments/1mcn3b8/conne...

I recorded a short video that includes some more details/specifics regarding this design that you can watch below:

https://www.youtube.com/watch?v=0D0EMTMDGSY

Looking for early users: we ship same-day on feature requests and can adapt the tool to your workflow fast. Try it and let us know what’s missing. Happy to make it work for your team. Curious what HN thinks about the UX, install friction, or any must-have features before ditching the daily standup.

I built a minimal, header-only ASCII font renderer for embedded systems and microcontrollers. It requires zero dependencies, supports monochrome and RGB565 displays, and uses an 8×8 pixel ASCII font (chars 32–126).

Useful for low-power devices, debug UIs, console demos, or any resource-constrained environments.

Single header (embedded_ascii.h)

Callback-based & buffer-based rendering

No heap allocation, <800B font footprint

Includes basic text measurement & demo mode

GitHub: https://github.com/Ferki-git-creator/ascii-render

What's up HN! I built a TypeScript Language Service plugin that adds native support for importing .yaml and .yml files with full type inference and autocomplete in TypeScript 5. I made this because I wanted to store LLM prompt templates outside of my source code, but JSON was impractical due to the need to escape every newline and quote, which reduces readability for large texts. I wanted to use YAML, but TypeScript doesn't provide intellisense for YAML files by default. This plugin solves that issue. Happy to hear your feedback or suggestions! The project is open source (MIT) and open to contributions.

PyJig can generate jigsaw puzzle cuts and full sets from an input image you provide.

It is from a puzzle app that I started a while back and shelved. It was stuck in a broken state due to some external dependencies, which I recently cleaned up.

Pretty niche, but maybe someone will find some use for it while I look for the motivation to pick up my original project idea.

My friend and i built this because we were trying to just learn things in a more fun and interactive way. We think there's a community we could build around this? And there's definitely a lot of work to do. Super curious to see what you guys think, and where we can make the learning experience better.

Over the past few months I kept switching between pgvector in production and SQLite-VSS / DuckDB in notebooks. Every swap meant spending time in the syntax land.

Vectorwrap hides those differences behind one tiny Python adaptor: create a collection, upsert, query — then change only the connection string when you switch databases.

Here, I have tried to solve my direct pain point, so curious if this has application beyond my usecase.

What’s inside

Backends: Postgres 16 + pgvector, MySQL 8.2 (Vector Store), SQLite VSS, DuckDB VSS

Same filter dict syntax on every engine (SQLite uses adaptive oversampling internally)

Repo https://github.com/mihirahuja1/vectorwrap

I’d love some feedback on API design, missing edge cases, or reasons you wouldn’t adopt something like this. Thanks for taking a look!

Just upload a panoramic image and this tool splits it into multiple 3:4 1080x1440 parts

Note: It is a fork, the original broke it down into 4:5 (1080x1350) - Older Instagram post size and improved the UI :)

Code is licensed under GNU General Public License v3.0 and is at: github.com/Kuberwastaken/panosplitter

Hey HN,

I’ve been working on a tool called MCPJungle - an open-source, self-hosted MCP Registry + Gateway that helps MCP clients (like Claude, Cursor, custom AI agents) connect to multiple MCP servers through a single endpoint.

MCP (Model Context Protocol) is gaining adoption as a standard for tool-calling in LLMs, but managing multiple servers (auth, tool discovery, ACLs, observability) is still a nightmare - especially across teams in an org.

MCPJungle tries to fix that:

- Expose all your MCP servers behind a single `/mcp` endpoint - Use ACLs to control which clients can view & call which MCP tools - Keep track of all your MCP clients & servers from one central place.

Individuals can run it locally for maximum privacy. Orgs deploy it as a shared gateway for all their AI agents.

It’s written in Go & distributed a single binary. You can run it via Homebrew or Docker. No auth or config needed by default - it’s meant to be friction-less for developers.

Still early, but the current version is stable and being used by a few early devs. Would love to hear feedback, critiques, or ideas. Happy to answer any questions here too.

Thanks!

I have recently added a section for fraction addition, subtraction, multiplication, and division.

Please check it out and let me know what you think. Thank you!

After spending 2-3 hours daily on LinkedIn job searches and missing opportunities due to slow alerts (4+ hour delays), I built a monitoring system that checks frequently and sends instant Telegram notifications.

The key insight: timing matters more than perfect applications. Getting notified quickly after posting vs hours later is the difference between being applicant #5 vs #89.

Setup is dead simple - describe what you want in plain English ("Senior Python dev, fintech, remote OK") and AI handles the filtering. No complex keyword forms.

6+ months of real usage results: - Found current role within 2 hours of posting - 90% reduction in daily search time - Zero irrelevant notifications - Enhanced intelligence: competition data, posting timestamps, repost detection

Tech stack: Python, database layer, Telegram Bot API, AI integration

The system covers major software development roles and has been stable for 6+ months. Made it available for others since it solved a real problem.

Try it: Search "JobsPulseLatestBot" on Telegram

Looking forward to hearing about others' job search automation experiences.

I built Quetty - a fast, terminal-based Azure Service Bus manager in Rust.

Frustrated with switching to Azure Portal for simple queue operations, I wanted something that lives in my terminal. It supports peek/send/receive/delete operations, handles dead letter queues, and runs everywhere including ARM devices.

Tech: Rust + tokio + ratatui

GitHub: https://github.com/dawidpereira/quetty Demo: https://github.com/user-attachments/assets/f52fb894-47a5-428...

I would kindly appreciate all feedback.

Hey Show HN, what started as a small weekend project turned into 2,000 lines of code. I know there are browser plugins and Python scripts out there to turn your ChatGPT archive into something useful. But if you’re looking for an all-in-one solution, this might be interesting for you.

*Sylvio AI* is an intelligent, all-in-one developer companion app that brings together powerful AI tools to streamline software development, content creation, debugging, documentation, and learning—all in one place. Whether you're a solo indie hacker, student, or experienced developer, Sylvio AI helps you ideate, build, and polish your projects faster and smarter with zero setup or cost.

---

## 1. *Who is the App For?*

* *Developers* (from beginners to experienced engineers) * *Students* learning programming and computer science * *Startup founders / indie hackers* * *Technical writers / educators* * *Freelancers / dev content creators* * *Product managers & DevOps professionals* (for planning and documenting)

---

## 2. *What Are Its Benefits?*

* Saves *time* by automating repetitive dev tasks * Helps you *learn* and understand concepts (e.g., regex, errors, snippets) * Boosts *productivity* through centralized tools * Improves *code quality* and project documentation * Simplifies *project planning and communication* * Offers *one-click generation* for common dev tasks like README.md, changelogs, boilerplate, etc. * 100% *free and ready-to-use*

---

## 3. *What Problem Does It Solve, and How?*

### Problem:

Developers constantly jump between ChatGPT, Stack Overflow, GitHub, code snippet sites, name generators, planning boards, and more—fragmented workflows slow down productivity and creativity.

### Solution:

Sylvio AI *centralizes all essential developer tools in one smart platform*, giving you focused, pre-built tools tailored specifically for developer workflows.

Examples:

* Instead of prompting ChatGPT 10 different times, generate a README, app name, changelog, and boilerplate instantly from your project description. * Copy-paste an error message, and Sylvio explains it and offers real-time fixes. * Convert code across languages (e.g., JS → Python) with one click. * Create flashcards and summaries from tech docs to study or teach.

---

## 4. *Why Not Just Use ChatGPT Instead?*

Using ChatGPT is flexible, but:

| ChatGPT | Sylvio AI | | ---------------------------- | ------------------------------------------------------------------------ | | Requires prompting skill | Comes with structured tools/templates | | General-purpose | Built specifically for devs | | No memory or project context | Organizes tools per project | | Manual formatting | Auto-generates docs/boilerplate in clean formats | | No bundling | Combines tools into workflows (e.g., App Planner → README → Boilerplate) |

*Sylvio AI* offers *context-aware*, plug-and-play tools that eliminate the need to engineer prompts or babysit the model—everything is *purpose-built* and fast.

I’ve been working solo on an AI sales outreach agent that handles the entire cold outreach process — from finding leads to writing and sending emails, to following up until there’s a reply.

The problem I wanted to solve: I was spending hours crafting personalized cold emails and still seeing mediocre results. I knew the process could be broken down into repeatable patterns — targeting, messaging, timing — and optimized with data.

What GoAgentic does:

- Finds and qualifies leads based on your criteria - Generates highly personalized emails that don’t read like AI spam - Sends and tracks them with deliverability safeguards - Lets you experiment with messaging and timing to find what works - Stops when there’s a reply (so you only step in when it matters)

Would love feedback from HN on:

- How to make this more valuable for technical founders who hate doing sales - The biggest red flags you see with AI-driven outreach tools - Whether you’d prefer a “set it and forget it” model or more manual control over the AI’s actions

Link: https://www.goagentic.com/ - it's free to try it out!