value: nguyenhu

value:
Have you ever wonder if your SDKs is friendly for Agentic AI like Claude Code or Codex? I built an opensource (Apache 2.0) CLI that answer that question for you.
With it you can create a test suite either manually or with an Agent based on the source code and documentation. The CLI will dispatch Agents with their own sandboxed microVMs to solve each test. Results then get graded by another Judge Agent.
Test-taker agents only have access to public information (guides, blogs, package metadata), while Judge agents have access to both public and private information (source code, internal documents)
After the test result are generated you can make improvement to your SDK manually, or use an Agent to automate the process.
Agents are sandboxed, this means:
- Host machine secrets (API keys) are not exposed to the sandbox environment
- Egress HTTP requests are monitored, Judge agents' egress are limited to trusted domains to ensure that proprietary IP are not exfiltrated
Features:
- CLI commands for the entire workflow of generating, eval, reporting on test suites
- Agent skills for each command
- Local Web UI if you want to inspect test result and edit test cases visually
GitHub:
https://github.com/PSPDFKit-labs/agentic-usability

value: Show HN: I built a way to see if your SDK is AI-friendly

author: nguyenhu


value: samplexBro

value: Show HN: I got tired of hand-syncing AI coding rules across four tools

author: samplexBro


value: theozero

value:
Meet bumpy  - your new favourite open-source versioning, release, and changelog tool. Especially useful in monorepos with many related packages, but also great to use in simpler setups.
This is a modern successor to the popular  changesets tool, used by many open source projects.
While changesets is great, and I love the file-based bump+changelog workflow, the project has hundreds of open issues, many of which have been open for multiple years. Bumpy fixes most of the important ones (over 120+ by my last count), and adds some new features as well. It also greatly simplifies things, so it should be easier to evolve as folks start pushing its limits.
Some highlights:

  - changesets is built as a monorepo with 20 subpackages, this is a much simpler monolith
  - changesets requires you install a github app, use a github action, an npm module, and another for changelog formatting (this is a single install)
  - much more flexible include/exclude logic, instead of assuming behaviour is the same for all private packages
  - allows custom publishing commands, does not assume/force npm publishing
  - more sane peer dependency bumping logic
  - built in formatters, and easier to write custom ones
  - non-interactive version of add command (useful for agents)
  - it's infested with delightful frogs
  - lots of other small quality of life improvements

What's missing:

  - no prerelease workflows yet (changesets users say this part of it is very confusing, so want to get it right)
  - I want to allow multiple publish targets per package
  - Add plugin system to define common publishing targets (e.g., VSCode extension marketplace)

Yes it was coded using AI, but carefully. There is a comprehensive test suite. We are using it actively to release varlock along with 25+ related libs and plugins.
Run `bunx @varlock/bumpy init` to get started - if you are using changesets, it will help you migrate automatically.

value: Show HN: Bumpy – versioning/changelog tool, fixed 120 open changesets issues

author: theozero


value: gnapapp

value:
TokenToday is a live news channel where every story is researched, written, and reviewed by AI agents, no human editors. Agents register via API, submit stories in Markdown, go through a multi-agent editorial review (other agents request revisions or approve), and a publisher agent makes the final call to publish.
The business model: revenue is distributed to agents in proportion to readership their stories generate. It's a fully autonomous newsroom with economic incentives baked in.
Curious whether the editorial quality holds up as more agents join, and whether the rev-share model changes what agents choose to write about.
---
Link: tokentoday.org
Join as a journalist: tokentoday.org/join
Skill file: tokentoday.org/skills/journalist.md

value: Show HN: The newsroom that runs itself; hiring AI Journalists [TokenToday]

author: gnapapp


value: tpfuetze

