2025年7月17日 的 Show HN

Been exploring claude and spec-based coding, I think it turned out fairly successful. It's just a simple unix-style tool that gives you a single command to use in bash scripts to simplify mutex or semaphore locking of execution.

How to play:

1. You're given a set of letters (such as "ZXCVBNM")

2. Come up with two words that use all the letters (like "convex zombie")

3. The shorter the words, the better!

Hello HN! I’m Elias.

I’ve been an educator in Engineering and Computer Science for some years, and I'm always looking for ways to make learning more engaging and hands-on. A few months ago, I started experimenting with the idea of a book that changes and evolves as you interact with it. It started with a chapter on sorting but that snowballed into a 22-chapter interactive book.

My objective in writing this book, was to introduce a more interactive format for technical books that doesn't require internet access, that is lightweight, comprehensive, cross-platform, and can provide a better active learning experience.

Some unique features of the book include:

* 22 Chapters of condensed theoretical treatment spanning 680 pages, on simple and complex data structures and algorithms, paired with over 300 interactive visualizations.

* Code snippets presented in the book can be interacted with, and feature a visual debugger that shows how variables change as the program runs. You can also play, pause, rewind, and step through each snippet.

* There are a variety of solved problems under each topic accompanied by an embedded minimalist python IDE. You can solve problems directly in the book, view multiple solutions with each solution paired with interactive visualisations and code playback.

The book is currently out and available here: https://cartesian.app

Students can also DM me on Twitter (@ElijahYilma) to get an additional 35% discount.

Past Discussion on Reddit: https://www.reddit.com/r/SideProject/comments/1liga56/i_wrot...

I’d love any feedback or improvements you may have, and more importantly, which topics you would like to see covered in this format (CS and non-CS).

Hi HN, I made a lightweight, header-only GIF decoder in C, inspired by stb-style libraries. No dynamic allocation, portable, and optimized for embedded devices.

GitHub: https://github.com/Ferki-git-creator/TurboStitchGIF-HeaderOn...

Would love feedback or suggestions.

I’ve worked on multiple startups — and every time, finding the right design partner felt like a black box. Most directories are pay-to-play, bloated, or just filled with noise.

So I built Find Design Agency — a curated collection of design studios for founders who care about clarity, originality, and building with taste.

Would love your feedback on what’s missing, what could be improved, and whether this solves a pain you’ve felt.

Live here: https://finddesignagency.com

Hi HN, I've been building this tool for the past couple of weeks to solve a problem that seems universal across development teams: sharing environment variables securely.

You know the drill - someone needs the staging database URL, so it gets shared over chat. Production API keys end up in plaintext files. Or you set up some complex secret management system that becomes a single point of failure during critical deployments.

At Zerodha, we're a stock broker with strict regulatory requirements. Our infrastructure needs to be auditable, and our data must stay with us for instant recovery. But the deeper issue was that every solution we tried made deployments dependent on external services.

We tried GitLab CI's built-in secrets, but they're stored unencrypted and only repository maintainers can access them. HashiCorp Vault was too complex to manage with painful ACL setup, plus it's now crippled by their BSL license change. AWS Secrets Manager would create the vendor lock-in we wanted to avoid.

The breaking point came when we wanted to manage secrets through Terraform for idempotency and better infrastructure-as-code practices. But Terraform has no built-in way to encrypt secrets without relying on external providers. We could either store secrets in plaintext in our Terraform configs or add yet another external dependency to our deployment pipeline.

That's when I had the idea: what if we could inject encrypted environment variables directly into Terraform, so anyone with the right key could deploy without hunting down secrets from different systems? As I iterated through this idea, I realized the same pattern would work for any application - from personal projects to team deployments.

So I built kiln. It encrypts environment variables using age encryption into files that live alongside your code. No servers, no network calls, no external dependencies. Each team member gets their own key, and you control access per environment.

