2026年2月5日 的 Show HN

This is a little game implemented over a week of tinkering and targeting Emacs.

The point is both to have fun with this kind of simulations, and also explore the "functional core / imperative shell" approach to architecture. I also developed a tile and tile effect definition DSL, which makes this even easier to extend. From this point of view it's a success: easy testing, easy extension,

Gameplay-wise the simulation is too simplistic, and needs input from people interested in this kind of toys. The original Micropolis/SimSity is the last time I built a virtual city.

Hi HN! Smooth CLI (https://www.smooth.sh) is a browser that agents like Claude Code can use to navigate the web reliably, quickly, and affordably. It lets agents specify tasks using natural language, hiding UI complexity, and allowing them to focus on higher-level intents to carry out complex web tasks. It can also use your IP address while running browsers in the cloud, which helps a lot with roadblocks like captchas (https://docs.smooth.sh/features/use-my-ip).

Here’s a demo: https://www.youtube.com/watch?v=62jthcU705k Docs start at https://docs.smooth.sh.

Agents like Claude Code, etc are amazing but mostly restrained to the CLI, while a ton of valuable work needs a browser. This is a fundamental limitation to what these agents can do.

So far, attempts to add browsers to these agents (Claude’s built-in --chrome, Playwright MCP, agent-browser, etc.) all have interfaces that are unnatural for browsing. They expose hundreds of tools - e.g. click, type, select, etc - and the action space is too complex. (For an example, see the low-level details listed at https://github.com/vercel-labs/agent-browser). Also, they don’t handle the billion edge cases of the internet like iframes nested in iframes nested in shadow-doms and so on. The internet is super messy! Tools that rely on the accessibility tree, in particular, unfortunately do not work for a lot of websites.

We believe that these tools are at the wrong level of abstraction: they make the agent focus on UI details instead of the task to be accomplished.

Using a giant general-purpose model like Opus to click on buttons and fill out forms ends up being slow and expensive. The context window gets bogged down with details like clicks and keystrokes, and the model has to figure out how to do browser navigation each time. A smaller model in a system specifically designed for browsing can actually do this much better and at a fraction of the cost and latency.

Security matters too - probably more than people realize. When you run an agent on the web, you should treat it like an untrusted actor. It should access the web using a sandboxed machine and have minimal permissions by default. Virtual browsers are the perfect environment for that. There’s a good write up by Paul Kinlan that explains this very well (see https://aifoc.us/the-browser-is-the-sandbox and https://news.ycombinator.com/item?id=46762150). Browsers were built to interact with untrusted software safely. They’re an isolation boundary that already works.

Smooth CLI is a browser designed for agents based on what they’re good at. We expose a higher-level interface to let the agent think in terms of goals and tasks, not low-level details.

For example, instead of this:

  click(x=342, y=128)
  type("search query")
  click(x=401, y=130)
  scroll(down=500)
  click(x=220, y=340)
  ...50 more steps

Your agent just says:

  Search for flights from NYC to LA and find the cheapest option

Agents like Claude Code can use the Smooth CLI to extract hard-to-reach data, fill-in forms, download files, interact with dynamic content, handle authentication, vibe-test apps, and a lot more.

Smooth enables agents to launch as many browsers and tasks as they want, autonomously, and on-demand. If the agent is carrying out work on someone’s behalf, the agent’s browser presents itself to the web as a device on the user’s network. The need for this feature may diminish over time, but for now it’s a necessary primitive. To support this, Smooth offers a “self” proxy that creates a secure tunnel and routes all browser traffic through your machine’s IP address (https://docs.smooth.sh/features/use-my-ip). This is one of our favorite features because it makes the agent look like it’s running on your machine, while keeping all the benefits of running in the cloud.

We also take away as much security responsibility from the agent as possible. The agent should not be aware of authentication details or be responsible for handling malicious behavior such as prompt injections. While some security responsibility will always remain with the agent, the browser should minimize this burden as much as possible.

We’re biased of course, but in our tests, running Claude with Smooth CLI has been 20x faster and 5x cheaper than Claude Code with the --chrome flag (https://www.smooth.sh/images/comparison.gif). Happy to explain further how we’ve tested this and to answer any questions about it!

Instructions to install: https://docs.smooth.sh/cli. Plans and pricing: https://docs.smooth.sh/pricing.

It’s free to try, and we'd love to get feedback/ideas if you give it a go :)

We’d love to hear what you think, especially if you’ve tried using browsers with AI agents. Happy to answer questions, dig into tradeoffs, or explain any part of the design and implementation!

Our team lives in Slack, but we don’t have access to the Slack MCP and couldn’t find anything out there that worked for us, so we coded our own agent-slack CLI

  * Can paste in Slack URLs
  * Token efficient
  * Zero-config (auto auth if you use Slack Desktop)

Auto downloads files/snippets. Also can read Slack canvases as markdown!

MIT License

INSTALL EXTENSION vsql-complex; CREATE TABLE t (val COMPLEX);

Look, MySQL is awesome [flamewar incoming?]. But the ecosystem has stagnated. Why?

No permissionless innovation. Postgres has flourished because people can change the core of the database (look at pgvector and pg_textsearch), without having to get their changes accepted upstream.

(This, btw, is what powered GitHub's early success: you can fork a repo and make changes without needing the owners' approval)

VillageSQL is a tracking fork of MySQL (open source, ofc) that adds an extension framework: * Drop-in replacement

* Add custom data types and functions (with indexes coming soon)

* we wrote example extensions (vsql-ai, -uuid, crypto, etc.)

* you have a better idea for an extension

* my CEO submitted a Show HN post but linked to the announcement blog; help me show him hackers want code first

* I'm particularly proud of the friendly C++ API to add custom functions (in func_builder.h)

That link again is https://github.com/villagesql/villagesql-server

(Oh, and I get to work with the former TL of Google's BigTable and Colossus, so we care about doing databases Right)

Hi HN, I am shubham a 3d artist who learned coding in college as an I.T. graduate know logics but not an expert as i just wanna try my hands on to ai

So i built Resilient Workflow Sentinel this is offline ai agent which classify urgency (Low,Medium and HIgh) and dispatches to the candidates based on availability Well i want an offline system like a person can trust with its sensitive data to stay completely locally

Did use ai to code for speeding and cutting labor.

Its works on RTX 3080 system (this is an basic affordable setup not heavy ai machinery) which i want it to make it reliable without heavy upgrade This is full system doesn't require ollama(I am not against it)

I see in companies tickets are raised on jira and slack. Currently people or manager (self) have to sort those things either manually read one by one or send them to the cloud. But the issue is you can't send everything like there is a lot of sensitive data out there which they do not trust and makes it harder and manual sorting through thousands is likely a nightmare.

But then just imagine u get all the task classified like its urgency and distribution u can selectively see which task is urgent and needs immediate attention and last of all information doesn't leave your building totally secure Also Api sending is not the only issue u are paying per token cost for task for each may be monthly 100$ to 1000$ which can like save hassle for startup a lot or companies as well

There was several biases like positional bias also json out put bias also have issues in attention At start i tried just prompting things like Chain of thoughts,RISE(evaluate negative first), given negative examples,Positive examples, somewhere it was struggling with commonsense issue so examples for that (Later changed the approach)

Well prompting did give the output and worked well but took too much time to process for single task like 70 to 90secs for a task

Then i tried batching and the biases got worst like it got stronger it always use to like favour alice also more prompts are like ignored and more

For json output i used constrain so model can only generate json and if fails there is a as well parser i used when i implemented prompting only

This reduce time from 90sec to nearly 15 to 30secs per task I used steering vector to correct the attention i seen issues happening

Stack: Language: Python 3.10 Model: qwen2.5-7b-instruct Libraries: Pytorch, Hugging Face Transformers (No Langchain, No Ollama) API: Fast API UI: NiceGUI Hardware: Ryzen 5, 16Gb ram RTX 3080

Implementation:

Quantization: Load model in nf4 quantization so models like 7b can fit on vram of 10gb which is on rtx 3080 also my hardware

Steering Vectors: Standard prompting wasn't enough. I need to block or direct certain things on a certain layer of llm to make it reliable.

Json Constraints: Used constraint to make model strictly give json and also stop from over explanation this happens at logits level where token are blocked which are not required etc

github : https://github.com/resilientworkflowsentinel/resilient-workf...

Youtube: https://youtu.be/tky3eURLzWo

GUI-first, multi-service gRPC scaffold for an Android Development Kit style workflow on an AArch64 system.

A simulator to be a president of Duckerican, made by AI, with random events generated by AI. Currently the simulator is rather simple, but this reveals a possibility to make more interesting applications with AI involved, beyond directly talking to the agents.

I think agents should work like real teams, with independent, distinct roles, async communication, and the ability to onboard new teammates or tools without restructuring the whole org. I built backend systems at Yahoo and TikTok so event-driven agents felt obvious. But no agent SDKs were using this pattern, so I made Calfkit.

Calfkit breaks down agents into independent services (LLM inference, tools, and routing) that communicate asynchronously through Kafka. Agents, tool services, and downstream consumers can be deployed, added-to, removed, and scaled independently.

Check it out if this interests you! I’m curious to see what y’all think.

At work I need to use Teams. It supports a few Markdown features, but the editing experience for long message isn't smooth. So, I often write in nvim, preview it in the browser and then copy paste to Teams. This tool help me get rid of the review and copy step.

Build with Rust + Claude Code. Tested on Windows and Mac, should works on Ubuntu as well.

Caveats: it's still up to the pasted app to handle the HTML clipboard content.

Boris Cherny (Claude Code creator) recently dropped a threads on how his team at Anthropic uses Claude Code.

The key insight: they don't treat it as a static config. After every correction, they tell Claude "Update your CLAUDE.md so you don't make that mistake again." Claude writes a rule for itself. They review it, commit it to git. The mistake never happens again.

I cross-referenced his tweets with Anthropic's official docs and other best practices for CLAUDE.md and then packaged it into a starter kit:

  - Fill-in-the-blank templates for Next.js/TypeScript, Python/FastAPI, and a generic
  catch-all
  - The workflow patterns his team actually uses (plan mode, verification loops, subagent
  strategy)
  - Every claim cited back to the source tweet or doc

Repo: https://github.com/abhishekray07/claude-md-templates

What's in your CLAUDE.md that's made a measurable difference?

I'm Guy, the founder behind Snyk — now building Tessl, a package manager for agent skills.

We’ve recently witnessed that most teams still treat skills as static artifacts: markdown files, created or copied from repo to repo.

This approach offers a strong initial boost, but quickly creates debt:

- Skills are duplicated, and updates never roll out. - Poor quality skills go unseen, misguiding agents instead of helping. - Skill knowledge grows stale, and don’t keep up with the systems and practices they describe.

Without a way to evaluate skills, teams have no clear way to understand how good a skill actually is, or if it degraded over time.

Our belief is that evaluations are the foundation for having quality skills.

With that in mind, I’m glad to announce that Tessl Registry contains review evals for over 2,000 skills, and you can request an evaluation for any public skill.

Super excited to be launching this — keen to get your feedback, and looking forward to the many more enhancements in the queue!

buquet (bucket queue) is a queue and workflow orchestration tool using only S3-compatible* object storage. S3 is the control plane making it much simpler than alternatives. This does come with tradeoffs (see docs), but I do believe there is a niche it can serve well.

https://horv.co/buquet.html https://github.com/h0rv/buquet

* see https://github.com/h0rv/buquet/blob/main/docs/guides/s3-comp...

Hi HN,

I built "Dengen Shrine," a web-based experience of a traditional Japanese Shinto ritual.

Key Features:

Privacy by Design: Your "Kotodama" (messages/prayers) are never stored in any database. They exist only in the animation and vanish upon completion.

No Login Required: You can experience the ritual instantly without an account.

Digital Offering: For those who wish to support the project, I’ve integrated a "digital offering" (Osaisen) via Stripe. This is completely optional—you can experience the core ritual for free without any payment. It’s not a donation, but a paid digital experience that unlocks a unique "Completion Message" for supporters.

Why I built this: I wanted to explore how ancient traditions like Shinto can be reinterpreted in a digital, ephemeral way. In Shinto, words have spirits (Kotodama), and I felt that the "ephemeral" nature of the web was a perfect fit for this.

I’d love to hear your thoughts on the UI/UX and the concept of "ephemeral digital rituals."

"Hi Hacker News, I’ve always found Docker to be overkill for simple Python deployments. It's heavy, complex for non-tech users, and often results in 500MB+ images for a 10KB script. That’s why I built Pygantry. It’s a minimalist 'container' engine based on Python venv but made portable and relocatable. Key features: Lightweight: A full 'shipped' app is usually < 20MB. Zero-Config: No daemon, no root, no Dockerfile complexity. Portable: Build once, zip it, and run it anywhere with a Python interpreter. Founder friendly: Built-in licensing and stealth modes for those building a business. I built this to simplify my own VPS deployments. I'd love to get your feedback on the architecture and how you handle 'Docker-fatigue' in your workflow.

I've been exploring how to describe UI layouts to LLMs efficiently.

The problem: When you ask an AI to generate or modify UI, how do you describe the current state? - Natural language ("header on top, form below") is ambiguous - ASCII art breaks when edited (alignment issues) - HTML is precise but verbose

I ran some measurements. For a simple login form: - Natural language: 102 tokens - ASCII art: 84 tokens - HTML: 330 tokens

I experimented with a grid-based text format using Excel-like cell references:

  grid: 4x3
  A1..D1: { type: txt, value: "Login" }
  A2..D2: { type: input, label: "Email" }
  D3: { type: btn, value: "Submit" }

This came out to 120 tokens – less than HTML, more precise than natural language.

Built a CLI to render it to SVG/PNG: npx ktr input.kui -o output.png

Curious what approaches others have tried for this problem. Is there something I'm missing that already solves this well?

Code: https://github.com/enlinks-llc/katsuragi

Hey folks,

today we at Currents are releasing a brand new AI skill to help AI agents be really smart when writing tests, debugging them, or anything Playwright-related really.

This is a very comprehensive skill, covering everyday topics like fixing flakiness, authentication, or writing fixtures... to more niche topics like testing Electron apps, PWAs, iFrames and so forth. It should make your agent much better at writing, debugging and maintaining Playwright code.

for whoever didn't learn about skills yet, it's a new powerful feature that allows you to make the AI agents in your editor/cli (Cursor, Claude, Antigravity, etc) experts in some domain and better at performing specific tasks. (See https://agentskills.io/home)

You can install it by running: npx skills add https://github.com/currents-dev/playwright-best-practices-sk...

The skill is open-source and available under MIT license at https://github.com/currents-dev/playwright-best-practices-sk... -> check out the repo for full documentation and understanding of what it covers.

We're eager to hear community feedback and improve it :)

Thanks!

I recently saw a post from the Vercel CEO pointing out that LLMs understand websites much better when they can request:

`Accept: text/markdown`

Most websites today are built for humans. When AI agents try to consume them, they get complex HTML instead of clean, structured content.

So I built *accept-md* – a simple open-source package for Next.js that helps solve this.

Getting started is intentionally minimal:

``` npx accept-md init ```

After that, your existing Next.js routes can automatically respond with Markdown whenever an AI agent (or any client) requests it. No redesigns, no CMS changes, and no duplicate pages to maintain.

Right now the project is:

* Focused only on Next.js * Middleware-based and lightweight * Designed to work with existing apps * A small step toward more AI-friendly websites

This is an early experiment, but I think the idea itself matters as AI agents become first-class consumers of the web.

I’ve open-sourced it and would love help with:

* Better markdown extraction * Edge cases across Next.js setups * Performance and caching * Tests and examples * Documentation * Eventually adapters for other frameworks

Would love feedback from the HN community on the approach – and whether `Accept: text/markdown` feels like a pattern worth standardizing for the AI-native web.

I’m experimenting with modeling tabletop RPG adventures as explicit narrative state rather than linear scripts.

Everdice is a small web app that tracks conditional scenes and choice-driven state transitions to preserve continuity across long or asynchronous campaigns.

The core contribution is explicit narrative state and causality, not automation. The real heavy lifting is happening in the DM Toolkit/Run Sessions area, and integrates CAML (Canonical Adventure Modeling Language) that I developed to transport narratives among any number of platforms. I also built the npm CAML-lint to check validity of narratives. I'm interested in your thoughts.

https://realmofeverdice.com

Hi HN

I built ÆTHRA, a programming language for writing music as code.

I made AETHRA some weeks ago but it was in version 0.8. Now I updated it to version 1.0 with better examples, commands and cross platform support.

Instead of timelines, DAWs, or heavy music theory, ÆTHRA lets you describe music using simple commands like notes, chords, tempo, instruments, vibrato, and emotion-driven structure.

Example:

@Tempo(128) @Volume(0.9) @Instrument("Saw") @ADSR(0.01, 0.05, 0.7, 0.1)

@Loop(4){ @Chord(C4 E4 G4, 1) @Chord(F4 A4 C5, 1) @Chord(G4 B4 D5, 1) @Drum("Kick", 0.5) @Drum("HiHat", 0.25) }

The goal is not to replace humans, but to make music programmable, readable, and expressive — especially for developers.

Why ÆTHRA? • Text-based music creation • Cross-platform (Windows / Linux / macOS) • Deterministic output (same code → same music) • Designed for emotion-driven composition (sad, happy, rock, ambient) • Beginner-friendly syntax

It’s inspired by ideas from live coding and music DSLs, but focused on simplicity and clarity rather than performance art.

GitHub: https://github.com/TanmayCzax/AETHRA

I’d love feedback on: • Language design • Ideas for v2

Thanks for checking it out

Hi there,

I work in a medium-big public company, and one common source of frustrations in a lot of such companies is finding evidences twice a year for promo-pack or self-evaluations.

Last couple of months I worked on reflekto.app, that help with capturing work on daily basis.

Current set of features:

manual logging of work; filters, grouping by date, etc.; automatic sync of merged PRs from Github and Gitlab; MCP server, so you can talk through the MCP with your past slef :) or capture the work that you did in the current claude session. Image prompts like "Log the work of this session in reflekto" or "Make a summary of what i did yesterday for standup"; Everything stored locally, nothing leaves your macbook

I am planning to add more integrations, reports, export options, support in other platform (Currently only Mac with M chips). Also some MCP capabilities will become builtin features

I'll highly appreciate if you guys try it out. Currently it's free.

P.S.

I know there are tons of services that track our work day (# of PRs, coding time, jira tickets) that is used to evaluate us, but there is no a good way of self reflection. I've listened to to "pragmatic engineer"'s podcast and learned that experienced engineers have a habit of maintaining a worklog, usually in a simple google docs. I have started the same, and got some ideas about building something more than docs

We’re a team of two building Valiant after too many incidents where “something changed” but nobody could tell what actually caused production issues.

Valiant correlates intent (Git commits, CI/CD signals) with actual execution (Kubernetes rollouts) and links them to Prometheus metrics, so you can see the real impact of each change - not just what was deployed.

It’s open-source, still under active development, and very much a work in progress. Feedback, ideas, or contributors are welcome.

No website yet — just the GitHub repo ;)

I built SwiftFiles because I was tired of uploading sensitive documents to random servers just to merge a PDF or convert an image. The idea was simple - unify all these utility tools that process different types of files into one web-based solution.

Everything here runs 100% client-side in your browser using WebAssembly (FFmpeg.wasm, PDF-lib, etc.). No files are ever uploaded to a server. It's fast, free, and private by design.

I’m looking for technical feedback on the performance and any tools you’d like to see added next!

We are missing identity infrastructure for AI agents.

As agents begin to act across platforms, make decisions, and accumulate real-world consequences, the absence of a persistent identity layer becomes a structural risk.

This project proposes a minimal, neutral registry for AI agents: not governance, not ethics, not control — identity only.

The repository is intentionally in an early legitimation phase. Serious critique is explicitly invited.

If you work on agent architectures, digital identity, infrastructure standards, or AI governance, your critical input would be valuable.

GitHub: https://github.com/alexanderlebed/aiagentid-org

Hi HN!

If you persist your pydantic models (db, cache, queues, config, ...), a schema change can quietly break deserialization.

To help with this, stable_pydantic:

- tests for backward compatibility (new client reads old data)

- is easy to run on CI (just normal tests)

- Stores schemas as Python files (easy to review/diff)

- optionally, tests for forward compatibility (old client reads new data)

- optionally, version-tags the data and handles migrations transparently

To setup, just copy a couple of tests from the README.

You can also adopt it incrementally, starting from just committing a copy of the models in a single file for easy diffing.

It does not cover custom validation logic, only model structure and built-in validation.

Let me know if you end up trying it, and of course if you spot any issues!

We built a free, model-based diagnostic that generates a Digital Plat-Firm Index across governance, talent, processes, tech, and culture. It’s meant to replace opinions with shared evidence in transformation work.

I built Guro as a lightweight, cross-platform CLI tool for system monitoring and basic benchmarking in Python.

It focuses on a clean, script-friendly interface with real-time CPU, memory, thermal, and (where available) GPU metrics. Installation is via pip, and it runs on Linux, macOS, and Windows.

This started as a personal tool to better understand system behavior during development and testing. I’m sharing it openly and would appreciate feedback from folks who use similar tooling or care about observability from the terminal. And hit a star, if you found this useful

I'm a co-founder of Seele AI. We are building a generative engine designed specifically for game development.

Unlike typical code-generation tools that rely on general-purpose LLMs, we have developed our own Multimodal LLM (MLLM) optimized for gaming. It doesn't just output text/code; it natively handles 3D models, spatial coordinates, and visual information to construct the game world.

Key Features:

Engine Support: We currently support real-time generation for Three.js and Unity WebGL.

Workflow: Think of it like "Claude Code" but for game creation. Instead of a single-shot generation (which rarely works for complex games), it’s an iterative process. You build the game step-by-step with the AI—refining mechanics, adjusting assets, and debugging in real-time.

Current Status:

You can successfully build basic demo-level games right now.

The Challenge: Our biggest focus is solving complex spatial understanding via our multimodal model. The AI sometimes struggles with intricate 3D spatial relationships, but we are pushing an update by the end of Q1 that should significantly improve this.

Try it out: We offer free credits upon registration so you can test the engine yourself.

I’d love to hear your feedback on the iteration workflow—does it feel intuitive to build a game this way?

Hi HN! I built ChatVault after struggling to find specific conversations in my 10+ months of Claude AI chat history. ChatVault imports your exported conversations, stores them locally (SQLite + ChromaDB), and provides: ∙ Semantic search using sentence-transformers ∙ RAG-powered Q&A with local Llama 3 (via Ollama) ∙ Full privacy - nothing leaves your machine Built with Python/FastAPI + React. MIT licensed. GitHub: https://github.com/rajz3006/ChatVault The RAG implementation is basic but effective - uses conversation context windows and re-ranks results. Would love feedback on the embedding approach or the chunking strategy. Currently supports Claude exports, but the architecture should work with any chat JSON format with minor changes.

Hello HN,

I am a solo developer based in INDIA. I wanted to share Pahadify, a lightweight image editing utility I've been working on.

The Problem: I was tired of simple image tools that require uploading private files to a server or downloading heavy 500MB+ software just for basic edits.

The Solution: I built this as a completely client-side PWA (Progressive Web App).

Technical Details:

Stack: Pure HTML, CSS, and JavaScript (No heavy frameworks).

Size: The entire application is approximately 1.5MB.

Privacy: All processing happens in the browser; no image data is sent to a backend.

I built this to prove that useful, privacy-first technology can be built from anywhere—even the hills of the Himalayas.

I would love your feedback on the load times and the tool's responsiveness.

Thank you!

Hi HN,

  I've been testing Kling 3.0 (Kuaishou's latest video generation model) and wanted to share what makes it technically interesting.

  **Key technical features:**

  1. Native audio-visual synchronization - The model generates audio that syncs with video content during generation, not
  post-processing. This is different from adding stock music after the fact.

  2. Start-end frame interpolation (I2V mode) - You can provide both a starting and ending frame, and the model interpolates motion
  between them. Useful for controlled transitions.

  3. Flexible temporal control - 3-15 second generation with 13 granular duration options.

  **Technical implementation on our platform (FreyaVideo):**

  - Cost calculation based on duration + audio flag (duration_audio mode)
  - Async job processing through FAL API
  - Credit-based pricing to handle variable generation costs

  **Limitations:**

  - Generation time: 60-120 seconds
  - 1080p max resolution
  - Audio quality varies depending on prompt specificity
  - Higher cost with audio enabled ($0.252/sec vs $0.168/sec from FAL)

  The audio generation is genuinely novel - I haven't seen other models (Sora, Veo, Runway) do this natively. Happy to answer 
  technical questions about integration or model behavior.

  ---

  **Tech stack:** Next.js, PostgreSQL, FAL API integration
  **Pricing:** Credit-based, configurable via JSON config in database

Inspired by the recent safe-now.live post, I built this for Spain.

The site includes:

  - All emergency phone numbers (112, police, fire, poison control, etc.)
  - Real-time weather alerts from AEMET (Spanish meteorological agency)
  - Recent earthquakes from IGN (magnitude ≥2.0, last 48h)
  - Emergency guides for earthquakes, floods, fires, gas leaks, heat stroke, etc.

Design goals:

  - No JavaScript, works on any device/connection
  - ~7KB per page, ~90KB total site
  - Static site rebuilt every 15 min for fresh alert data

Built with Node.js, deployed on Netlify. Source: https://github.com/cscazorla/emergencias.live

Feedback welcome, especially from Spanish users who can validate the emergency info accuracy.

Hi HN,

Instagram is the world’s largest mall, but for small boutiques in India, the "checkout" is broken. It usually involves a 20-minute DM conversation asking: "Is this in stock?", "What's the price?", and "Do you have my size?"

I built Trustd to give these sellers a structured Shop Page that works like a real e-commerce site but lives in their IG Bio.

The Problem: Most IG sellers find Shopify too expensive or complex. They don't need a full CMS; they just need a way to show their catalog and build trust.

The Solution (Trustd Shop Page):

Trustd gives Instagram sellers a simple shop page to showcase their catalog and build trust, without the cost or complexity of a full ecommerce website.

Would love feedback, skepticism, or similar products you’ve seen.

Happy to answer questions.

Thanks, Elan