value:
Hi guys, am building SecureLend.ai and when working on our underwriting agents (free trial, paid after) I had issues with seamless payment options.
Of course I looked at x402 which I believe is a great protocol but not a fan of
a) sharing private keys with the agent
b) having a human in the loop or
c) similar workaround e.g. pre-funded wallets
So I started building out a solution. For my use case it was important to not only have stablecoins but also a fiat rail which is now implemented using Stripe.
Initially I build a mandate system internally but am very glad and big shoutout to the guys at google for AP2 (https://github.com/google-agentic-commerce/AP2) which I ended up using for the scoped payment mandates.
Please do check it out and would appreciate feedback from people building in the space.
Docs:
https://docs.delegare.dev
Git:
https://github.com/delegare/delegare
Sandbox:
https://app.sandbox.delegare.dev/

value: Show HN: Delegare – let AI agents pay safely (x402, AP2 – base/USDC and Stripe)

author: tpfuetze


value: attendos

value: Show HN: A free crypto trade journal with cycle support and CSV import

author: attendos


value: vorillaz

value:
After a very long time I've spend a great amount of time revisiting my very first open source project.
+1300 logos and icons coming along with a brand new website, high fidelity SVG files, extended documentation and support for all major front end frameworks.
GitHub link: https://github.com/vorillaz/devicons

value: Show HN: Devicons, +1300 logos and icons in React, SVG, and icon format

author: vorillaz


value: bugthesystem

value: Minimal Linux sandboxes for running untrusted code. Built for AI agents, build systems, and any scenario where you need to execute code you didn't write.

value: Show HN: Minimal Linux sandboxes to manage AI-Generated Code with ease

author: bugthesystem


value: siclark

value:
Whilst working with a colleague researching a data model we wanted to build into a website we were struggling sharing the output of our AI sessions, not just the findings but the thought process, the failures as well as success, and any files written.
So I built a Claude skill that enables asynchronous collaboration between multiple human / agent pairs.
Its write once markdown files in a shared location, git, dropbox, network, that all users can view realtime. User driven summaries can be created to save context and summarise status for new joiners to the workspace. If wanted these can be posted to git discussions for wider collaboration or sharing.
On git there are no branches, merges or PRs so nothing to slow you down. Files are uniquely named so no clashes.
It's all markdown files with links between summaries and summary commands that extract themes into a patterns.md file.
No database, no embeddings or vector DBs. If you want to put Obsidian over the top you can, it's just not built in.
I'd love feedback on the concept and implementation. Raw data kept forever for review, with the compressed summaries available for faster review by humans and to save tokens for agents.

value: Show HN: Async multi-person collaboration skill for Claude Code

author: siclark


value: My colleague friend and I made a tiny Bash CLI that prints a random Law of Software Engineering in the terminal. I use it in my shell startup so I get one law every time I open a new shell. It fetches the laws from lawsofsoftwareengineering.com and caches them locally.

value: Show HN: Lose_law – Tiny CLI for Random Laws of Software Engineering


value: eskibars

value:
Hi all,
I've had a feeling for a while that there was going to be a war on software based on LLMs controlled by "bad actors."  LLMs have gotten really good at finding security vulnerabilities and in the hands of bad actors, it can really ravage the public infrastructure we all rely on.  Unfortunately, I've felt like OSS was going to be the first sacrificial lamb so to speak because the code is out there, so easy to identify.
I'm launching zeroquarry.com now for open source maintainers to be able to scan their own code before a bad actor does.  Just bring your own LLM key and I'll pay for the hosting infrastructure, development costs, etc for at least the next several months.  most scans cost about $5-$20 in tokens using frontier models.
https://youtu.be/bbLYw7j90hA for a demo of how it works
Right now, I'm focused purely on OSS and getting feedback on the product: no option to pay for it.  You bring you API key(s), choose your model(s), and run.  I've limited the scans to 2x per month for now and 1 concurrent scan at a time by default to try to avoid abuse, but if you're a maintainer of an OSS project and you would like higher limits, just reach out and provide details on your project and I'll bump up pretty much as high as needed.  email is shane at the domain
I was going to delay launch until later, but the it's something I've been working on for a few months and the Mythos news really prompted me to move a bit faster.  Feedback is generally welcome both here or at the e-mail address above

value: Show HN: Scan your OSS projects for vulnerabilities

author: eskibars


value: aliezsid

value: Show HN: Excalidraw but for 3D Drawing

author: aliezsid

title: Show HN: Excalidraw but for 3D Drawing


value: Show HN: Axiom v2.0 – Parallel Ingestion at 125M rows/SEC


value: mcval

value:
Quick context: I’ve been messing around with various coding tools and agents (GitHub Copilot, Lovable, Claude Code, Codex, etc.) for about 2 years. Before that I did zero development. I barely knew what GitHub was. I knew a bit of python and SQL but mostly spent my time in excel doing data analysis, sentiment analysis, and NLP. I never really thought of myself as a developer, and I’m not sure shipping this counts either. It’s the first open-source thing I’ve made, and I think might be useful to a few people so wanted to share it on here.
I started using Ghostty recently and kept editing ~/.config/ghostty/config, reloading, squinting, editing again every time I wanted to try a theme. Built this over a weekend so you can preview 16 palettes and 4 fonts with a background-tint slider, then copy the config lines.
One static HTML file. No build step, no tracking.
Site: https://ghosttythemes.com/
Source: https://github.com/mcvalosborne/ghostty-theme-mixer
Hope it’s useful.

value: Show HN: Ghostty Theme Mixer (preview themes and fonts live)

author: mcval


value: wasimsk

value: Show HN: Elon Musk trial against Sam Altman to reveal OpenAI power struggle

author: wasimsk


value: freakynit

value: Show HN: Building a Real Agent, Step-by-Step

author: freakynit


value: kemyd

value: Show HN: AI Email Design – Create beautiful newsletters in multiple models

author: kemyd


value: Show HN: I wrote a DOOM clone in my own programming language


value: CarlHoerberg

value:
Hi HN. I'm Carl, creator of LavinMQ.
LavinMQ is an open-source message broker. AMQP 0-9-1, MQTT, HTTP and streaming. Single binary, minimal resource use. If you know RabbitMQ, it's that (but running on a fraction of hardware).
We're the team behind CloudAMQP where we've hosted RabbitMQ for 14 years. Sometimes customers hit issues we couldn't fully explain / work around. So we built our own broker, in order to provide solutions where we previously couldn't (which is much easier when you control the full stack).
It all started by me building an open-source AMQP proxy to handle short-lived connections for a customer, to avoid heavy connection churn on cpu.
Once the protocol was implemented, adding a persistence layer seemed like a fun challenge. How hard could it be? Turns out the protocol was the easy part. Reliable disk storage, ack handling, and replication was harder. It took years. Our first release was pushed in 2020 and today it runs on 5,000+ production instances on CloudAMQP.
LavinMQ is written in Crystal (LLVM-compiled, Go-like concurrency, Ruby-like syntax). Messages go straight to disk via memory-mapped files, no in-memory cache. Append-only writes for both messages and acks. The whole design is built around minimizing memory copies, allocations and syscalls.
Numbers: ~580k msgs/sec on a t4g.micro (2 vCPU, 1 GB RAM). Over 1M msgs/sec on a c8g.large (2 vCPU, 4 GB).
Try it:

  docker run -p 15672:15672 -p 5672:5672 cloudamqp/lavinmq

We are curious to hear: how are you handling messaging today? What would make you consider switching broker?

value: Show HN: LavinMQ, an open-source message broker written in Crystal

author: CarlHoerberg


value: wontopos

value: Show HN: I built AI character chat that remembers the way people do

author: wontopos


value: tawb

value:
Howdy HN! My recent dive into home ownership has brought me a whole new world to navigate w.r.t contractors, insurance claims, etc.  I've been leaning heavily on the Dangerous Professional concept for clearer communication.  It fits very cleanly as a plugin and has been very high-ROI for me.
This is a community implementation.  No affiliation with patio11, just a fan of his work.
Repo: https://github.com/Tetra-Research/dangerous-professional-plu...
Install: `npx skills add Tetra-Research/dangerous-professional-plugin`

value: Show HN: Implementing Patio11's "Dangerous Professional" as a Claude Code Plugin

author: tawb


value: aaronjaegar

value: Trunks lets you keep using git while pushing repos to S3, R2, Tigris, MinIO, Postgres, SFTP, local disk, or a file share.

value: Show HN: Trunks – Git repos backed by your own storage

author: aaronjaegar


value: maksimov

value:
Hi HN,
This was one of those "scratch my own itch" type of things. I wanted to build my own small CLI tool to scan GPU capacity in our AWS accounts. Today it can do EC2, SageMaker, EKS and K8s clusters. It’s able to tell you how much is potentially wasted and recommend how to improve.
Easy to install:`go install` and run. No signups, no API keys.
The tool is written in Go, deliberately designed to support other clouds and GPU providers. I would love people to try it and return with feedback. Contributors are most welcome, especially those who can help with discovery and metrics for other clouds.
Many thanks.

value: Show HN: Open-source GPU cost analysis tool

author: maksimov


value: vanelsas

value: Show HN: Bareforge – A UI builder exporting stateful JavaScript/CLJS projects

author: vanelsas


value:
Hi HN, I built MindCheck after running into a problem in my own AI-assisted workflow.
A couple months into using Codex heavily, I realized I had delegated too much of a data pipeline without really tracking the details. When the model results degraded, I traced it back to feature-processing decisions that had quietly changed across iterations. The mistake was fixable. The uncomfortable part was realizing I no longer knew exactly where I had stopped following the logic.
MindCheck reads local AI conversation logs from Claude Code, Cursor, Codex CLI, and Gemini CLI. It breaks sessions down by task type and heuristically estimates how much of the work involved active reasoning versus delegation.
The goal is not to reduce AI usage. I’m trying to make the boundary visible: where I’m still forming hypotheses, testing ideas, pushing back, and owning the direction of the work — versus where I’m mostly prompting and accepting.
For me, the task breakdown was the most useful part. Data analysis still looked relatively engaged, but planning and writing were much more delegated than I expected.
By default, Tier 2 runs locally using embeddings. Optional Tier 3 refinement only runs if explicitly configured, and then only low-confidence individual user messages are sent — not full sessions or AI responses.
The scoring is heuristic — it won’t tell you whether you understand the work, but it can show where you started handing the reasoning off. I’d be interested in feedback from people using AI coding tools heavily: does this kind of delegation map seem useful, and what signals would make it more trustworthy?

value: Show HN: MindCheck – Analyze your AI coding logs for over-delegation


value: mtimma

value:
Hello HN!
Like most of developers, I have worked on migrating a large legacy codebase with no up-to-date documentation or unit tests, and found AI agents, like Claude LLM, to be very helpful for finding and describing specific functionality. However, returning to the same code with agents feels wasteful in terms of token usage. Also, after finishing migrating some part of the software, I wanted to know which parts of the code still required analysis and migration. This would require to visit and review both the code and documentation to find the gaps.
After not finding a solution on the internet that satisfied my needs, I created a structure that could link markdown analysis files to the source code. To enforce agent to use this structure to help track documentation coverage, I decided to create a small MCP server. With it the agent is able to tell me how much of the code is left to be analysed in percentage, as well as identify parts of code and functionality that require analysis. The ultimate goal is to identify requirements that have not been migrated yet, assuming the documented functionality has been.
The server is entirely local, it does not access the internet, besides for the MCP client to download and run the server package using npx.
Important disclaimer! The code was generated using orchestrated Claude Opus-4.5 agents from a set of requirements. The requirement and task markdown files can be found in the 'agent_tasks' folder of the repository.

value: Show HN: Knowerage – code coverage for LLM analysis

author: mtimma


value: podlp

value:
Hi HN,
Last month at a SundAI hackathon, my team built a prototype for an app called iClaw. The goal was to develop an AI agent using Apple Intelligence. I've since continued hacking away at this idea when I had time, and now I'm releasing it on https://geticlaw.com with code on GitHub.
Apple Intelligence is a really poor model choice for an AI agent. It's not great at extracting information (it often injects preambles like "Here's the page..."), it struggles with following directions, and it gets overwhelmed when you ask it to choose from more than 3 available tools. But it's also a great choice because it comes pre-installed on many Macs without any configuration. It's also incredibly fast compared to just about every other 2-4B model I've run on my MacBook Air.
iClaw is very experimental and will make mistakes, but it's designed around safety. iClaw lives in the App Sandbox where it only has access to the permissions you grant it. All tools calls that create or delete (files, emails, calendar events) require explicit consent. You can also fully disable any tool, so they can't be called.
It was fun pushing the limits of what the 3B Apple Foundation Model (AFM) could do. I trained a LoRA adapter for better instruction following, and to "learn" a DSL for rendering custom widgets. I built, re-built, and re-re-built a 40+ tool library routing system using text classifiers and a multi-step decision framework. I built a Safari Extension that allows iClaw to access what's on your browser (I envision use cases like data extraction, form filling, or agentic navigation).
In all honesty, iClaw isn't ready for prime time. My ultimate goal was to distribute on the Mac App Store, which I perceived as a "safety & trust" signal. iClaw tries to do too much, so it easily gets lost. But I'm also surprised at just how much is possible, even without a purpose-built model. Check it out at https://geticlaw.com and GitHub, and let me know what you think.

value: Show HN: iClaw is part OpenClaw, part Siri, powered by Apple Intelligence

author: podlp


value: kompressr

value:
In my previous organization, we went from a monolith to multiple FE & BE repos & then wanted Image Optimization, which took more than a year for us to get it right & even then it was not fully done for old images!!
At first it looks like "we just need image optimization." Then the scope grows:
- existing site assets need a CDN path
- uploads need storage and permanent URLs
I saw the pain & the thought of Kompressr was born. Kompressr is my attempt to make that pipeline boring & make things just work!
There are two live paths:
1. Prepend a project CDN URL to assets you already host:

    https://cdn.kompressr.com/PROJECT_ID/https://example.com/hero.jpg

2. Upload a file directly and get back a CDN URL:

    curl -X POST https://uploads.kompressr.com/api/upload \
      -H "Authorization: Bearer $KOMPRESSR_API_KEY" \
      -F file=@output.png

The returned URL is usable immediately. If Kompressr already has an optimized version, it serves that. If not, the original goes out first while optimization runs in the background.
It handles images, video, PDFs, fonts, CSS, JS, HTML, SVG, JSON, and XML on paid plans. Free tier starts with image optimization.
For AI apps, the Upload API can be the file layer: upload generated output, store it, optimize it, and hand your user a permanent URL.
There is also an MCP server (`npx -y @kompressr/mcp-server`) if you want agents to upload files directly.
Pricing is storage + bandwidth, not per-transformation.
Autopilot is coming next for the no-code path, where you point your domain to Kompressr & all assets are optimized.
Free tier: 250 optimizations, no credit card.
Take the Free Audit to know how much you can actually save on a page: https://kompressr.com/audit
AI apps guide: https://kompressr.com/agents
Docs: https://kompressr.com/docs
Pricing: https://kompressr.com/pricing

value: Show HN: Kompressr – One Step CDN which optimizes all your files

author: kompressr


value:
AurionOS v1.1
(the link is youtube tutorial to setup AurionOS :D)
a few week ago i posted about AurionOS
today i am releasing AurionOS v1.1 with much more added :D
i added AurionGL(sadly not working but i will fix it for on full release :D), Wallpaper is finally real picture(not just colors), kernel panic, ported MicroPython(still testing) added better installer and login screen
here's source code: https://github.com/Luka12-dev/AurionOS
any feedback :D ?

value: Show HN: Aurion OS v1.1 (C/x86 ASM) [video]


value: Show HN: Photorealistic GPT Image 2 animal hybrids


value: nnoorbakhsh

value: Show HN: Qumulator – simulate 1k-qubit circuits on CPU, exact results, no GPU

author: nnoorbakhsh


value: axeldunkel

value:
When at night the pager goes off, I ask Claude: "what is alerting, what changed in the last hour?". Claude answers by chaining calls across Graylog, Prometheus, Alertmanager, Linode, GitLab, NetBox and more. The menu of tools Claude has access to is even bigger than that: I have connected 30 backends so far (20 in the public registry, the rest internal to my setup), including most of my ops stack (OPNsense, Tailscale, Xen Orchestra, DokuWiki and more). ToolMesh is what makes that menu composable for Claude.
Each backend is a simple DADL file - a small YAML that declares the REST API of the service to ToolMesh, which then exposes those tools to Claude. Most of the publicly available DADLs (currently 20 with 1,833 tools in total) were drafted by an LLM in minutes and tuned from there. The registry is public.
Here is the HN API as DADL - the API behind this very page:

  tools:
    get_top_stories:
      method: GET
      path: /topstories.json
      access: read
      description: "Up to 500 top story IDs, ordered by HN ranking"
    get_item:
      method: GET
      path: /item/{id}.json
      access: read
      description: "Get story, comment, job, poll, or pollopt by ID"
      params:
        id: { type: integer, in: path, required: true }

How can a single agent access so many backends without creating context overflow? Code Mode. Naively, every tool and schema goes into context - 50,000+ tokens before the agent does anything useful. ToolMesh compresses that to ~1,000 by giving the model a typed API surface and letting it ask for endpoint details only when it needs them. That is the difference between "doesn't scale" and "please add 10 more, it's fine!". ToolMesh can also connect to other MCP servers, rendering them code mode capable as well.
Security in mind: credentials never reach the model (they are injected at runtime). ToolMesh runs a fail-closed pipeline: auth -> authz -> credential injection -> exec -> output gate -> audit. CallerClass lets the same API have different policy per client type (local dev assistant vs hosted agent vs CI bot). Every call lands in a SQLite-queryable audit log - "what did the agent do Tuesday?" becomes a SQL query, not a shrug.
ToolMesh is not magic. APIs with stateful flows or weird auth still need care, and an LLM with a great tool surface can still pick the wrong tool. You still need sane policy.
Try before cloning: https://demo.toolmesh.io is a public instance with the HN API loaded (login dadl/toolmesh). Connect Claude Desktop, Claude Code, or ChatGPT in 30 seconds: https://toolmesh.io/demo
GitHub: https://github.com/DunkelCloud/ToolMesh
Docs: https://toolmesh.io
DADL Spec + Registry: https://dadl.ai
Apache 2.0, single Go binary or Docker, no SaaS dependency.
If you think of your full ops stack - what DADLs would you like to have available to your LLM?

value: Show HN: ToolMesh – turn all your REST APIs into MCP tools via declarative YAML

author: axeldunkel


value: aleciffo

value:
OSSCAR is a quarterly ranking of the fastest-growing open-source GitHub organizations. It's a joint project between Supabase and >commit, a VC focused on open-source.
A few notes about the methodology: we focus on organization accounts (excluding personal accounts and forks), split them into two divisions by starting star count so smaller and larger ecosystems are evaluated among peers, measure growth across three signals (GitHub stars, contributors, and package downloads from npm, PyPI, and Cargo), normalize each signal within its division using a log–minmax transform, and combine the resulting scores into a single composite via the L² norm. Organizations are then ranked by this composite within their division. Full methodology is on the site.
This is v1 of the ranking, so there’s a lot of room for improvement. In future versions we want to add other package managers, new signals and refine the methodology. Things we'd love opinions on:
1. What do you think about the signals we are using? Which important ones are we missing?
2. Is log-minmax a robust scaler in this setting, or is there something better?
3. Is L^2 norm the right aggregation strategy for sparse, heterogeneous signals?
Everything's open: the website, the data and the scoring pipeline. We'd love your feedback on the methodology, the rankings, signals we're missing, or anything that looks wrong. Issues and PRs very welcome.
Repo: https://github.com/commitvc/osscar

value: Show HN: Osscar – Measuring open-source growth beyond GitHub stars

author: aleciffo


value: drewlong

value: Show HN: DeadNet – Watch AI agents debate, play games, and write stories live

author: drewlong


value: thecartine

value:
I just shipped Foolery 0.13.3.
It’s a local coding-agent orchestration tool. This release includes a major UI redesign, Setlists for tracking optimized orchestrations, and improved agent/model metrics.
I also made a 60 second tour of the current direction:
https://www.youtube.com/watch?v=0iDxnCkUoVQ

value: Show HN: Foolery – a local coding factory for orchestrating coding agents

author: thecartine


value: zciwor

value:
GitHub's search is a great resource for software development. Being able to search an obscure function implementation and see 100s of examples in code is immensely helpful.
I've been exploring how to make something similar for electronics. To be able to search for a part number and see 100s of subcircuits using that part in context would be just as helpful.
As GitHub has become a home for a lot of open source electronics, the challenge is two fold: (1) search git repos by part and (2) build a universal ECAD visualizer (most people just upload the design files).
Happy to hear how others might approach the visualizer problem. Representing schematics and layouts across ECAD formats is... messy.

value: Show HN: I'm cataloging open source electronics

author: zciwor


value: beeswaxpat

value: Show HN: Live Sun and Moon Dashboard with NASA Footage

author: beeswaxpat


value: TheAndruu

value:
I kept manually reformatting wrapped paragraphs and trailing whitespace every time I pasted Claude Code or Copilot CLI output into a Slack message or a GitHub issue. So I built a terminal command to run after copying that does the reformatting for me.
Running in a terminal instead of using one of the browser-based formatting tools means less context switching.  It handles both regular text, bulleted lists and code formatting all at the same time.  Source: https://github.com/TheAndruu/ai-clean
The page above runs the same Go pipeline compiled to WebAssembly — paste your own messy clipboard contents, no install needed.  If you want to install it, there is homebrew and one-line install commands.

value: Show HN: AI-clean – strip unwanted formatting from text copied out of AI CLIs

author: TheAndruu


value: vasvir

value:
I have been working as the lead developer of this for sometime now and I hope some of you find it intriguing, and of course to find out what people think about it.
The main underlying motive behind this work is to unify all life-science knowledge currently sitting on isolated silos. So...
Biovista Vizit is a knowledge (force directed) graph exploration platform that integrates data from various heterogeneous biomedical resources. By overlaying structured biomedical datasets with literature evidence, Vizit empowers researchers to explore genes, diseases, pathways, and clinical outcomes through an intuitive interactive graph. For each connection, multi-modal supporting evidence is provided, linking back to the original biomedical corpus, like MEDLINE, Human Phenotype Ontology (HPO), Protein Data Bank (PDB), Adverse Outcome Pathway (AOP), and ClinicalTrials.gov.
A big effort in integrating these disparate data sources went into systematically handling the fragmentation problem created by multiple synonyms, typos and generally unstructured input text fields. We now have a procedure to integrate other public biomedical data sources (e.g. USPTO, FDA AERS) or private in house data into the system. Each one comes with its own challenges of course.
You can save and share your created graphs at any point by clicking on the "Save" button.
You can start exploring by clicking on the red "Start" circle.
Feedback and comments are welcome.

value: Show HN: Extract Biomedical Knowledge from Multi-Modal Data Using Biovista Vizit

author: vasvir


value: codefreex

value: Show HN: PageForge – Generate WordPress SEO Pages from a Single CSV

author: codefreex


value:
Hi HN — I’m building OPC Community, a community/resource hub for solo founders and one-person companies.
While researching funding options, I noticed that most accelerator/grant lists are either too broad, startup-team-oriented, outdated, or hard to filter as a solo founder.
So I made an updated database of programs that seem more relevant to solo founders: accelerators, grants, fellowships, founder programs, and competitions.
No signup is required to browse the database.

value: Show HN: I compiled a list of solo-founder-friendly accelerators and grants


value: Show HN: Pretext powered portfolio recycling letters


value: holliplex

value: I put this together over the weekend and think it's pretty fun. You are shown a distorted face, and have to memorise and match the distortion on the original. Compete with your friends!

value: Show HN: Face Lift, a memory game about faces

author: holliplex


value: hahooh

value:
I built Hahooh because I was tired of writing the same boilerplate every time I wanted to give Claude or a local agent access to a new database schema or a random REST API.
While there are many great MCP servers out there, they are often fragmented or require manual setup. I wanted to create a "WordPress for MCP" experience where:
1. Non-authed/Public tools: You can quickly bridge a public API to an agent.
2. Agent-Centric CLI: Instead of a human configuring everything, the CLI is designed so an agent can eventually say "I need access to this DB" and (with permission) create its own bridge.
3. Security: I’m using GCP Secret Manager for credentials and bcrypt for API key hashing.
The stack is Go (backend), Vue 3 (frontend), and a Go-based CLI.
I’m really interested in the "agent-as-builder" paradigm. If agents can build their own tools, the engineering bottleneck for AI workflows disappears.
I'd love to hear your thoughts on the security model and how you’re handling MCP server management.
Site: https://hahooh.xyz
CLI: https://hahooh.xyz/download

value: Show HN: Hahooh – Give AI agents the power to build their own MCP tools

author: hahooh


value: kharwarm

value:
I built sensor fusion for a mobile robot and reached for robot_localization like everyone does. After spending too long fighting navsat_transform, UTM zone boundaries, and YAML covariance tuning, I wrote my own.
FusionCore is a 22 state UKF that fuses IMU, wheel encoders, and GPS in ECEF directly (no coordinate projection, no extra node). It estimates IMU bias, adapts its noise covariance automatically from the innovation sequence, and gates outliers with a chi squared test on every sensor.
I benchmarked it against robot_localization EKF on 6 sequences from the NCLT public dataset (University of Michigan, real robot, real GPS, RTK ground truth). It wins 5 of 6. On the 6th sequence (fall, degraded GPS over a long period) it loses badly. RL UKF diverged to NaN on all six.
Configs, methodology, and full reproduce instructions are in the benchmarks/ folder.

value: Show HN: FusionCore: ROS 2 sensor fusion that outperforms robot_localization

author: kharwarm


value:
I built givemesearch because I kept seeing Claude Code confidently generate complete BS using function signatures that had been changed or removed. This is using a setup that I've had some success with personally so I'd like to see if I can make it a SaaS.
So I built this little SaaS that gives coding agents real-time web search grounding for general coding agent usage. Connect your Claude Code to givemesearch via MCP and you will be able to ask your Claude Code to research anything before it starts spewing out BS.
It's currently at an early stage and I'm trying to get some alpha testers. It's free during alpha, and will be a be a flat $10/mo with no extra charges per query, obviously subject to some fair use limit.
I'd love feedback and comment from you all! Thank you
https://givemesearch.com

value: Show HN: Givemesearch: live web search grounding for coding agents (free alpha)


value: squidleon

value:
I have notifications coming from too many places, Telegram, WhatsApp, RSS, email, GitHub, calendar. I wasn't looking for another forwarding
service, I just wanted everything in one spot so I don't have to check six apps to know what happened.
Arrr! is a Linux daemon ( and pirate) that pulls from all those sources via plugins and puts everything into a single stream. The thing that pushed me to actually build it was the digest: I don't want a desktop popup for every RSS item, but I do want a summary of what came in overnight.
It runs as a systemd user service, loads plugins from .dll files at runtime (RSS, Telegram, WhatsApp, IMAP, GitHub, CalDAV, MQTT, Todoist),
and delivers to D-Bus, ntfy, SMTP, Gotify, Pushover or any sink plugin. There's a web UI for history and config, and a small tray app for Linux desktop notifications.
Self-hosted, no cloud, single binary
https://github.com/tgiachi/Arrr

value: Show HN: Arrr!, Linux notification aggregator (RSS, Telegram, WhatsApp, email)

author: squidleon


value: nadermx

value: Show HN: STT.ai

author: nadermx

title: Show HN: STT.ai


value: Show HN: AI Agent Controlling Real Servers (BMC, Firmware, Network) – Full Demo [video]


value: Show HN: How much of the Linux kernel is written by AI?


value: ArqueNova

value: Show HN: DingoFind – A sub-10ms Australian address autocomplete API in Rust

author: ArqueNova


value: willwashburn

value:
We were spending a lot of time re-writing the same primitives in projects we were doing getting claude + codex + other harnesses communicating in real time.
Many other projects forced us into using their framework or harness or into a specific stack. So we open sourced an SDK that acts as the messaging layer without the rest of it.
Still early, but we've been working on it and found it useful.

value: Show HN: Simple SDK for agent-to-agent communication

author: willwashburn


value: yakkomajuri

value:
Hey HN!
I've been wanting to use something like OpenClaw for a while but couldn't get myself to give it access to anything important due to all the risks involved. Prompt injection is still a problem (even though some people seem to ignore it) and so are hallucinations and mishaps that cause agents to do things like delete production data [1].
Even harnesses like Claude Code and Codex are subject to this, particularly since we're getting progressively looser about how we run them e.g. Conductor is really popular and runs agents without any sandboxing.
That means we're in a bit of an all-or-nothing situation. There are people who just ignore the risks and connect everything to their agents and reap benefits from it while being subject to more risk, and there are others that just don't connect anything because they are mindful of the potential issues.
I've been quite cautious but have wanted to run more autonomous agents and so I built the component I needed to enable me to do so: AgentPort.
AgentPort is a gateway that connects to any service (e.g. Gmail, GitHub, Stripe, PostHog, Linear) and let's you set granular permissions for what the agent can do automatically, what it needs your approval for, and what it can never do.
For example, you can set `list_customers` and `get_customer` on the Stripe integration to "Auto-approve" but `create_refund` to "Ask for approval". The agent will thus be able to do a lot in the background independently but when it comes to a potentially destructive operation it will be blocked and receive an approval link to send to you. You can then approve or deny the call with those exact parameters e.g. `create_refund(customer_id: 1234, amount: 12)`.
Agents connect via MCP or CLI and have access to all the integrations you connected without ever getting API keys. Kind of like Composio but with granular permissions and open source.
The goal with AgentPort is to specifically address two vulnerabilities that agents are subject to:
1. Destructive operations on downstream services: It can't delete a database unless you explicitly approve
2. Credential exfiltration: Your agent never sees API keys
AgentPort also helps with sensitive data exfiltration, but that is more nuanced and complicated to defend against if the agent has an internet connection [2].
Ultimately, AgentPort was the missing piece for me to start running more autonomous agents that have access to third-party services, and hopefully it can unlock use cases for you too. There's a ton more work needed around securing agents (Claws in particular) and I've both been writing about it [3] and intend to do more in this space, so if you're thinking about similar things let's have a chat.
The repo is https://github.com/yakkomajuri/agentport and you can run it locally with docker compose in a minute or use the one-liner install to deploy a prod instance (domain, TLS, etc.) in just a few mins as well.
[1] "An AI agent deleted our production database. The agent's confession is below" (https://news.ycombinator.com/item?id=47911524)
[2] See my post "On agents dropping production databases": https://yakko.dev/blog/on-agents-dropping-production-dbs
[3] https://yakko.dev/blog

value: Show HN: Integrations gateway for agents with 2FA for destructive ops (OSS)

author: yakkomajuri


value: Iflal

value: Show HN: Keychase – A zero-config, offline Python secret scanner

author: Iflal


value:
Hi HN, I'm Hugo. I've been building Rocky over the past month, shipping fast in the open. The binary is on GitHub Releases, `dagster-rocky` on PyPI, and the VS Code extension on the Marketplace. I held off on a broader announcement until the trust-system surface was coherent enough to talk about as one thing. The governance waveplan — column classification, per-env masking, 8-field audit trail on every run, `rocky compliance` rollup, role-graph reconciliation, retention policies — landed end-to-end last week in engine-v1.16.0 and rounded out in v1.17.4 (tagged 2026-04-26). That's the milestone I'd been waiting for.
The pitch: keep Databricks or Snowflake. Bring Rocky for the DAG. Rocky is a Rust-based control plane for warehouse pipelines. Storage and compute stay with your warehouse. Rocky owns the graph — dependencies, compile-time types, drift, incremental logic, cost, lineage, governance. The things your current stack can't give you because it doesn't own the DAG.
A few things I think are interesting:
- Branches + replay. `rocky branch create stg` gives you a logical copy of a pipeline's tables (schema-prefix today; native Delta SHALLOW CLONE and Snowflake zero-copy are next). `rocky replay <run_id>` reconstructs which SQL ran against which inputs. Git-grade workflow on a warehouse.
- Column-level lineage from the compiler, not a post-hoc graph crawl. The type checker traces columns through joins, CTEs, and windows. VS Code surfaces it inline via LSP.
- Governance as a first-class surface. Column classification tags plus per-env masking policies, applied to the warehouse via Unity Catalog (Databricks) or masking policies (Snowflake). 8-field audit trail on every run. `rocky compliance` rollup that CI can gate on. Role-graph reconciliation via SCIM + per-catalog GRANT. Retention policies with a warehouse-side drift probe.
- Cost attribution. Every run produces per-model cost (bytes, duration). `[budget]` blocks in `rocky.toml`; breaches fire a `budget_breach` hook event.
- Compile-time portability + blast radius. Dialect-divergence lint across Databricks / Snowflake / BigQuery / DuckDB (12 constructs). `SELECT *` downstream-impact lint.
- Schema-grounded AI. Generated SQL goes through the compiler — AI suggestions type-check before they can land.
What Rocky isn't:
- Not a warehouse — it's the control plane on top.
- Not a Fivetran replacement. `rocky load` handles files (CSV/Parquet/JSONL); for SaaS sources use Fivetran, Airbyte, or warehouse-native CDC.
- Not dbt Cloud — no hosted UI, no managed scheduler. First-class Dagster integration if you need orchestration.
Adapters: Databricks (GA), Snowflake (Beta), BigQuery (Beta), DuckDB (local dev / playground). Apache 2.0.
I'd love feedback on the trust-system framing, the governance surface (particularly classification-to-masking resolution in `rocky compile` and the `rocky compliance` CI gate), the branches/replay design, the cost-attribution primitives, or anything else that catches your eye. Happy to go deep in the thread.

value: Show HN: Rocky – Rust SQL engine with branches, replay, column lineage


value: amantinband

value: Show HN: Figma alternative where AI works with vector primitives, not code

author: amantinband


value: xmhatx

value: Show HN: VoiceGoat – A vulnerable voice agent for practicing LLM attacks

author: xmhatx


value: jonnyburch

value:
I deleted facebook well over a decade ago. As a now 40 year old, I was of the generation that stored all of their data on Facebook, but the only feature I missed was birthday reminders.
This became even more embarassing as friends and family started having kids. Hell if I remember your third kid's name, let alone birthday.
So a couple of years ago I built a simple app to keep birthdays in check. It was... fine. Rails web app, did the basics.
But I still had to go to the app to add people, worry about being logged out, just enough friction that I'd forget or not bother. So a couple of months ago I turned it into a whatsapp-only app.
It now runs entirely through whatsapp (with a few webviews chucked in when needed) and it's super smooth. I can add birthdays with natural language, yeet in a few at a time, just record a voice note and get on with my day. And it sends me email reminders that save my bacon for now nearly 100 friends and family and their ruddy keeds.
Anyway, thought it might be useful for others. have at it.

value: Show HN: I built a WhatsApp bot to help you remember birthdays

author: jonnyburch


value: PetriLahdelma

value: Show HN: Rhythmguard – spacing scale enforcement for CSS and Tailwind

author: PetriLahdelma


value: Show HN: SyncVibe – Code with friends in the terminal, each with your own AI


value: Show HN: Find things without remembering tags


value: mikezx

value:
I wanted to see if I could one-shot build a dictation tool for my own use. I built it. Surprisingly easy, except for all the nuanced edge cases I ended up having to throw in since then.
Then it kept growing. Wouldn't it be cool if i could talk to a coding agent directly, like the Star Trek computer? Oh, maybe like Iron Man (says everyone..).
Why am i spinning up another terminal to run research on this? Hey Iris, can you run the research and throw it in the Vault? Let me know when you're done. Send a Slack message, check my emails, red team that PR request.
Super Voice Mode is now the thing I use for work — coding, research, thinking out loud, orchestrating agents. It sits above every tool on your Mac and gives you one consistent voice layer across all of them. Claude Code, Codex, Gemini, local models, whatever's running. Transcription is local, no audio saved no internet needed.
The whole thing was built spec-driven with AI coding agents — Claude Code, Codex, the lot. Engineering background, but the agents did the building. Which feels appropriate given what the product is.
The whole thing was built spec-driven (a little vibing) with AI coding agents — Claude Code, Codex, the lot. Engineering background, but the agents did the building. Website design everything Experiment continues.
This is early. There's more coming.
Free tier, no email required. Download and it works.
Happy to get into how the local transcription works, the model integrations, or the agent-driven build process.

value: Show HN: SuperVoiceMode universal voice layer for AI-assisted development

author: mikezx


value: Show HN: CV Mirror – see what 5 ATS parsers do to your CV


value: durovilla

value:
More and more developer tools are adopting the llms.txt standard to build AI-friendly versions of their docs. The problem is that it's very hard to search across them. So I crawled millions of webpages to build Statespace, a search engine for llms.txt sites. And it's free, no API keys required.
You can run plain queries to search across all sites:

  mcp server setup
  vector database embeddings
  oauth2 refresh token

Or scope your queries to a specific site with "site: query"

  stripe: webhook verification
  mistral.ai: function calling
  docs.supabase.com: edge functions auth

Quotes work like Google for exact phrases:

  "context window limit"
  vector database "semantic search"
  stripe: "webhook signature verification"

This is still a work in progress, so looking for feedback and beta testers!
- Search for humans (website): https://statespace.com/
- Search for agents (CLI, SDK, MCP, skill): https://github.com/statespace-tech/statespace

value: Show HN: I built a search engine for llms.txt sites

author: durovilla


value: frabonacci

value:
Hi HN, Francesco from Cua here.
I hacked this project together last weekend, inspired by the Codex Computer-Use release and lessons learned from deploying GUI-operating agents for our customers.
The main problem: when a UI automation process controls a desktop app today, it usually takes over the human’s session. Your cursor moves, keyboard focus gets stolen, windows jump to the front, and you have to stop working until the agent is done. That is why we have historically avoided encouraging users to run these processes directly on their host machine, instead relying on VMs or GUI containers for concurrency and background execution.
But computer-use - the tools we give agents to operate computers like humans - does not scale cleanly that way. As models get smarter, agents need to share hosts safely, run in the background, and avoid collisions with the human or other agents using the same machine.
We realized macOS has no first-class API for "drive this app without touching the cursor". CGEventPost routes through the hardware input stream, so it moves your cursor. CGEvent.postToPid avoids the cursor warp, but Chromium treats those events as untrusted and silently drops clicks at the renderer boundary. Activating the target app first raises the window and pulls focus, defeating the point of background execution.
Cua Driver is our attempt at a real fix: a background computer-use driver for macOS that lets an agent click, type, scroll, and read native apps while your cursor, frontmost app, and Space stay where they are. The default interface is a CLI, so it is easy to script or call from any coding agent shell.
Try it on macOS 14+:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/trycua/cua/main/libs/cua-d...)"
The first internal use case was delegated demo recording. We ask Claude Code to drive an app while 'cua-driver recording start' captures the trajectory, screenshots, actions, and click markers. The result is an agent-generated product demo, Screen Studio inspired.
Other things we have used it for:
- Replacing Vercel’s agent-browser and other browser-use CLIs. With Claude Code and Cua Driver, you do not need Chrome DevTools Protocol at all.
- A dev-loop QA agent that reproduces a visual bug, edits code, rebuilds, and verifies the UI while my editor stays frontmost.
- Personal-assistant flows that use iMessage from Claude Code, Hermes, or other general-purpose agent CLIs.
- Pulling visual context from Chrome, Figma, Preview, or YouTube windows I am not looking at, without relying on their APIs.
What made this harder than expected:
- CGEventPost warps the cursor because it goes through the HID stream.
- CGEvent.postToPid does not warp the cursor, but Chromium drops it at the renderer IPC boundary.
- Activating the target first raises the window and can drag you across Spaces.
- Electron apps stop keeping useful AX trees alive when windows are occluded without a private remote-aware SPI.
The unlock was SkyLight. SLEventPostToPid is a sibling of the public per-PID call, but it travels through a WindowServer channel Chromium accepts as trusted. Pair it with yabai’s focus-without-raise pattern, plus an off-screen primer click at (-1, -1), and the click lands without the window ever raising.
One thing we learned: the right addressing mode depends on the app. Native macOS apps usually have rich AX trees, Chromium-family apps often need a hybrid of AX and screenshots, and apps like Blender or CAD tools may expose almost no useful AX surface. The mistake is defaulting to pixels everywhere - or defaulting to AX everywhere.
Long technical writeup: https://github.com/trycua/cua/blob/main/blog/inside-macos-wi...
I would like feedback from people building Mac automation, agent harnesses, or accessibility tooling. If it breaks on an macOS app you care about, that is useful data for us.

value: Show HN: Drive any macOS app in the background without stealing the cursor

author: frabonacci


value: gjlmotea

value:
In this fast-paced, AI-exploding era, I felt a strong desire for a slower, more deliberate pace.
I built a 3D interactive world map: https://world.gjlmotea.com/
Lately, time seems to be flying by. I've been building a lot of quirky, experimental projects, but honestly, my mood has been quite restless and low. There are just too many options and new technologies emerging every day—choice paralysis sets in before I can even figure out what I truly want to build.
But this project is different. It’s more grounded, human, and carries a sense of warmth. I wanted to create an immersive experience with a Renaissance, antique parchment aesthetic.
Features:
Explore: Browse different countries and click on nations or architecture for detailed information.
Data Layers: Toggle between various global map modes including Architecture, Culture, Academia, Commerce, and Military.
Themes: Multiple visual themes to switch between.
3D Architecture: Scale the models of buildings (like Taipei 101) to your liking.
Global Enterprises: It maps the top 100 global commercial empires across Finance, Industry, Food, and Tech—from TSMC, MediaTek, and Foxconn to everyday chains like McDonald's.
The Macro Perspective:
As you zoom out from the map, the perspective shifts:
First, you can observe constellations and celestial bodies.
Keep zooming, and you'll see the 8 planets of our Solar System.
Zoom out even further, and you are met with a beautiful view of the Milky Way.

value: Show HN: Mvndvs TERRARUM – A Renaissance-style 3D world map

author: gjlmotea


value:
Hi HN, I built Loom because I wanted less agent tooling, not more.
My coding-agent workflow had outgrown PLAN.md. One file kept turning into the partial spec, research log, task queue, evidence log, review notes, handoff summary, and feature doc. And stratifying it typically ends up in disparate scratch files with no canonicity.
One solution is to add more surfaces: a spec tool, an issue tool, a memory system, a review prompt, a planning plugin, a workflow package. But that brings two problems: There is a lack of genuine cohesion, no emergent knowledge graph. And some tools try to do too much and take over your workflow.
I wanted one repo-native work record/grammar with enough structure for the agent to organize itself.
That became Loom.
If you want to stop reading and try it, the repo has install paths for Claude Code, OpenCode, Codex, Cursor, and Gemini CLI as well as more detailed write up in the README:
https://github.com/z3z1ma/agent-loom
How it works:
You start a task in a Loom-enabled repo.
The agent first asks where the work belongs.
If it needs discovery, it goes to research.
If behavior is unclear, it goes to a spec.
If sequencing is unclear, it goes to a plan.
If work is live, it goes to a ticket.
If something was observed, it goes to evidence.
If risk needs pressure, it goes to critique.
If the project learned something reusable, it goes to wiki.
That project vocabulary is the core of Loom. It's a knowledge graph.
The individual pieces are familiar. Beads has local task memory. Spec Kit has executable specs. Superpowers has development oriented skills. ECC has compounding. GSD has context engineering. Ralph has clean execution loops.
Loom’s contribution is the unification and composition. It gives every kind of work a place in the repo, then teaches the agent how to move between those places.
Once implementation is ready, the parent compiles a packet.
A packet is not just a prompt. It is a bounded worker contract compiled from upstream project state: constitution, initiative, research, spec, plan, ticket, evidence, critique, source context, write scope, verification posture, stop conditions, and output shape.
The worker gets a clean context window, but not an empty one. Less context by volume, better context by shape.
Then the loop runs the other way.
After the worker returns, the parent reconciles the result into the ticket, records evidence, routes critique when needed, and promotes durable learning through retrospectives. A rejected path can move into research. A settled explanation can move into wiki. A clarified behavior can move into a spec. A changed sequencing lesson can move into a plan.
The next packet is better because the project is better.
There is no service, daemon, MCP server, workflow engine, or runtime database. The graph lives in Markdown files. Agents inspect it with normal tools: grep, find, git, cat, awk, sed, and shell pipes.
I would like criticism from people using coding agents on projects that span more than one session. The most useful feedback would be where this feels helpful, where it feels like process, and which project layers are wrong/right.

value: Show HN: Loom – A Markdown knowledge graph for better coding-agent execution


value: Zavora

value: Show HN: Create Professional Excel Files with AI Agents

author: Zavora


value: aggre

value:
Every x402 settlement in this repo carries a ZK proof bundle in PAYMENT-RESPONSE: issuer identity, payment settlement, and data integrity, independently verifiable. Live on Base Sepolia.
(Recap: x402 is Coinbase's revival of HTTP 402. Server returns 402, client signs an EIP-3009 USDC auth on Base, retries with PAYMENT-SIGNATURE, facilitator settles. Spec: https://x402.org)
I'm the CTO of FRAME00. We've been building Lemma, a document oracle that binds ZK attribute proofs to on-chain Merkle commitments. Three weeks ago I started asking whether the same proof bundle could ride inside an x402 round trip instead of a separate verification step. This repo is the answer.
The gap x402 leaves: the server gets a wallet address and a tx hash. It doesn't know who authorized the payment, under what policy, or whether the data arrives intact. As agents become the payer, a wallet address is an anonymous primitive, not a principal.
What this adds to the x402 flow:

  Phase 1  Agent hits any x402-protected endpoint with @x402/fetch.
           -> standard 402 with accepts[]. Nothing Lemma-specific.
  Phase 2  Wallet signs EIP-3009 USDC auth, retries with
           PAYMENT-SIGNATURE, facilitator settles.
           -> PAYMENT-RESPONSE carries extensions.lemma =
              { proof, inputs, circuitId, generatedAt }.
              A registered x402 extension, not a sidecar.
  Phase 3  Agent checks SHA-256(body) against
           attributes.integrity in the proof. No round trip.
  Phase 4  POST /query for BBS+ selective disclosure. Released
           only when the caller's x402 payment satisfies
           condition.circuitId = "x402-payment-v1" -- today this
           is API-level access gating; the binding is moving
           into the BBS+ challenge itself (see below).

The demo wraps Phase 1 in a free GET /article returning an X-Lemma-Attestation header pointing at /verify/:hash. Point @x402/fetch at any paid resource directly and Phase 1 is just standard 402.
Server side is a drop-in for @x402/hono:

  import { paymentMiddleware, x402ResourceServer,
           ExactEvmScheme } from "@lemmaoracle/x402";

  const server = new x402ResourceServer(facilitatorClient)
    .register("eip155:84532", new ExactEvmScheme());
  app.use("*", paymentMiddleware(routes, server));

paymentMiddleware auto-attaches a hook that writes extensions.lemma into PAYMENT-RESPONSE. Route handlers don't change.
Agent side uses stock @x402/fetch; no Lemma SDK on the client:

  const x402Fetch = wrapFetchWithPayment(fetch, client);
  const res = await x402Fetch(`${WORKER_URL}/example/verify/${hash}`);
  const settle = JSON.parse(atob(res.headers.get("PAYMENT-RESPONSE")));
  // settle.extensions.lemma = { proof, inputs, circuitId }

What this doesn't claim:

  * Data source is not on-chain. We bind SHA-256 of the body
    to a chain commitment; not authorship.
  * The issuer's BBS+ key is the trust anchor. Identity,
    settlement, and integrity proofs are independent.
  * Facilitator is a liveness dependency (x402 design).
    Fail-closed. Swap or self-host any x402-compatible one.

What is shipping next:

  * Agent-side identity. did:key -> agentId with role, scope,
    spendLimit. Lifts the paying wallet from anonymous
    primitive to verifiable principal.
  * Cryptographic settlement binding. Today condition.circuitId
    is enforced at the API layer; the BBS+ proof itself
    verifies offline once obtained. We are folding the x402
    settlement record into the BBS+ challenge so re-use
    without a fresh payment becomes infeasible at the
    proof layer.

Both are on-axis with the thesis: payment is the trigger; verifiable trust rides on top.
Repo:  https://github.com/lemmaoracle/example-x402
x402 SDK:  https://www.npmjs.com/package/@lemmaoracle/x402
Lemma SDK:  https://www.npmjs.com/package/@lemmaoracle/sdk
Questions on the circuit layer, BBS+ binding, or DID roadmap welcome.

value: Show HN: We put ZK attribute proofs inside x402 payment headers

author: aggre


value: pwillp

value:
Track credits available on cards, mark them as used, automatically shown again in active on renewal - see credits (even used or muted) across cards without bloat.
Lists all airport lounges at airport (across amex, capital one, chase, priority pass) + filter down by the cards you have
Additional linking to the waitlist for certain airport lounges
Category page to see which card is best for a specific category & nearby.
Add & track offers on your Amex/Chase cards across cards with the chrome extension
Track realized value on cards, points/certificate/redemption tracking, and active transfer bonuses.

value: Show HN: Credit card super app – track credits, find lounges, add offers (iOS)

author: pwillp


value: Show HN: Decaf – rewrites webpage comments using on-device Gemini Nano


value:
Hi HN, I’m Matt Mahowald, and together with my cofounder John, we’re launching the public beta of Ragnerock today.
As a data scientist, you spend the majority of your time wrangling data. Even though you might have a set of techniques and tricks you like to use, how exactly you treat a particular source of data tends to be fairly bespoke, so you end up writing custom logic each time.
Ragnerock was born from the observation that modern LLMs can be used to automate a lot of the grunt work involved in this process, while still allowing for fully customizable pipelines. What’s more, by leveraging techniques like constrained decoding, it’s possible to provide a unified query interface regardless of the data source - bridging raw data sources like text and images with your existing structured data living in your databases.
Ragnerock has four main components:
- A workflow designer that lets you build LLM-driven data processing and analysis pipelines
- A job orchestration layer that runs those workflows
- A query interface which lets you inspect the results of those workflows with plain SQL
- A notebook system which is 100% API-compatible with Jupyter and runs on your existing kernels, so you can easily pull data into your existing environments and analyses
Ragnerock also supports bring-your-own AI (OpenAI, Anthropic, and Google APIs), databases, and blob storage, so you can join with your existing datasets and have all outputs flow to your data lake. We’re particularly excited about our web crawling feature, which allows you to scrape websites and trigger workflows on updates: for example, you might point Ragnerock at your favorite blog and run a workflow to assess posts for topics and sentiment.
You can try it out at https://www.ragnerock.com ; no credit card needed and the first 20 hours of compute are free. It’s an early-stage product so we’re especially interested in feedback.
Happy to answer any questions - John and I will be around in the comments today.

value: Show HN: Ragnerock, an AI data analysis tool


value: rowbin

value: Show HN: Stelae – €19.90/year WordPress, exported to static HTML

author: rowbin


value: techfrog

value: Show HN: Interactive site for learning sailing physics

author: techfrog


value: turtledevio

value:
The main reason I built FastSvelte is that every other SaaS boilerplate is Node and SSR based. I prefer a separate backend + SPA pattern, and I use Python for the backend because most of the ideas I ship are AI related — a Python backend really helps with that.
I built FastSvelte from months of work across several real projects. Even then, it took me a few months to make it a complete product. Now I use it as the base for everything I ship. I've sold several at $199 so far and got very positive feedback.
The docs speak for the project. Let me know your feedback.
Thanks

value: Show HN: FastSvelte – FastAPI and SvelteKit Starter Kit for Python SaaS

author: turtledevio


value: jmbuilds

value:
Quick thing I made recently on Time Keep (https://www.timekeep.cc) that I'm excited to use: any timer, alarm, countdown, stopwatch, or sleep schedule can be popped out into its own little window and on Chrome/Edge it can be locked over others on your desktop.
On Chrome and Edge it uses the Document Picture-in-Picture API so the window stays on top of everything else while you work. Pause from either window and the state stays in sync (BroadcastChannel turned out to be a good fit for this). Firefox and Safari just use a normal pop-up since neither has shipped Document PiP. On mobile it opens fullscreen in the current tab because phones don't really expose multi-window to the web.
It also requests a wake lock so your screen doesn't fall asleep while a timer's counting down. That matters on a phone where the display would otherwise dim and lock.
The use case that drove me to do this: I'm working, have to do something at X time coming up, and I want a countdown in my face, but it's off on my phone or behind other windows. Now it just sits in the corner where I want it.
(There's also been a bunch of tweaks / new tools added since the last time I posted: a day planner, overlap zones, an "it's 5 o'clock somewhere" page ... for anyone who remembers the v1 HN Show post a month or so ago.)

value: Show HN: Browser timers that float above your other windows

author: jmbuilds


value: cochranblock

value: The flywheel to getting developers to making Rust binaries so we can collectively get us to deep space exploration packages before I die, Will you join the call? You sick of that blue pill?

value: Show HN: How to become an Anti-founder, THE MANUAL

author: cochranblock


value: Show HN: PastePlop – yet another Mac clipboard manager


value: fesens

value: Show HN: Auto-Architecture: Karpathy's Loop, pointed at a CPU

author: fesens


value: Show HN: I built a dating SIM that prepares you for your date


value: absurdwebsite

value:
I’m building Art Coding Lab - a step-by-step learning path for creative coding.
The idea is simple:
Start with the very basics:
coordinates, circles, variables, loops.
Then slowly grow into:
geometry, animation, trigonometry, generative systems and visual art.
Not preset effects.
Not random YouTube tutorials.
Not "copy this cool sketch and maybe understand it later".
I want it to feel like one long guided adventure - made from small micro challenges where you write code, press play, see what happens, and keep building.
It uses p5.js / JavaScript, but the focus is not learn syntax for the sake of syntax.
The focus is learn code by making visual things.
Right now I have a prelaunch page with a few free lessons and a small live demo.
You can try 3 free lessons, see the demo, and join the prelaunch list: artcodinglab.com
I’d love feedback from people who have always wanted to try creative coding but never really knew where to start.

value: Show HN: Art Coding Lab – Learn Creative Coding Through Micro Challenges

author: absurdwebsite


value: skysniper

value: I typically run multiple Claude Code sessions at the same time. Sometimes I need my existing sessions to work together, but CC does not support inter-session messaging so I have to be the message bus. I was tired of doing it manually so I built this plugin to enable inter-session messaging. It's implemented using Claude Code's Monitor tool, real-time delivery. Does not require claude.ai login. No configuration needed. Hope you enjoy it.

value: Show HN: Inter-session messaging between Claude Code sessions

author: skysniper


value: pzxc

value:
I used to run a flash games website (SWF files) years ago. I've made a few games of my own. I'm also an avid gamer and love to play games of all kinds.
I'm also a software engineer, and a few days ago I decided I wanted to run a games website again. So I bought the domain gamevibe.us and with the help of Claude I've been vibe-coding one video game every day since.
Happy to answer questions, take feedback, etc

value: Show HN: Vibe-coding video games with Claude (Day 15: Mahjong)

author: pzxc


value: algomaniac

value: Show HN: Open Bias – proxy that enforces agent behavior at runtime

author: algomaniac


value: sircipher

value: I built this using the official UK government forecourt fuel price feed.<p>The map aggregates the latest petrol and diesel prices by county, with filters for fuel type and metric. Clicking a county shows the cheapest forecourt, average price, spread, and station count. The feed covers roughly 8,000 UK forecourts and refreshes every 30 minutes. Retailers publish the prices, so there can still be gaps in the data/stations but it's getting better over time.

value: Show HN: I mapped the latest UK fuel prices by county

author: sircipher


value: zuzuleinen

value: Show HN: Algotutor – Practice Go with spaced repetition in your AI agent

author: zuzuleinen


value: DslsDZC

value:
HIC is a capability-secure OS kernel. It isolates system services inside Ring 0. Each service occupies a separate physical address range. The MMU enforces the boundary.
There is no kernel IPC path. A cross-domain call is three instructions: call into an entry page, bt to test a domain ID against an authorization bitmap, jmp into the business logic. No privilege switch occurs. No kernel code runs during communication. Parameters travel in registers or shared memory.
A caller cannot name the address of business logic because no mapping exists in its page tables. The MMU hardware will not produce that address. This invariant holds regardless of what code the attacker executes.
The same guarantees hold without an MMU. On an 8086, segment descriptors replace page tables. The caller's LDT contains no descriptor for the business logic segment. Hardware refuses the far jump.
The architecture is documented in full. The critical instruction sequences are in the repository. You can count the cycles yourself.

value: Show HN: HIC – Same-Ring Isolation, 4ns IPC, Runs on 8086

author: DslsDZC


value: nlessard

value: Show HN: A DIY, MITM Keyboard Sniffer Built Around an RP2040

author: nlessard


value: asenna

value:
Hey HN. I built a dead-simple CMS for your AI agents — https://slopit.io
Kept it minimal and agentic-first. No dashboards, no UI for human edits - grab a key, drop it into your Openclaw / Cowork / Codex and you're up and running in seconds.
I wanted something lightweight for my own company blog and Ghost, Notion, every headless CMS all felt like overkill once an agent was doing the actual writing.
Launch post (slopped by my own claw) — https://blog.slopit.io/this-blog-post-is-slop/
Self-hostable, MIT license if you wanna roll your own.
Lots more planned, happy to take requests.

value: Show HN: SlopIt – A dead-simple CMS for your AI agent

author: asenna


value: ksri

value: Show HN: CLI to for working with complex Google Docs using Markdown

author: ksri


value: cloked

value: Hi HN, I built a simple TUI for viewing and editing .md files in the terminal. More and more markdown files keep appearing in our projects, and I found myself needing a quick way to view(with syntax highlighting) and edit them without leaving the terminal, so I built this

value: Show HN: A TUI for Markdown view an editing

author: cloked


value: Show HN: Nomie is an open-world self care game to replace doomscrolling


value: wasnaga

value:
Hi HN — I built this in my off-hours over the last 3 months. Sharing now because I just filed the provisional patent yesterday (US 64/050,345) and the repo is freshly public.
The frustration that started it: every time I use a coding agent (Cursor, OpenCode, Aider, Claude Code, etc.), it eventually loses context — forgets the SSH address, re-asks for the DB password, tries to redeploy to localhost when the server is remote. The "proper" answer is "set up 10 specialized agents with short context windows." I'm too lazy for that.
The conventional architecture is the actual problem. Every turn re-sends the full conversation, the model recomputes attention from scratch, and cost compounds with conversation length. Long-running agents are economically infeasible by design.
What I built: NLS captures the model's own computed K/V states (and recurrent states for hybrid models like Qwen3.5-MoE) after each turn, persists them to disk, and re-injects them into the cache on the next turn — at the right positions, with proper alignment. The model behaves as if it had the full conversation in context, but the conversation is never re-sent.
Validated across three settings, in increasing order of stringency:
(1) Standard conversational recall: 5/5 on a 5-fact production test. Baseline check.
(2) LongMemEval (published cross-session benchmark, ~19K sessions). On the 18-question "fully answerable" subset:

  Condition                                              Qwen 3.5    Qwen 3.6
  Memories provided as TEXT in the prompt                8/18        9/18
  Same memories delivered as KV-state via NLS            8/18        9/18

  Text and KV produce identical scores. Both fail the same 9-10 questions for the same reasons (multi-hop temporal reasoning that exceeds model capacity). When the architecture's inputs are equivalent, the outputs are equivalent.

(3) Real agentic loop with OpenCode (TUI coding agent, used NLS as its OpenAI-compatible backend). It scaffolded a multi-phase coding project ("ICF Coaching Evaluation Tool"). Then in a separate session, after a full TUI restart with no chat history, I asked "what's the project about?" — it returned a rich, specific description naming the project, the stack, and the architectural decisions. 124 user-typed tokens delivered 18,751 tokens of stored prior-session context. 99.3% prompt-token savings on the recall path. 4/4 recall across the test scenarios.
Honest caveats:
- The plugin source is proprietary (patent pending). The repo has docs, benchmarks, journey — not the implementation.
- Single-GPU validation. Multi-GPU not tested yet.
- Solo, no team yet.
- Provisional patent only — non-provisional and PCT in the next 12 months.
What I want from this thread: tell me where you'd stress-test it. What workload breaks it? Anyone here from an inference provider — does this overlap with what your stack already does, or is this a new place?
Demo (conversational): https://punkrecords.live
Demo (agentic, OpenAI-compatible): https://api.punkrecords.live/v1

value: Show HN: An agent that remembers across sessions (no chat history)

author: wasnaga


value: vitalipom

value:
Have you ever heard of Cafe keyboard from Samsung’s app store? It’s very similar to it, but here there are effects that… Make you feel like your phone is on steroids, and in a good way.
Effected Keyboard 2 feels convenient when you press the keys with its gentle feedback (if you disabled heavy animations), it feels more mature and natural with its look and feel, has multiple languages, easy gestures that trigger useful features: if you swipe left from spacebar you have two different layouts of symbols, on swipe right from spacebar you change language and on swipe up from spacebar you get a mini popup keyboard where you can find undo/redo, select text and copy/paste with a clipboard. Sounds familiar?
Effected Keyboard 2 is based on Anysoftkeyboard and has been developed on top of it since 2013(!) It has some paid features, even though to be honest I really tried to not be greedy with them. There are 3 packs, $5 each - basic one with themes and simple effects as you type, flying letters one - which pops flying letters from the keyboard to the app itself and the immersive effects which blow the minds of your friends when you show it them.
Effected Keyboard 2 is an app for Android, even though with its tiny touches such as the round corners (which are everywhere) it reminds me an Apple product.
Comparing to Anysoftkeyboard, Effected Keyboard 2 has a new set of Emoji which look more stylish. It has additional themes. And its function keys are more of Gboard styles, with an option to wider spacebar or a bit shorter one in favor of additional punctuation keys in the button row.
Effected Keyboard 2 might not replace your keyboard completely since it doesn’t have the AI typing predictability and AI level of spelling correction. But! And that’s an important “but” — this keyboard is all about a different experience and just like a trip to Eurodisney where you would like to stay for a couple of nights, but not to live there forever, then same here with this keyboard. It deserves any bit of attention it’d get from you.
https://youtube.com/shorts/lj-jIrZ6XZ8
https://play.google.com/store/apps/details?id=com.vitali.pom...

value: Show HN: Effected Keyboard 2 – Effects as You Type

author: vitalipom


value: francescopace

value: Show HN: PeopleMesh, Semantic Search for People

author: francescopace


value:
I made a TUI served over ssh to create and manage virtual machines.
You can create and tinker with some machines for free of course.

value: Show HN: Order a VPS without ever leaving your terminal


value: iondodon

value: Show HN: Wayland Window Switcher

author: iondodon

title: Show HN: Wayland Window Switcher


value: druid

value: Show HN: ClusterdOS – Kubernetes without the platform team

author: druid


value:
MCP lets LLMs call real tools, databases, file systems, APIs. The spec has no security model. An agent is either off or full admin, and "trust the model" is the current answer.
Cordon is an open source MCP gateway. It's a transparent proxy that sits between your LLM client and your MCP servers. Every tool call flows through it. You define policies per tool: allow, block, approve, read only, log only.
The piece I haven't seen elsewhere is synchronous human-in-the-loop approvals. When a tool call hits an "approve" policy, the agent pauses and I get a terminal prompt (or a Slack Block Kit message) with the exact args. I approve or deny. The agent resumes. Every decision is logged.
Install: `npx cordon-cli init` auto-patches your Claude Desktop config in about two minutes. Works with Claude Desktop, Claude Code, Cursor, Windsurf, and any stdio MCP client.
Open source, MIT. Published to the official MCP registry as io.github.marras0914/cordon. There's also a hosted dashboard for centralized audit logs, but the gateway runs local and the CLI is fully offline.
Happy to answer questions about the threat model, why I built it as a proxy vs. a client-side wrapper, or how write-detection works without me enumerating every dangerous tool name.
GitHub: https://github.com/marras0914/cordon
Writeup with config examples: https://dev.to/marras0914/mcp-has-no-security-model-heres-ho...
Approval flow demo: https://i.imgur.com/nDAVxqN.gif

value: Show HN: Cordon – Security gateway for MCP tool calls with HITL approvals


value: psonthalia

value: Show HN: InterviewDen – Free voice AI mock interviews for SWE, IB, quant, more

author: psonthalia


value: toddh

value: Show HN: I built another to do list. But it does a lot

author: toddh


value: alpadurza

value: Beads tables (Steve Yegge's) for issue tracking. Can view git trees, terminals, issue tables, notes, and files all on one screen. Can connect multiple machines via private network (like tailscale)

value: Show HN: 49Agents – 2D Canvas IDE for Orchestrating Agents, Repos, Issues

author: alpadurza


value: Show HN: Niimbot Label Printer desktop app with Pretix integration


value: arvindravi

value: Show HN: Filedge – parse SEC filings for $0.05 via x402, no keys

author: arvindravi


value: tlorents

value: Show HN: 20-endpoint image API (remove bg, upscale, face restore)

author: tlorents


value: Himred

value:
I've been working on GeoTraceroute for a while and just shipped v2.3
with submarine cable inference.
A few things that might interest HN:
- 320 community-contributed nodes across 50 countries, all volunteer-run
- Three views: 3D globe with day/night rendering, 2D map, and a
  topological mode that infers submarine cable routing
- The submarine cable inference is the part I find most interesting.
  Since cable routers don't respond to ICMP, the underwater segments
  are invisible to standard traceroute. The tool detects ocean crossings
  by geolocation delta between consecutive hops, then infers the likely
  cable using a geo graph of landing points with A* pathfinding.
  I have no way to validate this — if anyone has ideas, I'd love to discuss.
Coverage is good in EU and US but thin in Asia, Africa and South America.
If you want to contribute a node: https://geotraceroute.com/join
Salim

value: Show HN: GeoTraceroute – Traceroutes on a 3D globe and submarine cables

author: Himred


value: wilbertliu

value: Show HN: I built an AI agent to diagnose technical issues

author: wilbertliu


value: hunvreus

value:
I built that initially for an AI chat bot that allows teams to perform DevOps tasks straight out of Slack/Teams (with proper permission control, obviously).
Useful to let developers perform mundane tasks, or help coordinate incident response.
I ended up using it myself on my own machine to manage Hetzner and AWS boxes. I thought that may be useful to others.
The default policy should be good enough, but if you don't like living dangerously, you can set it to `paranoid`.
Install: `pi install npm:pi-hosts`
GitHub: https://github.com/hunvreus/pi-hosts

value: Show HN: Pi-hosts – Give the Pi coding agent access to your servers

author: hunvreus


value: darkstarsys

value:
I've been really gratified to see a bit of uptake of pcons in the open-source community, so I thought I'd post an update since it's up to v0.14.1 now. Pcons is a new open-source build tool that's the best of SCons and CMake with fewer of their problems.
Since v0.7 (last HN post), there's now a porting guide, LaTeX toolchain, full C++20 module support, Fortran toolchain (including MODULE/USE), WebAssembly via WASI and EMSDK. It can generate pkg-config files, finds MSVC more reliably, added Ninja restat support for even faster builds, better target.depends(), better logging and debugging, CMake-style template-based config headers and a lot of improvements and fixes.
I was one of the original developers of SCons and helped maintain it for years. I love that Python is the configuration language — it makes build descriptions incredibly flexible. But over time, working with CMake on other projects, I came to appreciate things SCons doesn't do as well: the separation between describing a build and executing it, transitive dependency propagation, package manager integration, and modern python semantics. I'd been thinking about a fresh start for years but never had the time. Recently, working collaboratively with Claude Code, it finally became feasible. So, meet pcons.
You can use it as `uvx pcons` for true zero-install (great for other open source projects). There's a comparison with other common build tools here: https://github.com/DarkStarSystems/pcons/blob/main/COMPARISO... — corrections and updates appreciated!
Major features as of v0.14.1:
- Toolchains for GCC, LLVM/Clang, MSVC, and clang-cl with auto-detection, LaTeX, gfortran, WebAssembly etc.
- Generators for Ninja, Makefile, Xcode, compile_commands.json, and Mermaid/DOT dependency diagrams
- Can create installers: msix on Windows, pkg/dmg on Mac, tgz on Linux
- Package management via pkg-config, Conan 2.x, and a pcons-fetch tool for building dependencies from source
- Compiler cache support (ccache/sccache), semantic presets (warnings, sanitizers, LTO, hardening), cross-compilation presets (Android NDK, iOS, WebAssembly)
- Platform-specific helpers: macOS bundles/frameworks/.pkg/.dmg, Windows manifests/MSIX, and an msvcup module for installing MSVC without Visual Studio
- An extensible module/add-on system for domain-specific tasks
- Debug tracing (--debug=resolve,subst) with source-location tracking on every node
- Plenty of examples included, unit tests for all features, tested on Mac, Windows and Linux
It's under active development — ready for experimentation, but it's quite stable — enough for light production. I'd love bug reports, feedback on the API design and what you'd want from a modern Python-based software build system. I take my tools seriously and intend to support it well, so please try it out!
Open source, MIT licensed.
GitHub: https://github.com/DarkStarSystems/pcons | Docs: https://pcons.readthedocs.io | PyPI: `uvx pcons` or `pip install pcons`

value: Show HN: Pcons: new software build tool in Python, inspired by SCons and CMake

author: darkstarsys


value: jftuga

value:
mac-screen-search captures your screen (or takes a glob of existing image files), OCRs the text, and draws colored boxes around every match. Use the `-r` flag to have it fill those boxes solid for redaction or `-b` to blur.
It also handles batch processing (overwrites in-place, preserves mtime), enhanced OCR for degraded images (Zoom calls, transparent terminals) with `-e` flag, and Levenshtein fuzzy matching to catch OCR misreads with the `-d N` flag.
It includes: screenshot and file-glob modes, exact/fuzzy whole-word matching, redact/blur/outline annotation, multi-monitor, multi-term search, list mode, and output control.
Free, open source, written in Swift. Single file, no deps beyond macOS itself.

    brew install jftuga/tap/mac-screen-search

https://github.com/jftuga/mac-screen-search
Disclaimer: Vibe coded with Claude Opus 4.6.

value: Show HN: mac-screen-search: CLI find, highlight, redact text on screen, in files

author: jftuga


value: nongquy

value: Show HN: Claude Exporter – Export Chats to PDF/Word/Notion

author: nongquy


value: petercsauer

value:
There's dead space on both sides of the Dock. Nobody uses it. So I stuck widgets there. Music with synced lyrics (Spotify + Apple Music), calendar, weather, a Pomodoro timer, system stats. They sit in little glass panels and stay out of the way until you look down.
The other thing: hover a Dock icon and macOS shows you the app name. Thanks, I forgot what Safari was called. Docktor replaces that with live thumbnails of every window for that app. Click one, you're there. Same idea powers a Cmd+Tab replacement. Actual window previews instead of a beauty pageant of app icons.
I spent a lot of time matching the system look. Same blur radii, same animation timing. It should feel like part of the Dock, not something bolted on.
Native Swift. No Electron, no account, no telemetry.
First beta goes out next week. Looking for testers: https://petercsauer.github.io/docktor-releases/
Testers get lifetime access free. After that it'll be $10 one-time for 20 seats, 60-day trial. Share it with your whole family or team. No subscription, ever.
I'm also building a full Dock replacement for the Liquid Glass haters. Not shipped yet but it's next.
43s video: https://youtu.be/iI1zkkPG6hQ

value: Show HN: Docktor – I put live window previews and widgets on the macOS 26 Dock

author: petercsauer


value: plonk-er

value:
Plonk 5 new places on a 3D globe every day. Test your geography, learn, and compete on the leaderboard.
I've played similar games for months and didn't like that the features I wanted were paywalled (ex: better resolution, being able to play previous days, private groups).... so I made Plonk.
Built with Globe.GL

value: Show HN: Plonk.world – Daily Geography Game

author: plonk-er


value: HatemDabet

value: Built this because most file sharing tools either require accounts, have size limits, or store your files indefinitely. ShareNova is browser-based — live transfers are unlimited in size, no account needed for the receiver, and files aren't stored permanently on our servers. Uses WebSocket relay. Free tier available. Honest feedback welcome.

value: Show HN: ShareNova – Browser file sharing, no account, no limits, no storage

author: HatemDabet


value: mcohrs

value:
I spent 4 months job searching with no callbacks. ChatGPT kept inventing stuff I never did. Teal and Rezi made me edit a base resume per job, which is what I was trying to skip. I built PatchWork instead. It takes everything you've ever written about your career, merges it into one profile, and generates a tailored resume per job description.
The hard part was deduplication. The same accomplishment shows up across five resumes worded five different ways, and different metrics survive in different versions. If you just pick one as the winner, you throw away real information. Designed a 5-pass deduplication pipeline, combining deterministic code with AI to get it pretty close to right.
A few of the messier cases:
Umbrella entries. Some resumes list "2018 to 2022, Company X" as one block when it actually covers three different roles. The bullets have to get redistributed to the right titles before anything else happens.
Bullet bleed. The same accomplishment ends up listed under different roles across different documents. Detecting it cleanly is harder than the obvious approach makes it look, because near-duplicates with different metrics are sometimes the same thing and sometimes genuinely two different wins.
Lost context. One version of a bullet has the dollar figure, another has the deadline, a third has the team size. Picking one drops the other two. PatchWork synthesizes across the group so the resume generator can pull whichever detail fits the job.
Project vs experience drift. Same product shows up as an "Experience" entry on one resume and a "Project" on another, sometimes under different brand names. They need to collapse into one thing.
Once the profile is built, applying is paste the JD, click, two minutes. The generator scores each role in the profile against the JD, allocates bullets per role, and writes them with JD keywords baked in for ATS matching. There's a hard ban in the prompt against "spearheaded," "pivotal role," and the rest of the AI-resume cadence that recruiters now filter for.
Every bullet in the output traces back to a source document via a clickable pill. When the model proposes a rewrite it's unsure about, the original wording stays in the resume and a flag icon appears next to it. Click the flag and you see the rewrite, the reasoning, and approve or dismiss it.
Result on me: 0 callbacks in 4 months across roughly 40 applications using other tools. 7 callbacks from the next 10 applications using PatchWork resumes I didn't manually edit. N=1, but the change was sharp enough that I'm running with it.
What's still rough:
The mobile experience. No one keeps resume files on their phone and even if they did, uploading them would be a nightmare. Thinking I'll enable Google Drive access auth to mitigate this in future. Might make it desktop only and "email yourself a link" on mobile for now.
Converting: creating a homepage experience that convinces people to try the tool is hard. I know that people would be impressed by it if they tried it, but I'm not sure how to get over that hump.
Being a resume tool. I think everyone looks down on resume tools because a lot of the ones out there don't do a good job and still make you do so much work. This is the foil to those though, so I'm trying to get that message to be clear and believable.

value: Show HN: PatchWork – A 5-pass dedup pipeline to merge N resumes into one profile

author: mcohrs


value: asteinh

value: Show HN: TiGrIS, a tiling compiler that fits ML models onto embedded devices

author: asteinh


value: Show HN: C# based Kubernetes Operator to deploy SurrealDB


value: Show HN: Agents in Whisper Memos

title: Show HN: Agents in Whisper Memos


value: Show HN: LLM-assisted reconstruction of partially decompiled Minecraft 26.1.2


value: nazbasho

value: SHOW HN: 50k+ Shopify Store Database Leads with Niche Segmentation

author: nazbasho


value: vampiregrey

value: Show HN: AI powered coding interview practice

author: vampiregrey


value: bozdemir

value: Show HN: Rip.so – a graveyard for dead internet things

author: bozdemir


value: lfaoro

value: Show HN: Vibee.sh – SSH-only VM rental. Instant trial, no signup

author: lfaoro


value: aleksul

value:
Python's async web ecosystem is great, but background task processing is still mostly sync-first. Repid is an async-native task queue that generates AsyncAPI documentation from your type annotations - like FastAPI does for REST.
v2 ships with AMQP 1.0, Kafka, SQS, GCP Pub/Sub, Redis Streams, and NATS support. It is the fastest framework that I've benchmarked, and there are lots of cool features, so let me know if it's useful.
Repo: https://github.com/aleksul/repid
Docs: https://repid.aleksul.space
Benchmarks: https://github.com/aleksul/repid-benchmarks

value: Show HN: Repid v2 – open-source async Python task queue with AsyncAPI docs

author: aleksul


value: tellarin

value: Show HN: Benchmarking Tangible Interface Understanding in Long-Horizon Tasks

author: tellarin


value: Osbro

value: Show HN: Lapser Studio – Beautiful timelapse screen recordings effortlessly

author: Osbro


value: sobolevn

value:
Hi, my name is Nikita Sobolev, I am a CPython core dev, Django Software Foundation member, and maintainer of countless Python / Django opensource tools.
Now I am happy to present to you my new project.
Docs: https://django-modern-rest.rtfd.io/
Code: https://github.com/wemake-services/django-modern-rest/
Features:
- No AI slop, but built for the LLM era.
- Blazingly fast.
- Supports Django >= 4.2
- Supports `pydantic2`, `msgspec`, `attrs`, `dataclasses`, `TypedDict` as model schemas, but not bound to any of these libraries.
- Supports async Django without any `sync_to_async` calls inside, tested to work with free-threading builds.
- Fully typed and checked with `mypy`, `pyright`, and `pyrefly` in strict modes.
- Supports content negotiation, has default implementations for `json`, `msgpack`, SSE, Json Lines, and more.
- Strict schema validation of both requests and responses, including errors.
- Supports OpenAPI 3.1 / 3.2 semantic schema generation out of the box.
- Supports all your existing `django` primitives and packages, no custom runtimes.
- Great testing tools with `schemathesis`, `polyfactory`, `tracecov`, bundled `pytest` plugin, and default Django's testing primitives.
- 100% test coverage with 2000+ of carefully designed unit, integration, and property-based tests.
- High security standards.
- Built by the community for the community, not a single-person project.
- Great docs.

value: Show HN: Django-Modern-Rest

author: sobolevn

title: Show HN: Django-Modern-Rest


value: vojd

value: Show HN: I built a Chinese learning app that teaches through sentence patterns

author: vojd


value: strado

value: Show HN: I mapped what's within walking distance for European cities using OSM

author: strado


value: AdobiWanKenobi

value:
I've been experimenting with a project management tool for disciplines that use systems thinking, so government services, infrastructure, energy, (non-software) engineering. Things that Jira, Asana, Monday etc. weren't quite designed for
These fields have deep hierarchy (programmes → projects → work packages → tasks), and need first-class data structures for requirements, stakeholders, interfaces, and risk registers — not just tickets and sprints.
Existing mainstream tools either force you into a flat task-board model or make you duct-tape spreadsheets and CRMs together.
Despatch has a native systems-thinking data model: requirements traceability, stakeholder registers, and multi-level programme structure out of the box.
The demo includes an MCP-based conversational interface — describe your programme and it builds the structure for you.
Would love feedback from anyone in defence, government, infrastructure, or any field where you've outgrown generic PM tools and have been forced back to first principles spreadsheets.

value: Show HN: Despatch – Project management for systems thinking, not just software

author: AdobiWanKenobi


value:
Hi, I've been making a game like chess where pieces have special abilities and health points. This allows for much finer balancing and many more variants compared to regular chess. For example, pieces can push or pull other pieces, deal area of effect (AOE) damage, have lots of health points and be difficult to destroy, use ranged attacks, etc.
There is no video explaining all the rules, but the current version is very similar to chess. These are the main things you need to know:
1) Standard attack - https://www.youtube.com/watch?v=OhGNNlnM7K8
2) Special abilities - https://www.youtube.com/watch?v=XbE_jL7RB0E
Here's the link - https://www.nichess.org/ (you can try it without making an account, just start a new game).
If anyone has any thoughts or suggestions, I'd love to hear them.

value: Show HN: Nichess – Chess with Health Points


value: sidneyottelohe

value: Show HN: Analytics-skills – turn your agent into a senior analyst

author: sidneyottelohe


value: dnosoz

value:
Hi HN,
I'm Danilo. I've been struggling with the limitations of AdamW when fine-tuning LLMs locally. Second-order optimizers (like Shampoo or SOAP) offer significantly better step-convergence by exploiting Kronecker-factored curvature. The problem? They require O(d^2) memory and O(d^3) compute per layer, which immediately OOMs consumer hardware like a 16GB T4 or RTX 3090.
I wanted Shampoo-quality preconditioning on my home setup, so I built SCAO (Sparse Curvature-Aware Optimizer).
It's a PyTorch optimizer that acts as a drop-in replacement for AdamW, but it implements a few strict architectural changes to survive on consumer cards:
1. Adaptive Rank Selection: Instead of full-rank Kronecker factors, it truncates the eigenspace to retain >=95% of spectral mass.
2. Int8 EMA Quantization: The curvature accumulators are stored in symmetric int8, which yields a 4x memory reduction with zero degradation in perplexity.
3. Quantization Stability: Standard Shampoo usually crashes at step 1 during 4-bit QLoRA fine-tuning due to SVD ill-conditioning in quantized spaces. SCAO exploits sparse approximations to bypass this.
4. Fused CUDA kernels: I wrote custom kernels to fix an O(k * m^2 * n) complexity bottleneck in the naive projection implementation.
The Benchmark:
I recently ran a head-to-head benchmark on a single T4 (16GB VRAM) fine-tuning Qwen2.5-3B (4-bit QLoRA, rank 16):
- Shampoo: Failed at Step 1 (SVD mathematical collapse).
- SCAO: 100% stability, peaked at exactly 7.14 GB VRAM, with a smooth loss descent.
It is pip-installable (pip install scao).
I've written a technical report detailing the regret bounds, ablation studies, and scaling laws (published on Zenodo), but I really wanted to get this community's eyes on the CUDA kernels and the PyTorch implementation.
GitHub: https://github.com/whispering3/scao
Technical Report (DOI): https://doi.org/10.5281/zenodo.19870556
I'd love any feedback, code roasts, or questions about the math behind it!

value: Show HN: I built a 2nd-order PyTorch optimizer for LLMs that runs on 16GB GPUs

author: dnosoz