Show stories

I’ve just released VectorNest — an open-source, browser-based SVG editor.

If you have an SVG and need quick edits (paths, alignment, small fixes, animations, LLM assistance) without installing software, this is for you.

Try the demo: https://ekrsulov.github.io/vectornest/ GitHub repo: https://github.com/ekrsulov/vectornest

Feedback, issues and contributions are welcome.

The article discusses the Axiom space station, a private commercial space station that is being developed to provide research and commercial opportunities in low-Earth orbit. It highlights the potential of the Axiom station to support scientific experiments, manufacturing, and space tourism.

Hi HN, After roughly 8 years of silently rolling 1.1 nightlies, we finally tagged a proper stable 2.0 release. We built this because wrist-sized Linux is genuinely fun to hack on, and because a handful of us think it's worth keeping capable hardware alive long after manufacturers move on. Smartwatches don't really get old — the silicon is basically the same as it was a decade ago. We just keep making it useful for us.

No usage stats, no tracking, no illusions of mass adoption. The only real signal we get is the occasional person who appears in our Matrix chat going "hey, it booted on my watch from 2014 and now it's usable again" — and that's plenty.

Privacy is non-negotiable: zero telemetry, no cloud, full local control. Longevity is the other half: we refuse to let good hardware become e-waste just because support ended. On the learning side, it's been one of the best playgrounds: instant feedback on your wrist makes QML/Qt, JavaScript watchfaces and embedded Linux feel tangible. The community is small and kind — perfect for people who want to learn open-source dev without gatekeeping.

Technically we're still pragmatic: libhybris + older kernels on most devices since it just works, but we've already mainlined rinato (Samsung Gear 2) and sparrow (ASUS ZenWatch 2) — rinato even boots with a usable UI. That's the direction we're pushing toward.

Repo: https://github.com/AsteroidOS Install images & docs: https://asteroidos.org 2.0 demo video : https://www.youtube.com/watch?v=U6FiQz0yACc Announcement post: https://asteroidos.org/news/2-0-release/

Questions, port requests, mentoring offers, criticism, weird ideas — all welcome. We do this because shaping a tiny, open wearable UX and infrastructure is oddly satisfying, and because Linux on the wrist still feels like a playground worth playing in.

Cheers, the AsteroidOS Team

Howdy, Open Notes co-founder here!

At Open Notes, we're building a system for community-driven constructive moderation and annotation that can be added to anything. Under the hood, we're using the open-source Twitter/X Community Notes algorithm (though that doesn't really kick in until you've got some scale). We're interested in providing everyone with tools for managing discourse that go beyond traditional moderation. Discord is the demo/reference integration, but we want it go anywhere and everywhere. Part of our thesis is that we want to get to where people are already talking rather than drag them to a clean and empty new room where we ask them to continue the conversation.

It's interesting that Pol.is was just recently on HN (https://news.ycombinator.com/item?id=46992815) because we're obviously inspired by them as well as the whole canon of social choice theory--we're just going at it from a different angle. It's long been true that if you wanted to trap me/yourself in a conversation, you could just bring up the Condorcet criterion (amongst others), so I'm finally turning an obsession into an actual product.

We want to enable people to make decisions about conversations as close to the conversation as possible while minimizing impact on live threads. Later, this nicely extends into all sorts of group decisionmaking. As our conversations are increasingly awash in AI of all sorts (as moderators, participants, analysts, etc.), things that help manage the discourse to fit the needs of individual communities need to be scalable but without drowning human choice in an ocean of automation.

Also, we're open-source: https://github.com/opennotes-ai/opennotes

Would love to hear people's thoughts and reactions. This has so much surface area ("all online discourse"), it's hard to formulate specific questions so instead we built a thing and now we'd love to see if it works for folks.

I've built Lite Network Scanner, an open-source Python tool with a TUI (terminal interface) for LAN discovery, custom IP scanning, and port auditing.

Its designed for ethical diagnostics and security testing.

Cross-platform: Works on Windows, Linux, and macOS.

Hi HN!