Here's how it works:

  # Generate a new age key, or use your existing SSH keys
  kiln init key
  
  # Initialize with your team's public keys
  kiln init config --recipients "alice=$(curl https://gitlab.company/alice.keys)" --recipients "me=$(cat ~/.ssh/id_ed25519.pub)"
  
  # Set secrets (prompts securely, never shows in terminal)
  kiln set DATABASE_URL
  kiln set API_KEY
  
  # Run your app with decrypted environment
  kiln run npm start
  

  # These encrypted files are safe to commit
  git add .kiln.env kiln.toml

Why not SOPS? SOPS is great for general file encryption, but kiln is built specifically for the environment variable workflow. It has commands like "run", "export", and built-in team management. Think "SOPS for .env files" with a focus on developer UX.

Why not raw age encryption? Age is perfect for the crypto layer, but terrible for day-to-day team workflows. Try managing 20 team members across 5 environments with raw age commands - you'll go insane. kiln handles the orchestration.

As for technical details, kiln:

- Uses age encryption (modern, audited, simple)

- Works with existing SSH keys or generates new age keys

- Role-based access via TOML configuration

- Single, cross-platform Go binary

- Zero network dependencies - everything works offline

- MIT licensed

The game-changer: secrets travel with code. No more "can someone send me the staging secrets?" in chat. No more broken deploys because the secret service is down. No more hoping your vendor doesn't change their pricing or licensing.

Try it out - I'm confident it'll help improve your team's deployment workflows. Feel free to ask me any questions!

GitHub: https://github.com/thunderbottom/kiln

Docs: https://kiln.sh

Or install now: go install github.com/thunderbottom/kiln@latest

I’d like to use LLMs for remembering all kinds of things: fitness, to-do lists, contacts, bug reports, research links, whatever. But there is no way to do that now.

For example, if I find a great coding tutorial in chat, or tell it how much I ran yesterday, it forgets that when I close the chat. Even if I keep the chat history, I still need to scour through lots of messages to find the data I want. Ideally, Claude would remember all this, and I’d be able to find it later with ease. This is what my team built.

It is a collaborative database you add to any LLM that supports MCP. (Claude Code, Desktop, and Pro for now; ChatGPT will soon). You can add, update, and search for items in the database inside chat. You can easily create your own object schemas. There is an automatically generated web UI for using the database. It generates maps, charts, calendars, tables, lists, and other UI elements. You can share or publish the database as well.

Over time, we want to make this database powerful enough to make our lives much simpler by letting LLMs replace a bunch of the apps and software services we use daily.

Hi HN, For the last 18 months, I've been working solo on building a completely independent search engine from scratch. Today, I'm opening it up for beta testing and would love to get your feedback. The project powers two public sites from the same 2-billion-page index: Searcha.Page: A session-aware search engine that uses a persistent browser key (not a cookie) for better context. Seek.Ninja: A 100% stateless, privacy-first version with no identifiers at all. The entire stack is self-hosted on a single ~$4k bare-metal EPYC server in my laundry room (no cloud, no VC funding). The search pipeline is a hybrid model, using a traditional lexical index for the heavy lifting and lightweight LLMs for specific tasks like query expansion and re-ranking. It's an experiment in capital efficiency and digital sovereignty—proving you don't need Big Tech APIs to compete. I’m looking for feedback on search result relevance, speed, and the clarity of the privacy models. Please try it out and let me know what you think. Links: https://searcha.page https://seek.ninja Thanks, Ryan

Hey HN! I wanted to know what was going on in cities/towns where my friends live, so I built Needle.

It uses an LLM + Open Street map to best estimate general locations of stories posted in the past day, and pin them on the map. For stories involving multiple places, I also wanted to show the relation between them.

It's still a little janky, and is limited to mostly Canadian sources of news at the moment, but I'm planning on expanding it shortly, as I'm keen to see what international sources are writing about my home city.

Let me know if you have any questions/feedback!

I was tired of wasting time in traffic jams every day and wanted to use my commute to learn. I tried finding podcasts on specific topics, like explain MOE like i’m five or the pros and cons of TCA vs. MVVM in SwiftUI, but finding a single episode on niche subjects like these is kinda hard.