I built Opaal because writing multi-agent orchestration prompts was becoming tedious and error-prone. Every time I wanted to coordinate 3-5 AI agents on a complex task, I would spend 20+ minutes crafting the prompt by hand.

Opaal (Orchestration Prompts for Agentic AI Launch) lets you design these workflows visually instead. You drag agent cards onto a canvas, organize them into phases (columns), draw connections between them, and the app generates a production-ready prompt automatically. The prompt updates live as you build.

Built with Electron + React + React Flow + Zustand + Tailwind CSS v4.

Key features: - 15 agent roles (Researcher, Architect, Developer, Reviewer, etc.) - Smart auto-connections between adjacent phases - Manual wiring for custom data flow - 3 starter templates (Code Review, Feature Build, Bug Fix) - Auto-detects installed Claude Code skills - Save/load .opaal files, export to CLAUDE.md - Full keyboard shortcuts, undo/redo, multi-select

MIT licensed. Would love feedback on what features would make this more useful for your workflows.

I built PolyMCP, a framework and runtime for exposing Python functions as MCP tools, serving them via standardized MCP servers, and orchestrating them with autonomous agents that can plan and execute multi‑step workflows.

PolyMCP is more than just an MCP server: it turns existing Python code into agent‑ready tools and gives agents the ability to discover, compose, and orchestrate across multiple services with adaptive planning and real‑world execution support.

Key parts of the ecosystem:

1) Expose Python functions as MCP tools Use existing Python functions directly as MCP tools without rewriting them:

from polymcp.polymcp_toolkit import expose_tools_http

def add(a: int, b: int) -> int: return a + b

app = expose_tools_http([add], title="Math Tools")

Type hints automatically generate structured tool schemas, and input/output validation and error handling are included. Multiple functions can be exposed on the same server.

2) Autonomous agent: PolyClaw PolyClaw goes beyond tool calling. It: • Decomposes complex tasks into executable steps • Selects and orchestrates MCP tools dynamically • Starts or connects to MCP servers on demand • Validates outputs before proceeding • Adapts plans when execution fails • Runs everything in isolated Docker containers

Example run:

polymcp agent run \ --type polyclaw \ --query "Build a sales reporting pipeline and test it end‑to‑end" \ --model minimax‑m2.5:cloud \ --verbose

Under the hood, the system plans, provisions infrastructure as needed, executes steps sequentially or in parallel, and handles adaptive replanning when something fails.

Why this matters

Most AI agent systems today either call tools statically or assume the infrastructure already exists. PolyMCP instead: • Makes existing Python code agent‑ready with minimal friction • Standardizes tools via MCP so multiple agents and services can interact with them • Provides autonomous orchestration across multiple services • Spins up infrastructure dynamically when needed • Validates step results and recovers from failures • Uses Docker for safe, isolated execution

PolyMCP is useful for enterprise automation, DevOps workflows, data pipelines, internal tooling orchestration, and any complex multi‑tool reasoning tasks where agents must plan and execute reliably.

Repo: https://github.com/poly‑mcp/PolyMCP

Happy to answer questions.

Hey HN, we built a set of production-ready AI agent templates with x402 micropayments baked in.

The problem: agents that need multiple APIs face signup/KYC/key-management overhead that doesn’t scale. x402 replaces all of that with HTTP-native payments.

Currently supporting USDC on Base, more integrations soon.

The kit includes 5 agent templates (web scraper, image gen, search, translation, code review). Clone, configure a wallet, run. 93 tests passing. Built on Coinbase Developer Platform.

This is the first project from our “1 app per week” studio experiment.

Repo: https://gitlab.com/artificial-lab/x402-agent-starter Docs: https://x402-kit.vercel.app Protocol: https://x402.org

Would love feedback on the architecture and the agent templates. What x402 use cases would you want to see next?

Hey HN! I’m Simone. We re-built Breadboard, a visual app builder that mixes Figma-style UI design with Shortcuts-style logic so you can build, preview, and publish interactive web apps directly from the canvas.

What it does

    Design UIs visually with a flexible canvas –like Figma–.
    Define app logic with a visual, instruction-stacked editor inspired by Shortcuts.
    Live preview apps directly on the canvas –no separate preview window–.
    Publish working web apps with one click.

    Modernize the HyperCard idea: combine layout, behavior, and instant sharing in one place.
    Reduce friction between design and a working app.
    Make simple web apps approachable for non-developers while keeping power features for developers.
    Build a foundation for LLM integration so users can design and develop with AI while still understanding what’s happening, even without coding experience –in progress!–.

Weather forecast app: https://app.breadboards.io/playgrounds/weather

Swiss Public Transit: https://app.breadboards.io/playgrounds/public_transit

info: https://breadboards.io

I would appreciate any feedback :)

The article explores the growing importance of AI skills in the modern job market, highlighting the need for individuals to develop these capabilities to remain competitive and adaptable in a rapidly changing technological landscape.

Bubble sort is pretty simple in most programming languages ... what about on a Turing Machine? I used all three of Claude 4.6, GLM 5, and GPT 5.2 to get a result, so this exercise was not quite trivial, at least at this time. The resulting machine, bubble_sort_unary.yaml, will take this input:

111011011111110101111101111

and give this output:

101101110111101111101111111

I.e., it's sorting the array [3,2,7,1,5,4]. The machine has 31 states and requires 1424 steps before it comes to a halt. It also introduces two extra symbols onto the tape, 'A' and 'B'. (You could argue that 0 is also an extra symbol because turinmachine.io uses blank, ' ', as well).

When I started writing the code the LLM (Claude) balked at using unary numbers and so we implemented bubble_sort.yaml which uses the tape symbols '1', '2', '3', '4', '5', '6', '7'. This machine has fewer states, 25, and requires only 63 steps to perform the sort. So it's easier to watch it work, though it's not as generalized as the other TM.

Some comments about how the 31 states of bubbles_sort_unary.yaml operate:

  | Group | Count | Purpose |
  |---|---|---|
  | `seek_delim_{clean,dirty}` | 2 | Pass entry: scan right to the next `0` delimiter between adjacent numbers. |
  | `cmpR_*`, `cmpL_*`, `cmpL_ret_*`, `cmpL_fwd_*` | 8 | Comparison: alternately mark units in the right (`B`) and left (`A`) numbers to compare their sizes. |
  | `chk_excess_*`, `scan_excess_*`, `mark_all_X_*` | 6 | Excess check: right number exhausted — see if unmarked `1`s remain on the left (meaning L > R, swap needed). |
  | `swap_*` | 7 | Swap: bubble each `X`-marked excess unit rightward across the `0` delimiter. |
  | `restore_\*` | 6 | Restore: convert `A`, `B`, `X` marks back to `1`s, then advance to the next pair. |
  | `rewind` / `done` | 2 | Rewind to start after a dirty pass, or halt. |