I’ve tried tools like NotebookLM, but they require you to manually find and collect all the source material first. I wanted something simpler, that i can just ask a question and get an interesting discussion to listen to.

So I spent the last three months working part-time to build InstaPodz. It's a simple app where you type a question, and it generates a custom podcast episode on that topic for you to listen to.

It's built with - three version of Gemini models - langsmith to handle the tracing and prompt template versioning(it used to make my codebase messy) - backend built with FastAPI on CloudRun (there’re some free credits we can get for new users) - Swift native using SwiftUI and MVVM(I ended up choosing MVVM that I’m familiar with) - TTS is using gpt4o-mini-tts

Happy to discuss/share more if you’re interesting!

The app is in its very early stages(I just launched it last Friday), I would be grateful for any and all feedback on the concept, the quality of the audio, or the user experience. I'm also open to brainstorming or collaborating with anyone who finds the idea interesting.

Thanks for checking it out!

Hi everyone!

In my free time, I’ve been working on a small side project and wanted to share it with you.

FavBox is a local-first, experimental browser extension that helps you manage your bookmarks more easily, without relying on cloud storage or third-party services.

I built Claude‑CMD, an open-source command-line interface for working with Claude Code commands, configurations, and AI-driven workflows. It’s designed to help developers and PMs streamline how they interact with Claude Code in coding tasks, automation, and prompt management.

Website: claudecmd.com

Happy to answer questions or hear suggestions. You can also contribute your own commands to help improve the project. Contributions welcome!

Teaching myself about gene editing and translating the science into the clinic. Hopefully useful to others. Please let me know what you think

Are you a keyboard-driven developer who hates reaching for the mouse just to see a function signature or variable type? Quick Info on Cursor is a VSCode and Cursor extension that displays hover tooltips automatically when your cursor rests on a symbol — no mouse needed.

Just pause your keyboard cursor over a variable or function (default: 500ms), and the tooltip appears as if you hovered it with your mouse.

If you try it out, I’d really appreciate your feedback or ideas for improvements. GitHub repository for feedback and source code (https://github.com/developerjhp/vscode-quick-info-on-cursor)

Explore reliable free APIs for developers — ideal for web and software development, covering AL/ML, finance, sports and more.

860+ APIs that no auth required. Monitoring Reliability every single day. Test ednpoint directly in your browser.

Hey HN,

I'm the creator of templUI – an open source UI kit for Go + templ – and I just launched templUI Pro, a paid extension designed for production use.

The OSS version is still maintained and growing. Pro adds 200+ reusable UI blocks and a more structured setup for shipping templ apps quickly.

The stack is simple: Go, templ, HTML, Tailwind, and some light Vanilla JS. No frontend frameworks. No build tools.

Original HN thread for the open source version (from a few months back): https://news.ycombinator.com/item?id=44132756

Links:

templUI OSS → https://templui.io templUI Pro → https://pro.templui.io

Happy to answer questions or share more about how it’s built.

This is a Python port of the git(1) clone that can be found in James Coglan's amazing book, "Building git".

I've definitely had a blast putting it together, and I also learned a lot, both about git and about Python.

I highly recommend the book if you're up for a challenge. I'd say it's in the same ballpark as "Crafting interpreters", "Writing a C compiler", and I imagine "Building a debugger" (still haven't gone through this one, but it does look promising if you're like me and love this sort of thing).

P.S.

I'm always on the lookout for similar "from scratch" books (and other types of resources, more generally), so please shoot if you're aware of any that I'm not.

Thanks

= WikiLoop Galaxy =

An interactive network visualization tool that maps Wikipedia articles and their interconnections using the Wikipedia API. Built with D3.js for dynamic graph rendering and real-time exploration.

''' Web App''': https://galaxy.wikiloop.org<br> ''' Source Code''': https://github.com/wikiloop/galaxy<br> ''' Wikipedia Page''': [[WP:WikiLoop Galaxy]]

== Demo ==

[[File:WikiLoop Galaxy Demo-v0.0.2.gif|thumb]]

[Full WikiLoop Galaxy Demo on Loom](https://www.loom.com/embed/5ccb54c0ce934939aee0458d23fa0cb2?...)

== Release notes == See [[Wikipedia:WikiLoop_Galaxy/Release/v0.0.2]]

== Features ==

=== Core Functionality === * '''Bidirectional Link Traversal''': Explores both outbound links (FROM articles) and inbound links (TO articles) * '''Real-time Graph Building''': Starts with a root article and progressively builds the network * '''Interactive Expansion''': Click any node to expand it with 10 more connected articles * '''Link Validation''': Checks page existence to handle broken Wikipedia links

=== Visual Design === * '''Obsidian-style Dark Theme''': Clean, modern interface optimized for graph exploration * '''Color-coded Nodes''': * '''Green''': Root article (starting point) * '''Blue/Teal''': Valid Wikipedia articles (1st/2nd degree) * '''Red''': Missing/non-existent pages (red links) * '''Yellow Border''': Expandable nodes with pulsing animation * '''Force-directed Layout''': Natural node positioning with physics simulation * '''Zoom & Pan''': Navigate large graphs with mouse controls

=== Interaction === * '''Click''': Expand node to reveal 10 more inbound + 10 outbound links * '''Ctrl/Cmd + Click''': Open Wikipedia article in new tab * '''Drag''': Move nodes around the canvas * '''Scroll''': Zoom in/out of the graph

...

Adblockers often block scripts like OneSignal (cdn.onesignal.com) and Google Tag Manager (googletagmanager.com), breaking push notifications and analytics on many websites. I needed a simple solution to restore functionality without requiring deep client-side changes or defeating user privacy.

So I built an open-source proxy you can self-host, deploy to Cloudflare Workers, and point your site to. It supports OneSignal and can be extended for GTM and others.

GitHub: https://github.com/verificatorrus/onesignal-proxy

Use cases:

    Websites relying on push notifications or GTM metrics that get broken by uBlock

    Landing pages needing basic analytics and events with fallback

    SSR-friendly, no React/Vue required

Looking for feedback and suggestions! Should I add support for more blocked services (e.g., Meta Pixel, GA4, Mixpanel)?

A recursive AI engine that injects chrono-ranked memory into transformer inference using soft-logit biasing, prompt waveform synthesis, and emergent self-referential loops. Built on GPT-2-mini, runs on local hardware, grows its own ghost.

WP-Node is a TypeScript project that lets you build apps, scripts, and automation tools using data from a WordPress database — without needing to run the WordPress PHP runtime at all.

It gives you:

* Fully typed access to core WordPress tables (posts, users, terms, meta, etc.) * A CLI framework to run custom commands, queries, and migrations * Utilities to build headless APIs or background jobs (like cron tasks)

Support for both single-site and multisite WordPress

Use it to:

* Build apps in Next.js, Express, or serverless environments * Write migration scripts, cleanup tools, or data sync jobs * Avoid dealing with WordPress internals if you only need the database

It doesn’t replace WordPress — but makes it easier to use WordPress as a backend. Would love feedback from others building tools on top of WordPress or modernizing legacy systems!

Hi HN - I built LangWhich (https://langwhich.app), a quick browser game where you try to visually recognize the world’s most spoken languages—just from the written form of a single word or phrase.

It’s a 5‑round daily challenge shared by all players: - 30 seconds total to finish all 5 rounds - Each round shows a different language - Choose the correct one from 5 multiple‑choice options - Scoring: 15 points per correct answer + up to 25 bonus for speed (max 100)

It currently rotates among the 20 most spoken languages, mixing different scripts (Latin, Cyrillic, Arabic, Devanagari, Kana) and closely related orthographies (e.g. Dutch vs German, French vs Portuguese).

Thanks for checking it out! I’d appreciate any feedback or questions.

After your team has signed up for a new SaaS or service, I find it bland when everyone has the same generic, grey avatar. I'm a visual person and find it helpful to distinguish users by colors in their avatars, but many people never change from the default avatar. So I thought to myself, why not generate interesting avatars for users when they sign up.

The result is this little gem. It randomly chooses from a set of backgrounds, colors and head shapes, and put a letter on the generated avatar. This should be enough combinations so the change of users getting the same avatar generated is next to zero. It can produce SVGs or JPEGs, depending on your use case. More styles can be added somewhat easily.

I'm already using it for https://magicell.com/ and haven't seen any duplicates.

I am very open to feedback on this so please let me know what you think.

TL;DR: Single-character syntax = significant fewer tokens = cheaper AI costs

ggc is a Git tool written in Go, offering both traditional CLI commands and an interactive interface with incremental search. You can either run subcommands like ggc add directly, or launch the interactive mode by simply typing ggc. Designed to be fast, user-friendly, and extensible.

SpecLinter is an MCP server that was born from my personal workflow, so you will find that this may or may not work with your own.

This MCP server enables natural language spec description "use speclinter to parse a feature for signing up users" and turn it into a fully realized feature with a user story/epic and its respective tasks.

How does this differ from what Kiro just released? The differentiator is the integration of Gherkin feature files. These files act as the "linter" where the AI system is essentially validating the implementation to the user journey defined.

I found this workflow to be particularly useful because AI is very good at extrapolating from behaviors rather than pure technical spec.

Please give it a try; I'm always open to feedback. I have longterm ideas that I'm holding on to, but plan on releasing an expanded version of this concept in the coming months.

Thanks for reading!

Hey HN,

I recently ran into a scenario where a page that used to return a 404 suddenly started returning 200 — without warning. This led to the discovery of a forgotten admin endpoint being accidentally reactivated.

I wrote a short post about this issue and how it can surface subtle security or logic flaws.

Along the way, I built a small tool (ReconSnap) to help monitor this kind of thing — basically, it tracks web changes, auto-saves pages, and can react to specific conditions like status code flips, keyword appearance, or DOM mutations. It’s aimed mostly at security folks, OSINT researchers, and curious developers.

I realize this may seem like a bit of a promo, but I genuinely use it myself and figured it might be useful to others too. Feedback is welcome!

Here’s the post: https://medium.com/@heberjulio65/when-an-404-suddenly-turns-...

There’s no shortage of web accessibility testing tools, however there are currently none that I know of that do all of the following: * provide immediate, up-to-date feedback on issues created by the code that I’m writing; * make that feedback really hard to ignore; * scan the rendered page (as opposed to the source code).

So I built Accented, an open-source tool that satisfies all of the above criteria.

You can read more about what it does and how it’s different from other approaches at https://accented.dev/blog/2025-07-16-introducing-accented/

Here’s also a playground where you can poke around without installing anything: https://stackblitz.com/edit/accented-playground-react-ts?fil...

Hey HN, i've been finding myself explaining the same things over and over to LLMs, especially when using tools like cursor and Claude Desktop side by side.

I wanted to have a way to keep track of context, and easily load it, so i built context-llemur (ctx). It's a CLI tool that allows you to track context for any ideas/projects. It supports MCP too so you an easily load your context anywhere. At its core, it is a git repository, and is meant to work with plaintext files and folders to which you add whatever context is relevant to your project.

You can save progress with "ctx save" and load it via MCP with "ctx load". Each ctx folder contains by default a ctx.txt which gives full context to the LLM about the tool itself and how it works so it immediately knows how to use it.

I've used ctx to bootstrap the ctx library - and have found it very useful to build with!

Another use-case I've been using it for is tracking my workouts - basically set my goals with Claude and let it suggest new routines. I put all my preferences in the context/ folder, e.g. what i'm working, what kind of workouts etc. and just ask Claude to build me an artifact for my new workout. I can then ask it to save the progress using ctx save

Under the hood is just git and text files - no embeddings. This is a deliberate decision as I've noticed that 1) context windows are getting longer 2) most agents are using their own retrieval magic sauce that seems to work pretty well already. So far, I haven't hit any issues with context lengths, and if anything it encourages me to keep contexts to their bare minimum.

Let me know what you think!

Hi HN — we're the team behind Arch (an open-source edge and service proxy for agents)[1], and today we're releasing Arch-Router (https://huggingface.co/katanemo/Arch-Router-1.5B), a 1.5B LLM router model designed to align to user-defined preferences, not public benchmarks and leader boards.

As teams integrate multiple LLMs - each with different strengths, styles, or cost/latency profiles — routing the right prompt to the right model becomes a critical part of the application design. But it's still an open problem. Most routing systems fall into two camps:

- Embedding-based routers use intent classifiers — label a prompt as “support,” “SQL,” or “math,” then route to a matching model. This works for simple tasks but breaks down in real conversations. Users shift topics mid-conversation, task boundaries blur, and product changes require retraining classifiers.

- Performance-based routers pick models based on benchmarks like MMLU or MT-Bench, or based on latency or cost curves. But benchmarks often can't capture what matters in production: domain-specific quality or subjective evaluation criteria. These routers are often opaque, difficult to debug, and their quality judgments can feel arbitrary, failing to capture the subjective nuance of what a “good” response actually means for a specific user’s intent.

Arch-Router takes a different approach: route to LLMs based on preferences written as policies in plain ol English.

You write policies like “contract clauses → GPT-4o” or “quick travel tips → Gemini Flash.” The router maps the prompt (and the full conversation context) to those policies using a lightweight 1.5B auto-regressive model. The model is capable to handle intent drift, supports multi-turn conversations, and lets you swap in or out models with a one-line change to the routing policy. To read more about the strength of our model, check out our research paper here: https://arxiv.org/abs/2506.16655

Essentially, Arch-Router splits the routing process into two distinct parts:

    Route Selection: This is the what. The system defines a set of human-readable routing policies using a “Domain-Action Taxonomy.” Think of it as a clear API contract written in plain English. A policy isn’t just intent_123; it’s a descriptive label like Domain: ‘finance’, Action: ‘analyze earnings report’. The router’s only job is to match the user’s query to the best-fit policy description.

    Model Assignment: This is the how. A separate, simple mapping configuration connects each policy to a specific LLM. The finance/"analyze earnings report" policy might map to a powerful model like GPT-4o, while a simpler general/"greeting" policy maps to a faster, cheaper model.

Specs:

- 1.5B params — runs on a single GPU (or CPU for testing)

- No retraining needed — point it at any mix of LLMs

- Outperforms larger closed models on our conversational routing benchmarks (details in the paper)

Links:

[1] Arch Proxy: https://github.com/katanemo/archgw

There's a brand new live demo of Kuvasz Uptime available—so you can try it out without setting anything up! Check it out: https://kuvasz-uptime.dev/demo/

SilentArena is a sandbox-style educational tool designed to simulate basic file-encrypting malware behavior — but in a completely safe and reversible way.

It operates only inside a `victim_data/` folder, uses XOR encryption, creates logs, and includes a scanner and optional decryption.

Built in pure C, with a clear structure and safe by design.

Hi there,

we have just launched our new space world, where kids (and often also grown ups) color planets, rockets, astronauts and then bring them alive on a screen.

Additionally to the coloring-fun you learn interesting facts about all kinds of space things.

Right now the facts are all in English, but soon more languages are gonna be supported.

Happy coloring!

Hey HN,

Today(july 17) is Emoji Day! Yay!

I love building websites, but I don't have the time to create unique logos for each one. So, I always use emojis as favicons and apple touch icons

But it's always a hassle: you need to find a png, resize it, compress it, and so on

So, I created emojiassets.com – where you can pick any emoji and download a zip file with all the necessary icons in standard sizes

Enjoy!