I'm curious if anyone can suggest refinements or further ideas. And please send pull requests if you're so inclined. My development path: I started by writing a pretty simple INITIAL_IDEAS.md, which got updated somewhat, then the LLM created a SPECIFICATION.md. For the bubble_sort_unary.yaml TM I had to get the LLMs to build a SPEC_UNARY.md because too much context was confusing them. I made 21 commits throughout the project and worked for about 6 hours (I was able to multi-task, so it wasn't 6 hours of hard effort). I spent about $14 on tokens via Zed and asked some questions via t3.chat ($8/month plan).

A final question: What open source license is good for these types of mini-projects? I took the path of least resistance and used MIT, but I observe that turingmachine.io uses BSD 3-Clause. I've heard of "MIT with Commons Clause;" what's the landscape surrounding these kind of license questions nowadays?

Hey HN! I wanted to show this tiny JRPG style hardware companion I built that shows what your Claude Code is doing. When Claude runs a tool, Clawy runs. When it's done, Clawy jumps up in joy. Shake the device and Clawy gets dazed! When Claude needs permission to run something, it shows the command and context like a video game quest scrolling text on screen and you can approve/deny with physical buttons.

He runs on a $20 M5StickC Plus 2. Flashing takes 2 minutes from the browser at clawy.lol/flash, no Arduino IDE needed. It uses Claude Code's native hook system over local WiFi and nothing leaves your network.

I built this as a prototype for myself because I wanted to keep track of my sessions while looking at other things in and around the house and not wanting to use terminus. So thought it would be a fun thing to make as an experiment. When I got some nice reactions on it I thought I'd make it available for everyone. It's rough around the edges but it works. The repo is here: https://github.com/marcvermeeren/clawy if you want to try it out!

The Sentinelgate article discusses a cybersecurity vulnerability that allows unauthorized access to sensitive data and systems. It provides technical details on the vulnerability, its impact, and steps being taken to address the issue.

The book page links to a blog post that explains how I got about it (and has a link to sample content), but the TL&DR is that I could not find a lot of books that were on "our" history _and_ were larded with technical details. So I set about writing one, and some five years later I'm happy to share the result. I think it's one of the few "computer history" books that has tons of code, but correct me if I'm wrong (I wrote this both to tell a story and to learn :-)).

My favorite languages are Smalltalk and Lisp, but as an Emacs user, I've been using the latter for much longer and for my current projects, Common Lisp is a better fit, so I call myself "a Lisp-er" these days. If people like what I did, I do have plans to write some more (but probably only after I retire, writing next to a full-time job is heard). Maybe on Smalltalk, maybe on computer networks - two topics close to my heart.

And a shout-out to Dick Gabriel, he contributed some great personal memories about the man who started it all, John McCarthy.

My friends and I built Owoa to solve a specific problem in digital rights management: the "analog hole."

Traditional steganography and watermarking usually rely on LSB (Least Significant Bit) modifications or fragile metadata. These methods are instantly defeated the moment a user takes a physical photo of their monitor with a smartphone. The moiré patterns, sensor noise, and lens distortion destroy the digital signal.

Instead of hiding data in pixels, Owoa uses generative AI to create unique variants of an image by subtly modifying background elements (textures, foliage, unstructured patterns).

Because the "data" is now part of the actual visual composition of the image, it is much more robust. In our testing, the attribution survives:

Heavy JPEG compression and resizing.

Aggressive cropping.

Physical photos of 1080p/4K screens taken with mid-range smartphones.

We've just launched a Owoa Playground and are looking for technical feedback on the robustness of this approach compared to traditional robust watermarking.

We're giving 10 free credits to anyone who joins the waitlist to test the engine. I'd love to hear how you'd try to break this.

Link: https://owoa.app/

I’ve created Nedagram that I think it's ready but needs extensive testing before announcing it: https://nedagram.com

## Problem statement:

- during Iran internet shutdown, the government cut off phone lines and mobiles (no text or calls). Gradually they opened up landlines and then phones, but still texting/SMS was down with no real internet.

- There were still ways to connect through proxies, vpns, DNS tunnels, etc. However, people had no way to send each other VPN config files or proxy urls/passwords/etc (they needed to call and read them over the phone)

## Solution: - TLdr; A modem: a way to transfer text (e.g VPN config) over phone calls

Here's the github issue for community testings, Please try and let me know what you think: https://github.com/shayanb/Nedagram/issues/5

p.s. there is a CLI version too, would be cool to see what people would do with it: https://www.npmjs.com/package/nedagram

Refine.tools is a powerful web application that helps developers streamline their data transformation and cleaning workflows. It offers a user-friendly interface, advanced data manipulation features, and seamless integration with popular data sources and formats.

Throughout my career, I tried many tools to query PostgreSQL, and in the end, concluded that for what I do, the simplest is almost always the best: raw SQL queries.

Until now, I typed the results manually and relied on tests to catch problems. While this is OK in e.g., GoLang, it is quite annoying in TypeScript. First, because of the more powerful type system (it's easier to guess that updated_at is a date than it is to guess whether it's nullable or not), second, because of idiosyncrasies (INT4s are deserialised as JS numbers, but INT8s are deserialised as strings).

So I wrote pg-typesafe, with the goal of it being the less burdensome: you call queries exactly the same way as you would call node-pg, and they are fully typed.

It's very new, but I'm already using it in a large-ish project, where it found several bugs and footguns, and also allowed me to remove many manual type definitions.

Sunny Flight is a leading provider of private jet charter services, offering tailored travel experiences for individuals and businesses. The company's focus is on delivering exceptional customer service, safety, and reliability for a wide range of private aviation needs.

Mantis is an open-source project that provides a modular and extensible framework for building real-time applications. It offers features such as message queuing, pubsub, and WebSocket support, making it a versatile tool for developing scalable and responsive web applications.

I've been teaching LLMs to play Magic: The Gathering recently, via MCP tools hooked up to the open-source XMage codebase. It's still pretty buggy and I think there's significant room for existing models to get better at it via tooling improvements, but it pretty much works today. The ratings for expensive frontier models are artificially low right now because I've been focusing on cheaper models until I work out the bugs, so they don't have a lot of games in the system.

Hey HN,

I’m a dev and a dad to a 10-year-old. I built this because I caught my daughter using ChatGPT to do her history homework. She wasn't learning; she was just acting as a "middleware" between the AI and the paper.

The Backstory: I realized the problem isn't the AI—it's the zero-friction answers. Most "AI for kids" apps are just "parrots"—they mimic intelligence by repeating patterns.

What’s Different: Qurio is a "Bicycle" for the mind. It treats the child like a future "Architect" rather than a "Junior Executor." Technically, it wraps an LLM in a strict "Socratic Loop." It detects intent to "cheat," refuses the direct answer, and generates a leading question based on the user's current logic level. It forces "Healthy Friction" back into the learning process.

The stack: Next.js 14, Supabase (Auth/DB), Vercel AI SDK.

Mods: I've added the backstory and differentiator as requested. Ready for the re-up! Thank you.

Atomic Habits Calendar is a tool designed to help users build and track their daily habits. It provides a customizable calendar interface to visualize progress and stay motivated in developing long-term lifestyle changes.

Fun little side project I built after learning about circuit bending in cameras for intentional glitch effect. It is browser based camera toy where you "rewire" CCD pin pairs, turn knobs to get different glitch artefacts in real time to capture as photos. I had fun learning to simulate different pin modes - channel split, hue/phase shifts, horizontal clock delays, colour kill etc.

Here are some photos taken: https://glitchycam.com/gallery

I intentionally leaned towards skeuomorphic design for nostalgia. I miss the days where I'd spend hours making a button to look like a physical button. Here I chose to make it look like a "good enough" Teenage Engineering device UI.

I tested/used GPT-5.3-Codex to build this from scratch, since there was a lot of hype around it on X. Maybe I wasn’t using it right, but I found it needed a lot of code cleanup at every step and a lot of hand holding along the way. It missed details/nuances and didn't land the skeuomorphic buttons or the interaction polish. It mostly helped with boilerplate where there wasn't much thinking/detailing. It did give a basic starting point for the effect calculations, but didn't really move the needle on the details.

Please give it a go and let me know what you think - your photos and video never leave your browser (you can download them if you choose to). Everything is processed locally in your browser (works offline), nothing is uploaded or seen by anyone.

Box of Rain is an open-source project that provides a simple, flexible, and extensible system for managing user settings and configurations across different applications and platforms. It aims to simplify the process of managing user preferences and settings, making it easier for developers to build applications with customizable user experiences.

The article discusses the development of a unified database system that integrates various data sources, providing a centralized platform for managing and accessing data across an organization. The system aims to improve data organization, accessibility, and decision-making processes.

Jarvish is a Next Generation AI Integrated Shell written in Rust, inspired by J.A.R.V.I.S. from Marvel's Iron Man. It natively embeds AI intelligence into your everyday shell experience — no more copy-pasting errors into a browser. Just ask Jarvis.

Hi HN,

I’ve been experimenting with archive format design and built 6cy as a research project.

The goal is not to replace zip/7z, but to explore: • block-level codec polymorphism (different compression per block) • streaming-first layout (no global seek required) • better crash recovery characteristics • plugin-based architecture so proprietary codecs can exist without changing the format

Right now this is an experimental v0.x format. The specification may still change and compatibility is not guaranteed yet.

I’m mainly looking for feedback on the format design rather than performance comparisons.

Thanks for taking a look.