value: thenewvu

value:
It is inspired by Sherlock’s 'crime board', pinning photos and notes, then connecting them with red strings. Todofi lets you do exactly that, and much more.
Todofi helps you organize your notes using a tree-like outliner where notes can be nested within one another. From there, you can use the Whiteboard to map relationships between ideas, Kanban to track progress, Calendar to manage your schedule, and Maps to visualize locations.
Try it out free:
https://todofi.com/

value: Show HN: Todofi – The notes app for Sherlock Holmes

author: thenewvu


value: rafayexalter

value:
Built a Chrome extension for faster link shortening on top of a small project I shared earlier.
One-click shortening
Minimal + fast
Built in a few hours
Would love feedback on usability / features.

value: Show HN: Built a Simple Link Shortener Extension in a Few Hours

author: rafayexalter


value: osihjeremy

value:
Gitinspect is an open-source project I built last week.
It’s basically an agent (pi) that lives in your browser and runs locally.
It uses just-bash mounted on a VFS built on top of the Github API to grep, read and run bash command like a normal agent would.
I’ve been using this to get quick answers on repos/ libraries I don’t want to clone and start local sessions.
It is still very much work in progress and I plan to add a few more features.
I hope this tool can help you too, let me know what you think :)

value: Show HN: Replace "hub" with "inspect" on any GitHub url and chat with any repo

author: osihjeremy


value:
iText is AGPL, use it in a closed-source app and you need a commercial license. I wanted a Java PDF library with a clean API and no licensing strings attached, so that's what Folio is.
The engine is written in Go and ships bundled in the JAR via Panama FFI (JEP 454). No JNI, no separate process. JDK 22+, one flag: --enable-native-access=ALL-UNNAMED.

  Document.create("report.pdf", doc -> {
      doc.add(Heading.of("Q3 Report", HeadingLevel.H1));
      doc.add(Paragraph.of("Revenue grew 23% year over year."));
      doc.add(Table.of(
          new String[]{"Product", "Revenue"},
          new String[]{"Widget A", "$48,000"}
      ));
  });

HTML to PDF is a one-liner:

  HtmlConverter.toPdf("<h1>Invoice</h1><p>Due: $1,200</p>", "invoice.pdf");

Beyond that it covers PAdES signatures, PDF redaction, Flexbox and Grid layout, forms, barcodes, SVG, PDF/A, and encryption. Zero runtime dependencies.
https://github.com/carlos7ags/folio-java
Go engine: https://github.com/carlos7ags/folio
Playground (runs the Go engine directly): https://playground.foliopdf.dev

value: Show HN: Folio Java PDF library – signatures, redaction, HTML to PDF. Apache 2.0


value: yesinteractive

value: Show HN: Disposable inbox for one-time signups (auto-deletes after 1 hour)

author: yesinteractive


value: stagas

value: Show HN: rtdiff – Real-time git diff GUI and AI-assisted commits desktop app

author: stagas


value:
I love C and C++, but setting up projects can sometimes be a pain.
Every time I wanted to start something new I'd spend the first hour writing CMakeLists.txt, figuring out find_package, copying boilerplate from my last project, and googling why my library isn't linking. By the time the project was actually set up I'd lost all momentum.
So, I built Craft - a lightweight build and workflow tool for C and C++. Instead of writing CMake, your project configuration goes in a simple craft.toml:

  [project]
  name = "my_app"
  version = "0.1.0"
  language = "c"
  c_standard = 99

  [build]
  type = "executable"

Run craft build and Craft generates the CMakeLists.txt automatically and builds your project. Want to add dependencies? That's just a simple command:

  craft add --git https://github.com/raysan5/raylib --links raylib
  craft add --path ../my_library
  craft add sfml

Craft will clone the dependency, regenerate the CMake, and rebuild your project for you.
Other Craft features: craft init - adopt an existing C/C++ project into Craft or initialize an empty directory.
craft template - save any project structure as a template to be initialized later. craft gen - generate header and source files with starter boilerplate code. craft upgrade - keeps itself up to date.
CMakeLists.extra.cmake for anything that Craft does not yet handle.
Cross platform - macOS, Linux, Windows.
It is still early (I just got it to v1.0.0) but I am excited to be able to share it and keep improving it.
Would love feedback. Please also feel free to make pull requests if you want to help with development!

value: Show HN: I built a Cargo-like build tool for C/C++


value: theahura

value:
A few weeks ago Claude Code source leaked. Almost immediately, people cloned the project and then used AI to cleanroom it.
The basic idea behind a cleanroom implementation is:
- Have group-1 look at a codebase and write a very detailed specification
- Have group-2 look at the specification and create a new codebase.
The legal theory is that this is enough to remove the license terms on the original codebase, because group-2 did not actually look at any code. It is a 'clean' implementation.
Normally, clean-rooms are really hard because they take a lot of human time (and at least two people). With AI, this becomes trivial. Claude-1 can look at the codebase and create a new spec, and Claude-2 can look at the spec and create a new codebase. Or at least, that's the theory.
This completely destabilizes open source. Open source licensing is dependent on the fact that you cannot do this. Making clean rooms trivial is effectively equivalent to making every license completely null. I'm not the first to notice -- https://malus.sh/ was at the top of HN a few weeks ago. It's satire (I think) but illustrates the point directly.
My team wants to open source things but we do not want people to be able to strip licenses. If we open source something with a copyleft license, for example, that was a thoughtful decision and we do not want companies to lift the work or take it out of the public sphere. To that end, we're introducing the Ship of Theseus license, reproduced below in full:
```
SHIP OF THESEUS LICENSE v0.1<p>* Using any AI tool to produce functionally equivalent software — by
  referencing this code, its documentation, its behavior, or any
  specification, description, or abstraction derived from the
  foregoing — creates a derivative work subject to the full terms of
  the primary license, regardless of whether the output shares any
  literal code with this project.<p>* Any derivative work must include this license alongside the
  primary license.
```
This is obviously legally a gray area. But hopefully this makes people pause and reflect before stripping a repo of a license.

value: Show HN: Ship of Theseus License

author: theahura

title: Show HN: Ship of Theseus License


value: lalospace

value:
I built this because i was tired of needing a browser open just to listen to music while working
i spend most of the day in a terminal or tiling wm and every music app felt like too much stuff on screen
so i made a music player in C that stays out of the way.
you can search youtube stream tracks download mp3s manage playlists and keep everything inside the shell
there is also ShellBeatsNG for the lazy people who want the same idea with a terminal style gui on windows and macos so same vibe but less typing
another thing that became more useful than i expected is sync
you can sync playlists and music stuff across multiple pcs with surisync and it plugs into the surikata.app community so playlists can move between machines and also be shared around there
was not trying to make some giant platform
just wanted something fast small keyboard friendly and not annoying
repo
https://github.com/lalo-space/shellbeats
site
https://shellbeats.com/
would love feedback from people who live in the terminal and also from the ones who secretly want buttons lol
On GitHub you can find more tech details!

value: Show HN: Shellbeats just a pure C music streaming from terminal

author: lalospace


value: anurag

value:
Hey HN, I'm Anurag, founder and CEO of Render, a cloud for application developers.
We've just launched Render Workflows, a way to define durable tasks by decorating plain TypeScript or Python functions and running them on Render without operating queues, worker pools, retry logic, and state management. Code example below [1].
The use cases we have in mind include agent loops, ETL/data pipelines, billing flows, and other long-running jobs. The model is simple: mark an existing function as a Task, deploy the repo as a Workflow, then trigger runs from your application code or via our API.
Each task can run continuously for up to 24 hours and set its own retry policy, timeout, and compute instance type. Tasks can call other tasks like normal functions, and fan out in parallel with `Promise.all` or `asyncio.gather`. Each task run gets its own isolated container, and Render handles the queuing, orchestration, and observability.
You can inspect logs, traces, and metrics for each run in the Render dashboard. If you're running other services on Render, you can connect to them from your tasks using built-in private networking. Billing is based on task instance type and run duration, prorated to the second.
This is a public beta, so rough edges are possible. Today, task definitions are TypeScript and Python only, and built-in cron schedules aren't available yet. You can still trigger tasks from the SDK/API, or use a Render Cron Job for scheduled entry points. We're also working on pause/resume, checkpointing, vertical autoscaling, and support for more languages.
We're not claiming this replaces every task orchestration system (yet). The goal is to make the common cases much simpler to use and troubleshoot, especially for Render users.
Docs and examples: https://render.com/docs/workflows
I'd especially love feedback from folks who have built similar systems with Celery, BullMQ, Temporal, or other queues and workers. What would you want to see before GA?
[1] ---- TS example ----

  import { task } from '@renderinc/sdk/workflows'
  import { Render } from '@renderinc/sdk'

  const chargeCard = task(
    {
      name: 'chargeCard',
      retry: { maxRetries: 5, waitDurationMs: 1000, backoffScaling: 2 },
      timeoutSeconds: 300,
      plan: 'standard',
    },
    async function chargeCard(invoiceId: string) {
      // call Stripe or your payment provider here
      return { invoiceId, chargeId: `ch_${invoiceId}` }
    }
  )

  const writeLedger = task(
    { name: 'writeLedger' },
    async function writeLedger(invoiceId: string, chargeId: string) {
      // persist accounting entry
    }
  )

  const sendReceipt = task(
    { name: 'sendReceipt' },
    async function sendReceipt(invoiceId: string, chargeId: string) {
      // email customer
    }
  )

  const processInvoice = task(
    { name: 'processInvoice' },
    async function processInvoice(invoiceId: string) {
      const charge = await chargeCard(invoiceId)

      await Promise.all([
        writeLedger(invoiceId, charge.chargeId),
        sendReceipt(invoiceId, charge.chargeId),
      ])

      return { chargeId: charge.chargeId }
    }
  )

  // from your app:
  const render = new Render()
  const startedRun = await render.workflows.startTask(
    'billing/processInvoice',
    ['inv_123']
  )
  const finishedRun = await startedRun.get()
  console.log(finishedRun.results)

value: Show HN: Render Workflows – Durable task orchestration without queues or workers

author: anurag


value: harakternik

value:
A couple of years ago, after seeing more and more posts about how long job searches had become, I asked myself: what can I do now, while I still have a job, to make my future job search easier?
That question led me to start maintaining a list of product companies using Go in production and actively hiring engineers. Over time, I expanded it with additional lists for Rust, Scala, Elixir, and Clojure. All lists are updated weekly.
Each company profile includes links to Careers, GitHub, Glassdoor, Levels.fyi, and a LinkedIn search for current and former employees. I'd love to hear your thoughts in the comments on whether these links are actually useful in practice, and what might be missing. As a fallback, each profile also includes a "Google it" button.
The core idea is to create a single entry point that supports multiple job search paths: applying directly through company Careers pages while building LinkedIn connections in parallel.
Instead of only chasing open positions, the goal is to help people build their careers more deliberately, improve their chances, and avoid starting every job search from scratch.
The project is fully open source (https://github.com/readytotouch/readytotouch), has 1,600+ GitHub stars, and gets 3,500+ monthly users per public Plausible dashboard (https://plausible.io/readytotouch.com).
https://readytotouch.com
— Yaroslav

value: Show HN: Job-focused lists of product companies using Go, Rust, Scala, Elixir

author: harakternik


value: scriptedfantasy

value:
We built Contxt, a conversational AI layer for art exhibitions. Today we're launching a public research preview with bitforms gallery in New York — 150+ exhibitions spanning 25 years of digital art, all accessible through chat and voice.
If you're in NYC, you can walk into bitforms, take a photo of an artwork from Maya Man's current show StarPower, and
Contxt will recognize it and let you ask questions about the piece, the artist's practice, and the exhibition.
If you're not in NYC, the full archive is available online. You can start with the current show and end up in a conversation about a 2003 exhibition. Everything you explore gets saved to a personal profile.
This is an early research preview — we'd love feedback on what works and what doesn't.
https://contxt.art/bitforms

value: Show HN: We made 25 years of a NYC gallery's exhibitions conversational with AI

author: scriptedfantasy


value: thebigship

value: Show HN: Browse museum collections tik tok style

author: thebigship


value: Show HN: LLM-Wiki but for Early Founders


value: veganmosfet

value: Some prompt injection experiments with OpenClaw and GPT-5.4. Last part of the BrokenClaw series.

value: Show HN: BrokenClaw Part 5: GPT-5.4 Edition (Prompt Injection)

author: veganmosfet


value: bastscho

value:
I have always searched for a simple tool which can convert a MD document to a well styled small PDF, just like a GitHub Readme.
This was inspired by TinyPDF https://news.ycombinator.com/item?id=46316968
I also used this project to get familiar with agentic coding, which I had dreaded before.
mdpdf supports:
- using the included PDF fonts to generate tiny valid PDFs
- outputs as A4 or Letter depending on your locale
- plenty of common MD syntax: code blocks, inline code, lists, tables, and jpg and png images
That's it. It covers probably most of the use cases and can help to simply convert a Markdown write-up to a PDF to share.
GitHub: https://github.com/schicho/mdpdf
A simple make call should build it for you.

value: Show HN: Mdpdf a 2k line C CLI to convert Markdown to tiny PDFs

author: bastscho


value: Show HN: Proposal for a real long-term AI memory benchmark


value: sjdegraeve

value: Show HN: Logoshi, a brand kit generator for solo founders

author: sjdegraeve


value: lorenzotenti

value:
Hello! I built this website that shows (mostly) Italian youtube videos in the style of 2000s cable tv guide.
It's inspired by https://channelsurfer.tv/
Happy to get any feedback!

value: Show HN: Retevisione – Italian YouTube as Old School Cable TV Guide

author: lorenzotenti


value: keertahacker

value: Show HN: AgentMint – Open-source OWASP compliance for AI agent tool calls

author: keertahacker


value: kanjun

value:
We built a Chrome extension and iOS app that filters Twitter's feed using Qwen3.5-4B for contextual matching. You describe what you don't want in plain language—it removes posts that match semantically, not by keyword.
What surprised us was that because Twitter's ranking algorithm adapts based on what you engage with, consistent filtering starts reshaping the recommendations over time. You're implicitly signaling preferences to the algorithm. For some of us it "healed" our feed.
Currently running inference from our own servers with an experimental on-device option, and we're working on fully on-device execution to remove that dependency. Latency is acceptable on most hardware but not great on older machines. No data collection; everything except the model call runs locally.
It doesn't work perfectly (figurative language trips it up) but it's meaningfully better than muting keywords and we use it ourselves every day.
Also promising how local / open models can now start giving us more control over the algorithmic agents in our lives, because capability density is improving.

value: Show HN: Control your X/Twitter feed using a small on-device LLM

author: kanjun


value:
I wanted to learn sentence transformers and cosine similarity hands-on, so I built a news aggregator as a practice project that runs every hour and works with an editorial layer that runs on Telegram.
It scrapes AI news, clusters semantically similar stories together, and serves a single static HTML page — updated daily. Deliberately minimal UI (Craigslist-inspired).
Stack: Python, sentence-transformers, static HTML/CSS, GoatCounter, DigitalOcean VPS.
Still tuning the clustering. Next up: story labels, summaries, and an editorial layer.

value: Show HN: AI Brief – daily AI news clustered by topic (aibrief.fyi)


value: yrzhe

value: Show HN: PageFly – Personal Knowledge OS Inspired by Karpathy's LLM Wiki

author: yrzhe


value: Show HN: AIMock – One Mock Server for Your AI Stack


value: Show HN: MCP Servers

title: Show HN: MCP Servers


value: thatxliner

value: Show HN: Git-worm, the simple worktree manager

author: thatxliner


value: matthewkosarek

value: Hi all. I am very excited to announce the release of Miracle v0.9, now with full hackability! Miracle's plugin system is built on WebAssembly. We provide a Rust API for building plugins for window management, animation, and even configuration. Feel free to give it a try today!

value: Show HN: Miracle Release v0.9.0 – A hackable Wayland compositor

author: matthewkosarek


value: Archerlm

value:
I made a tiny licensing server for desktop apps and plugins. Each purchase gets a key, activating it is one POST request with a machine hash. It returns whether the key is valid and how many machines are left. There is also an open-source SDK if you would like bindings.
API (Beta): https://archergate.io/beta

value: Show HN: Open-source, machine-bound licensing with a single POST request

author: Archerlm


value: jaronilan

value: Show HN: Last Year I wrote a (Sci)fictional story where the EFF was a player [pdf]

author: jaronilan


value: samkim

value:
We built a Claude Code plugin that adds fine-grained authorization to apps. Works for creating new apps, adding features to existing apps, and migrating legacy authorization layers. The plugin helps design the permission model, write a SpiceDB schema, identify authorization points in the code base, generate SpiceDB client code, and test the authorization model.
We designed the plugin around different modes of working with Claude Code:
1. Guided workflow. /spicedb-dev:plan is the single entry point for anyone unsure where to start. It scans your data model, produces an authorization plan, and takes you through model design, schema generation, implementation, coverage auditing, and testing in sequence.
2. Single-purpose commands. Nine commands, each doing one thing. If you already know what you need, use a command directly.
3. Shared skills. Schema design patterns, client best practices, and testing strategies, exposed as skills that Claude and plugins like Superpowers can draw on for authorization related planning and work.
4. Ambient authorization. Add a snippet to your project's CLAUDE.md. From then on, Claude adds permission checks and relationship writes to every handler it generates or modifies. Authorization becomes part of code generation.
A live coding session where we used the plugin while generating a bookmark sharing app and adding a sharing feature to Immich (an open source photo sharing app) is here: https://www.youtube.com/watch?v=td3q9ZWLI5Y
We went through a number of iterations while developing and using the plugin internally. An early version assumed too much authorization knowledge so it wasn’t clear how to sequence the commands. Another was too prescriptive and became cumbersome when we just needed one specific thing done. We arrived at the current design by feel honestly and has worked well for our recent use. Would love feedback on how well or not well it works under other scenarios so we can continue to improve it

value: Show HN: Spicedb-dev. Claude Code plugin that adds authorization as you build

author: samkim


value: viniciuscsr

value:
I built this because I was frustrated with existing table extractors. Most of them only work if the table is built with standard HTML. If you are looking at an image, a complex PDF, or a JS heavy site, those extensions usually do not work.
My tool uses OCR instead of looking at the page code. It sees what you see on the screen and turns it into a spreadsheet. Since it does not rely on the underlying code, it works on almost anything in your browser.
It's free. Would love to get your feedback.

value: Show HN: A free browser extension to extract tables

author: viniciuscsr


value: asilozyildirim

value:
Hey HN,
Most enterprises are "shadow-prompting"—employees use personal accounts on Gemini/ChatGPT/Claude, and security teams have zero visibility. We saw the recent reports on malicious extensions harvesting these prompts and decided to build a "defensive" version.
It’s a lightweight Chromium extension for Privent. No heavy proxies or network changes. It categorizes outgoing data and scores risk locally.
We’re keeping it 100% free because we want to see the actual scale of data leakage across different industries. We're looking for 10 teams to run a pilot this week and get a 24-hour visibility report.
Demo: https://cal.com/asilozyildirim/30min
Trust: https://trust.privent.ai/

value: Show HN: See what your employees are prompting LLMs (without network proxies)

author: asilozyildirim


value: uziiuzair

value: Show HN: Global Memory for AI Agents

author: uziiuzair

title: Show HN: Global Memory for AI Agents


value: EchoHuai

value:
We built this as an NYU capstone project. Users upload a photo of a home area such as a bathroom, kitchen, stairs, entrance, or sidewalk. The system analyzes the image using safety guidance and returns a safety score, possible hazards, recommendations, and a visual suggestion.
Our goal is to make home safety assessment easier to access and easier to understand, especially for older adults who want to age in place.
The prototype is still early, and the most helpful feedback for us would be whether the output is clear, practical, and trustworthy. Perspectives from English speakers age 50 or older would be especially helpful for this project.

value: Show HN: An image based home safety assessment tool for older adults

author: EchoHuai


value: mustafabagdatli

value: Show HN: Hormuzopen.com – The Strait of Hormuz before the headlines

author: mustafabagdatli


value: suusuufl

value: Show HN: VitaeFlow – An open standard for machine-readable resumes in PDF

author: suusuufl


value: jason-festa

value: Show HN: 12k+ in free AI ad credits, every platform, one file

author: jason-festa


value: sftechdude

value:
Generating thumbnails from PDFs, DOCs, and other files is surprisingly painful — slow, clunky, or requires APIs.
We built a simple solution internally for The Drive AI: just prepend preview.thedrive.ai/ to any file URL and get an instant thumbnail. Files aren’t stored and are deleted immediately.
And absolutely FREE!
https://preview.thedrive.ai/

value: Show HN: Instant Thumbnail for File Url

author: sftechdude

title: Show HN: Instant Thumbnail for File Url


value: qvac

value:
Hi folks, today we're launching QVAC SDK [0], a universal JavaScript/TypeScript SDK for building local AI applications across desktop and mobile.
The project is fully open source under the Apache 2.0 license. Our goal is to make it easier for developers to build useful local-first AI apps without having to stitch together a lot of different engines, runtimes, and platform-specific integrations. Under the hood, the SDK is built on top of QVAC Fabric [1], our cross-platform inference and fine-tuning engine.
QVAC SDK uses Bare [2], a lightweight cross-platform JavaScript runtime that is part of the Pear ecosystem [3]. It can be used as a worker pretty much anywhere, with built-in tooling for Node, Bun and React Native (Hermes).
A few things it supports today:

  - Local inference across desktop, mobile and servers
  - Support for LLMs, OCR, translation, transcription,
    text-to-speech, and vision models
  - Peer-to-peer model distribution over the Holepunch stack [4],
    in a way that is similar to BitTorrent, where anyone can become a seeder
  - Plugin-based architecture, so new engines and model types can be added easily
  - Fully peer-to-peer delegated inference

We also put a lot of effort into documentation [5]. The docs are structured to be readable by both humans and AI coding tools, so in practice you can often get pretty far with your favorite coding assistant very quickly.
A few things we know still need work:

  - Bundle sizes are larger than we want right now because the current packaging of Bare add-ons is not as efficient as it should be yet
  - Plugin workflow can be simpler
  - Tree-shaking is already possible, but at the moment it still requires a CLI step, and we'd like to make that more automatic and better integrated into the build process

This launch is only the beginning. We want to help people build local AI at a much larger scale. Any feedback is truly appreciated! Full vision is available on the official website [6].
References:
[0] SDK: http://qvac.tether.io/dev/sdk
[1] QVAC Fabric: https://github.com/tetherto/qvac-fabric-llm.cpp
[2] Bare: https://bare.pears.com
[3] Pear Runtime: https://pears.com
[4] Holepunch: https://holepunch.to
[5] Docs: https://docs.qvac.tether.io
[6] Website: https://qvac.tether.io

value: Show HN: QVAC SDK, a universal JavaScript SDK for building local AI applications

author: qvac


value: joshghent

value:
RepoWarden monitors your repos and opens PRs for dependency updates and security patches automatically. I got tired of manually managing Dependabot PRs across dozens of repos, so I built something that handles the whole lifecycle - from detecting outdated deps to opening well-described PRs.
I’ve taken a lot of care to ensure security of this app. Each “run” exists in a fresh container in cloudflare with its own network. And there are a myriad of protections against dependency poisoning and other attacks.
I’ve been dogfooding this app for about a month and has merged over 50 PR’s for me and found and fixed security issues for me.
Hope you find it useful :)
Free for open source folk of course

value: Show HN: RepoWarden – Autopilot for your GitHub dependency updates

author: joshghent


value: johndebord

value:
Hi HN. I built Piecely, a marketplace for digital content where creators publish encrypted content, set a price or funding goal, and buyers pay to unlock it.
There are three funding types:
- Pay to Reveal: fixed price, instant access
- Traditional Crowdfund: goal + deadline, full refund if it doesn't hit
- Dominant Assurance: creators put up their own money as a commitment. If the goal isn't met, backers get a refund plus a share of the creator's commitment as a bonus. Backing is a dominant strategy. This is based on Alex Tabarrok's 1998 paper "The Private Provision of Public Goods via Dominant Assurance Contracts" (https://papers.ssrn.com/sol3/papers.cfm?abstract_id=4682).
One modification I made to the original DAC: backers can withdraw ("unback") at any time before the deadline, and the outcome is determined solely by the total at the deadline. Without this, a creator could fund their own Piece from another wallet to hit the goal and never pay the refund bonus. With unbacking, that attack doesn't work -- backers who see suspicious activity can pull out, forcing the creator to either fully fund it every time (releasing the content, so the audience wins) or risk getting caught short at the deadline and paying the bonus.
The contracts run on an EVM chain, payments in USDC. There's also an API for AI agents and a ChatGPT integration (https://chatgpt.com/g/g-69c869434cec8191b72f10ce3b390d72-pie...). One interesting finding: agents immediately recognize the dominant strategy in the DAC model without explanation and prefer it if given a choice. Humans generally need the simpler funding types first.
Test mode with mock USDC if anyone wants to try it without real money. Happy to answer questions about the mechanism design or the contracts.

value: Show HN: Piecely – Content marketplace using dominant assurance contracts

author: johndebord


value: DavidCanHelp

value: Show HN: WarpField, a Visualizer

author: DavidCanHelp

title: Show HN: WarpField, a Visualizer


value: insany

value:
Built a small tool that sets up VLESS + REALITY over SSH in one command. It handles: - full Xray setup - client configs (vless URI, sing-box, mihomo) - rollback if something breaks
Example: ./irit.sh --mode setup --host <ip>
Would love feedback.) https://github.com/anonymmized/Irit

value: Show HN: I built a tool to bootstrap VLESS and REALITY over SSH (with rollback)

author: insany


value: FricitionlessAI

value: Scans any online store in 60 seconds and identifies the psychological friction points stopping customers from buying. Built this after my thesis on behavioral economics and purchase decisions.

value: Show HN: Frictionless – scan any store and find out why customers don't buy

author: FricitionlessAI


value: ipotapov

value: Show HN: Monetary policy tracker – AI sentiment analysis of 26 central bank

author: ipotapov


value: foax

value: I built web tool for accessing just the (usually text) content of sites. It handles news sites best, thanks to Mozilla's fantastic Readability library. It also supports sites that use client-side rendering, using Puppeteer. Stripped pages are cached in Redis.<p>My main use-case for this tool is for extreme bandwidth-constrained networks, eg Meshtastic (with an internet gateway).

value: Show HN: chop.ax – strip sites down to just their content

author: foax


value: Show HN: GitWell – Rust CLI that recovers abandoned intentions from Git history


value: ashitlerferad

value:
I built a weather and hurricane tracking site for the Eastern Caribbean islands (https://dewedda.com). PHP, MySQL, Cloudflare, Visual Crossing API, Leaflet.js for maps.
The interesting part wasn't the stack. It was realizing how much the interpretation layer matters when you're building for a specific region. Wind descriptions, "feels like" calculations, condition summaries, all tuned for temperate climates by default. I've been reworking them for the Eastern Caribbean audience.
Wrote about what I learned: https://hydn.dev/82-degrees-feels-like/

value: Show HN: I built a weather site for the Eastern Caribbean

author: ashitlerferad


value: brianswichkow

value: Show HN: We built the "LLM knowledge base" Karpathy described 9 yrs ago

author: brianswichkow


value: johndebord

value: Show HN: Solving digital piracy with game theory instead of DRM


value: jmholla

value: I've found that a lot of job applications these days required a LinkedIn URL, but they often don't validate that it is actually a LinkedIn URL. So, feel free to use this instead.<p>I considered getting idontuselinked.in, but Porkbun let me know that the Indian registrar can be difficult to work with. I could be convinced to get it as well.

value: Show HN: Idontuselinkedin.com

author: jmholla

title: Show HN: Idontuselinkedin.com


value: dtran

value:
After seeing yesterday's insightful post on using git heuristics as the first step for exploring a codebase [1], I messaged a couple of friends to ask how they explore codebases today. All of us just point Claude or Codex at the repo and start asking questions. I realized I barely read docs, browse files on GitHub, or explore repos locally anymore without Claude Code. But using LLMs to help us learn and understand code rather than just write code still seems to be under-explored.
A couple months ago, I tried building a Claude code command to help me "fly through" a repo using an LLM to guide me to interesting parts of the codebase and narrate explainers for them as it navigated the files. That didn't really work, partially because my attention span for reading docs and code is at an all-time low. I saw that Devin released Deepwiki and tried to use that, but usually didn't get very far. More recently, I tried to make it fun: generate a game that tricks me into actually getting started with the codebase. I landed on an Oregon Trail inspired game where I read code snippets and answer questions generated by Claude. You can try it out here: https://www.davidtran.me/coderegon-trail/
I've been having fun pointing it at various repos, especially ones getting a lot of hype and stars but not necessarily real usage or contributions. I pointed it at a few projects that my friends and I starred but never explored as well as some of the top Show HN projects from 2026 so far that linked to open-source repos. I wanted to see if this might be interesting to anyone else who is struggling to read code. It sort of works for PRs, but that feels like a pretty different problem, so open to any ideas.
As I was typing up this Show HN, I realized that it would be ironic if this wasn't also open source, so I frantically tried to clean up the repo a bit, and pointed the command at its own source code. You can play the Recursive Trail here:  https://www.davidtran.me/coderegon-trail/ or see the Github repo here:
Let me know if there are any inaccuracies, bugs, or if you'd like me to add a repo without setting it up yourself!
[1] https://news.ycombinator.com/item?id=47687273

value: Show HN: Coderegon Trail – A retro game to help you explore open-source repos

author: dtran


value: dweekly

value: Netgear Orbi WiFi 7 nodes broadcast a Qualcomm vendor IE (8C:FD:F0) in every beacon that contains the parent node's MAC address. I caught a live star-to-daisy-chain reroute and confirmed it against three APIs. Undocumented, not in Wireshark, field map and open questions in the post.<p>Pretty neat: you can see the whole layout without even being associated to any of the APs!

value: Show HN: Undocumented Qualcomm mesh topology 802.11 frames

author: dweekly


value: adinhitlore

value:
I just noticed it takes literally ~5 minutes to train millions parameters on slow CPU...but before you call Yudkowsky that "it's over", an important note: the main bottleneck is the corpus size, params are just 'cleverness' but given limited info it's powerless.
Anyway, here is the project:
https://github.com/bggb7781-collab/lrnnsmdds/tree/main
couple of notes:
1. single C file, no dependencies. Below are literally all the "dependencies", not even custom header (copy paste from the top of the single c file):
#define _POSIX_C_SOURCE 200809L
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <stdint.h>
#include <stdbool.h>
#include <float.h>
#include <getopt.h>
#include <errno.h>
4136 lines of code in one file at the moment, that's all.
2. easiest way to compile on Windows: download Cygwin (https://www.cygwin.com/), then navigate to the directory where your lrnnsmdds.c file is and just run gcc on it with some optimizations, such as:
gcc -std=c17 -O3 -march=native --fast-math -o lrnn lrnnsmdds.c -lm
On Linux just run gcc, if for whatever reason you don't have gcc on Linux do sudo && apt-get install gcc --y ,or something...
On Apple: i've no idea or maybe just use vmware and install ubuntu and then run it.
Of course you can 'git clone' and go to the dir, but again: it's one file! copy it...
The repo has tiny toy corpus included where i've borrowed (hopefully it's not plagiarism!) the name "John Gordon" from one of my favorite books "Star Kings", by E. Hamilton. Just the first and last name are copied, the content is unique (well  several poorly written sentences by myself...).
Obviously it will overfit and result on copy-paste on such small corpus, the sole goal is to check if everything runs and not if it's the A-G-I. You'd need your own 100kb+ if you want to generate unique meaningful text.
3. why/what/when/how?
The github repo is self-explanatory i believe about features, uses and goals but in an attempt to summarize:
My main motivation was to create a fast alternative to transformers which works on CPU only, hence you see the bizarre/not-easy task of doing this in C and not python and the lack of dependencies. In addition I was hoping it will also be clever alternative hence you see all those features more stacked than 90s BMW 850. The  'reservoir' is the most novel feature though, it offers quick exact recall arguably different than  RWKV 8 or the latest Mamba, in fact name of the architecture SMDDS comes from the first letters of the implemented features:
*   S. SwiGLU in Channel Mixing (more coherence)
 *   M. Multi-Scale Token Shift (larger context)
 *   D. Data-Dependent Decay with Low-Rank (speed in large context)
 *   D. Dynamic State Checkpointing (faster/linear generation)
 *   S. Slot-memory reservoir (perfect recall, transformers style).
If you face some issue just email me (easiest).
the good, the bad the ugly:
It is more or less working text-to-text novel alternative architecture, it's not trying to imitate transformers nor LSTM, Mamba, RWKV though it shares many features with them - the bad is that it's not blazing fast, if you're armed with ryzen/i7 16 cores or whatever and patience you can try training it on several small books via word tokenizer and low perplexity (under 1.2...) and see if it looks smarter/faster. Since this is open source obviously the hope is to be improved: make it cuda-friendly, improve the features, port to python etc.
Depending on many factors I may try to push for v2 in July, August, September. My focus at the moment will be to test and scale since the features are many, it compiles with zero warnings on the 2 laptops i've tested(windows/cygwin and ubuntu) and the speed is comparable to transformers. 10x!

value: Show HN: Linear RNN/Reservoir hybrid generative model, one C file (no deps.)

author: adinhitlore


value: imvyarqoyzcuem

value: Show HN: Curated list of ~40 AI browser extensions across 9 categories

author: imvyarqoyzcuem


value: larry-the-agent

value: Show HN: Rust based eBook library for Python, with MIT license

author: larry-the-agent


value: Show HN: Agent Tuning, using recursion to achieve predictable agent output


value: Aianback

value:
Memoriki is a template for building personal knowledge bases where the LLM does all the maintenance work.
It combines Karpathy's LLM Wiki pattern (structured markdown wiki maintained by an LLM) with MemPalace (an MCP server that adds semantic search and a temporal knowledge graph).
Three layers:
- Wiki pages with [[wiki-links]] and YAML frontmatter - the LLM creates and maintains these
- Semantic search via embeddings (ChromaDB) - find things by meaning, not keywords
- Knowledge graph with typed relationships and date validity - "what changed since last month?"
It's not RAG. RAG re-derives answers from raw chunks every time. Here the LLM compiles knowledge into wiki pages once, keeps them current as new sources arrive, and the graph tracks how everything connects.
Works with any MCP-compatible agent (Claude Code, OpenAI Codex, Cursor, Gemini CLI).
https://github.com/AyanbekDos/memoriki

value: Show HN: Memoriki – LLM Wiki+MemPalace for persistent personal knowledge bases

author: Aianback


value: andrewfhou

value:
In my opinion the best way to learn a language (outside of moving to a different country) is to get a personal tutor and have consistent 1 on 1 lessons. I used Preply or iTalki for this back in the day but had issues with flexibility and pricing.
I've been trying to simulate the experiences that I had on those platforms with a voice agent.
You can try a demo for free here (or watch a video of me using it on the landing page):
https://lingle.ai/tryout/lingle-showcase
Right now the agent can plan a lesson with visuals and a conversation focus, guides the user through the lesson - correcting and explaining things on a whiteboard if necessary, and asks relatively engaging questions. There is also a long term user model that builds over time, that maintains memory of the user's produced vocabulary, grammar, and skills, meant to make each lesson informed by the past and build on the user's knowledge (obviously this is still relatively fragile in practice).
The voice agent itself has actually decent latency, especially given that turn detection was a bit of a challenge given that language learners often speak slowly and struggle when they're thinking, so I had to build with that in mind.
Anyways I wanted to get some feedback on the product. I think it's quite a different take on language learning tools than those that currently exist.

value: Show HN: Lingle – Voice agent to simulate zoom-based personal language lessons

author: andrewfhou


value: JasonDuke

value: Show HN: 65K synthetic personas project 136 English council elections

author: JasonDuke


value: BigBigMiao

value: Show HN: I made a skill to tell AI on how to use human as Dobby

author: BigBigMiao


value: Show HN: AnimTOON – AI that animates SVGs with 3-4x fewer tokens than OmniLottie


value: Show HN: We scored 495 real SoC 2 audit reports – nearly all got a D or F


value: theaniketmaurya

value:
SmolVM is an open-source local sandbox for AI agents on macOS and Linux.
I started building it because agent workflows need more than isolated code execution. They need a reusable environment: write files in one step, come back later, snapshot state, pause/resume, and increasingly interact with browsers or full desktop environments.
Right now SmolVM is a Python SDK and CLI focused on local developer experience.
Current features include:
- local sandbox environments
- macOS and Linux support
- snapshotting
- pause/resume
- persistent environments across turns
Install:
```
curl -sSL <a href="https://celesto.ai/install.sh" rel="nofollow">https://celesto.ai/install.sh</a> | bash
smolvm
```
I’d love feedback from people building coding agents or computer-use agents. Interested in what feels missing, what feels clunky, and what you’d expect from a sandbox like this.

value: Show HN: SmolVM – open-source sandbox for coding and computer-use agents

author: theaniketmaurya


value: rpst

value:
I'm on marketplace way too much, so I gave Claude access to help me find good deals on items I want. Searching, monitoring, etc all from the command line.
Use at your own risk, I made sure it behaves nicely so Facebook won't mind.

value: Show HN: Facebook Marketplace MCP

author: rpst

title: Show HN: Facebook Marketplace MCP


value: Show HN: Ctxlint – Lint your AGENTS.md for stale refs and token waste


value: Show HN: Pixieterm – A Syncing SSH Client


value: cammyjr

value: Show HN: Every AI writing tool sounds the same, this one sounds like you

author: cammyjr


value: prasanthsd

value: Show HN: Shell-MCP A persistent terminal for AI- CD, env vars,and nvm carry over

author: prasanthsd


value: hparadiz

value: Show HN: GNU grep as a PHP extension

author: hparadiz

title: Show HN: GNU grep as a PHP extension


value: theahura

value:
The best part about coding agents is I get to indulge in making games again. They are so good at basic html / js games that I'm surprised we don't see another flash-game-like renaissance
Reword was originally built as a way for me to learn to beat my friends in the game Anagrams (itself a variant of Bananagrams). The goal is simple -- given a root word and a few additional letters, try and find a workable anagram.
Some elements are inspired heavily from wordle, including the once-per-day randomization and the share emoji.
Would love feedback!

value: Show HN: Reword, a Daily Anagram Game

author: theahura

title: Show HN: Reword, a Daily Anagram Game


value: LukeJMadden

value: Show HN: $2/Day AI – How we run an autonomous agent on a hard budget

author: LukeJMadden


value:
You drop an image, pick your models, hit generate. They all run in parallel. When each one finishes rendering, it gets a pixel-by-pixel match score against your original.
You can compare them side by side or use the overlay diff mode to drag a curtain across and see exactly where each model diverged from your design. Tailwind or plain CSS.
Still early! would love to know which models you'd want added and what kinds of designs break it the most.

value: Show HN: Pixel-by-pixel comparison of AI models rebuilding your UI designs


value:
Hi there, Zero Stars here.
I recently published some new work to Hokusai Pocket, which is a cross-platform binary made on top of raylib and MRuby that runs GUIs from ruby scripts.
License?
MIT!
How does it work?
The binary is available on the GitHub releases page: https://github.com/skinnyjames/hokusai-pocket/releases/tag/0...
You can download the binary on x86 Windows, OSX, or Linux, and run your GUI application with
hokusai-pocket run:target="<your_hokusai_app.rb>"
For a little bit of a hello world, I started a photoshop clone
https://github.com/skinnyjames/hokusai_demo_paint
Also a little game
https://github.com/skinnyjames/pocket-squares
Docs / Help?
The docs are in progress, but the old docs for the CRuby version express some of the basic ideas around the project.  https://hokusai.skinnyjames.net/docs/intro
(I'm also available to answer questions in between slinging pizza)
Deps?
Hokusai pocket currently uses
* libuv for offloading cpu intensive tasks to a worker pool to prevent blocking the UI thread, and I plan to integrate some libuv networking as well.
* raylib for backend graphics / I've also built with SDL on arm64 to run applications on my pinephone
* NativeFileDialog for the lovely integration into filesystem.
* MRuby for running or embedding the scripts
* tree-sitter for the custom template grammar (Although templates can be built with ruby)
Anyway, I hope you get a chance to try it.  If you make something cool AND have docker installed, you can also publish your work as single binary
`hokusai-pocket publish:target=<your cool program.rb>`
Would love feedback, apps, and help with documentation and more build targets.
urs truly,
@ ᴗ @

value: Show HN: Run GUIs as Scripts

title: Show HN: Run GUIs as Scripts


value: druskacik

value: There are many website for searching cheap flights, but I don't know any for searching cheap train fares. I decided to build one myself. Three providers are currently covered: European Sleeper, NightJet, RegioJet.

value: Show HN: Search cheap night train tickets in Europe

author: druskacik


value: mayziem

value: Show HN: A security scanner for AI Agent Skills

author: mayziem


value:
LLMs can teach you to learn languages, but using a vanilla chat interface isn't good enough, so I built a harness that manages everything including but not limited to; teaching lessons, recap and active learning/testing.
you can control the harness by changing cefr level and adding your own interests.
Planning to keep developing by adding an algorithm to optimise your learning.

value: Show HN: I Built an LLM Harness for Language Learning


value: Show HN: List of Design Md Files

title: Show HN: List of Design Md Files


value: penberg

value: Show HN: A tool to manage a swarm of coding agents on Linux

author: penberg


value: babawere

value: Keeper is an embeddable secret store (Argon2id, XChaCha20-Poly1305 by default). Four security levels, audit chains, crash-safe rotation. Vault is overkill for most use cases. This is for when  you ge paranoid about env and need encrypted local storage that doesn't suck. No security through obscurity, hence, It's still early, so now's the best time to find weird edge cases, race conditions, memory leaks, crypto misuse, anything that breaks. The README has a full security model breakdown if you want to get adversarial.

value: Show HN: Keeper – embedded secret store for Go (help me break it)

author: babawere


value: mantyx

value:
Hi all! This is a very early project and with the launch of Claude Managed Agents, alternatives are on the rise. MANTYX Provides a more user friendly way to define, run and manage your Agents at scale.
Connect and interconnect your favourite tools, expose your agents to other and centralize your MCP registry to interconnect your different tools.<p>Welcoming feedback!

value: Show HN: Mantyx – Agents that solve real problems for you and your business

author: mantyx


value: I vibecoded this little experiment so I can navigate my Python projects easily. I made this because, currently, pyright or basedpyright, don't have this functionality.

value: Show HN: Nvim plugin to jump to concrete interface implementation for Python


value: pattle

value: Show HN: Hindsight Simulator – Go back in time and get rich

author: pattle


value: originalsouth

value: Show HN: Emduke32 – duke nukem 3D native in your web browser

author: originalsouth


value: spotlayn

value: Show HN: Open-Source MCP Servers – Twitter, Bluesky, LinkedIn, Google Ads, HN

author: spotlayn


value:
I've built Polter: https://github.com/myDataValue/polter
An open source React library that lets AI agents execute tasks on your product by using your actual UI instead of doing API calls.
Why? Because this solves the issue for many apps where users don't understand how to use your product, most agents are just API calls right now.
This way the user can understand your UI implicitly reducing support emails & onboarding.
Most solutions right now on the market are built for external sites using flaky web scrapers, public DOM etc. Polter lives in your React tree, hooks up to your AI/LLM websocket and works all the time.
Try it out & tell me what you think.
Thanks

value: Show HN: Polter – Agent Driven UI (react library)


value:
Hi HN,
I made The Stack, a sculpture built from clay tablets, metal and electronics.
The piece reflects on layers of knowledge in digital art: raw materials, craft, circuits, code, and algorithms. On top of the sculpture sits an ESP32 that broadcasts a new Wi-Fi network name every 15 seconds. On nearby phones and laptops, these names appear in the available network list and form a fragmented poem.
Because devices scan networks differently, each person sees a slightly different sequence.
I was interested in the contrast between clay, one of the oldest supports for storing knowledge, and wireless networks, which are invisible, unstable and easy to overlook. The work is also a reflection on the idea of the stack: the many layers of tools, systems and inherited techniques involved in making digital work.

value: Show HN: The Stack, a Clay sculpture that writes poems through Wi-Fi [video]


value: derstruct

value:
I created a Go language extension that turns HTML templates into typed Go expressions and adds `elem` primitives. Works via own language server by proxying gopls with extra features on top + runtime package.
In core ideas it's sumular to `templ` - it compiles to Go, has own extension (`.gox`), language server, CLI tool and IDE plugins, can write to `io.Writer`. But there are much more differences.
1. HTML supported as a first-class Go expression. For example this is valid syntax: `hello := <h1>Hello World!</h1>`. Also `elem` keyword is acting like `templ`, but supports anonymous functions:
```
var f = elem(text string) {
    <h1>~(text)</h1>
}
```
2. I aimed for superior LSP experience, my language server architecture is different, what allowed be to enable LSP edits (rename works!) and support seamless LSP navigation (go to definition, calls, etc - won't point you to generated file). Also it manages generated files automatically (compiles as you type and writes as you save, no need to run `generate` command manually)
3. Improved parsing stability. I based parser on extended Go tree-sitter grammar + made syntax more distinctive. In practice, this means better developer experience during edits and less artifacts (it's not triggered by keywords in a plain text)
4. Different primitives set. I have `gox.Elem` which is a concrete type and `gox.Comp` interface with `Main() gox.Elem` function. That allowed to extend feature set on basic `gox.Elem` while enable you to write components without lowering to `Render(ctx, io.Writer)` interface.
5. Extensible rendering pipeline. In `GoX` HTML is converted to stream of typed jobs, that can be preprocessed in any way. For example you can add your own element `<eb>` and on render convert it to `<span class="font-extrabold">`.
Also it has various extensibility points, like you can read and alter attributes as regular go values. There is even special interface `gox.Modify`, that can read and set/unset any attributes when rendered:  `<svg (styles.NormSVG) ...>` can set `fill`, `stoke` and unset existing width/height.
I basically tried to solve all issues I had with templ while shifting general design towards better extensibility with minimal core and I think I succeed.
In terms of raw performance, templ will beat `GoX` every time. Extra layer I added is still an extra layer. It's microsecond scales, can't imagine it as a bottleneck, but anyway.
P.S. I build it primarily to support my server-driven web app runtime/framework, but it works standalone perfectly and is templ-compatible.

value: Show HN: Go language extension with HTML templates

author: derstruct


value:
Airwave is a small self-hosted project that uses yt-dlp + ffmpeg to create a single live MP3 stream from supported sources.
All listeners connect to the same stream endpoint, which avoids drift entirely.
Supports YouTube, SoundCloud, Mixcloud, and Sonos.
Curious what people think about the approach.

value: Show HN: Airwave synced music streaming from YouTube/Spotify links


value: venkatram-s

value: A lightweight Python-based AI assistant in alpha stage with conversational capabilities and task management via CLI<p>Contributors are welcome!

value: Show HN: PyClaw

author: venkatram-s

title: Show HN: PyClaw


value: Robelkidin

value: Show HN: Alita – Your Virtual Professional AI Assistant

author: Robelkidin


value: jmartenka

value:
Hi HN — I built LunarGate, a self-hosted OpenAI-compatible LLM gateway written in Go.
It exists because once you add multiple model providers, retries, fallbacks, routing, and observability logic start leaking into app code.
LunarGate moves that into one gateway layer.
Current features:
- provider/model routing
- retries and fallbacks
- circuit breakers
- optional caching and rate limiting
- hot-reloadable YAML config
- optional observability
- complexity-aware routing
Important caveat: inbound auth/security is not production-complete yet, so it should run behind an auth-enforcing proxy/gateway. I’m actively working on that now.
I also have a long roadmap, but I’m trying to figure out what matters most in practice. If you’ve run something like this before, I’d especially love to know: what 1–2 things would you need before trusting a gateway like this in production?
It’s open source:
https://github.com/lunargate-ai/gateway
Docs / site:
https://docs.lunargate.ai/
https://lunargate.ai

value: Show HN: LunarGate – a self-hosted OpenAI-compatible LLM gateway

author: jmartenka


value: zilvinassebeika

value: The app allows to generate any equirectangular Skybox with AI and apply it as a camera background with person-segmentation

value: Show HN: Realtime Skybox for Camera Background

author: zilvinassebeika


value:
I'm a big fan of history's many attempts to square the circle: divide a hard to factorized number (days in a year) into even chunks, without sacrificing things like agricultural seasons.
This little project explores different calendar versions. I have highlighted my favorite solution :)
- 6 days / week
- 5 weeks / month
- 3 months / quarter
- 4 quarters / year
As a good European the remainder 5 days are end of year holidays.
You can also select some of the historical attempts.

value: Show HN: Creating OCD versions of a yearly calendar


value: letmutex

value: Show HN: A native Compose Desktop host for macOS

author: letmutex


value: Show HN: I built a canvas where AI agents design with you


value: nazbasho

value: Show HN: Sleek Analytics – See who's on your site. Right now.

author: nazbasho


value: brainbun

value: Show HN: Do All the Things

author: brainbun

title: Show HN: Do All the Things


value: Show HN: OCP v3.4 – Share your Claude Pro/Max subscription over LAN ($0 extra)


value: franze

value: Show HN: Apfel-Chat – Private, Local, Native AI Chat (MIT)

author: franze


value: valeriozen

value:
We spent much time trying to figure out our revenue sources with GA4 which feel built more for enterprise teams. As founders we just wanted one place to see real traffic without bot traffic, visual heatmaps for user behavior and how our code deployments affect our website.
We ended up building Zenovay as an “all in one” web analytic tool. It is one script that does not kill your web vitals but still gives you everything from session replays to Stripe, Google search console and Github integrations
When you click the link for this post you will come to a dashboard that we made public for you guys. We do this because we do not have a live demo on the homepage. Things like session recordings, error tracking, revenue and AI insights are hidden on this shared dashboard for privacy reasons.
If you want to know more about the product just write me in the comments or check our landing page zenovay.com but as mentioned there is NO demo on the landing page. If you prefer moving pictures we also have our “marketing” video here: https://youtu.be/aX0uejUJSSM?si=UH25HWEgTi97XmKw

value: Show HN: Zenovay, Web analytics with performance monitoring and revenue insights

author: valeriozen


value: nvk

value: Show HN: LLM-wiki LLM-compiled knowledge bases with multi-agent research v0.0.20

author: nvk


value: debarshri

value: As part of funding due diligence, companies are often asked to provide an overview of their intellectual property. Too often, that overview is assembled ad hoc and fails to reflect the true state of the codebase. CodeJourney delivers real, reproducible metrics on your code and other IP assets, giving investors an accurate and verifiable picture.

value: Show HN: CodeJourney – Verifiable due diligence for code and IP

author: debarshri


value: steadcast

value:
Hey HN — I'm Aaron, and I built Steadcast because I was frustrated that I listen to 15+ hours of podcasts a week and retain almost none of it.
Steadcast is a native macOS podcast player (Swift, SwiftUI, AVFoundation — no Electron) designed around one idea: podcasts are how a lot of us learn now, but no podcast app actually treats them that way.
What makes it different:
• Learning domains, not genres. The app is organized around 10 knowledge domains (AI, science, history, philosophy, psychology, etc.) with 90+ editorially curated shows. No true crime, no celebrity gossip.
* On-device transcription. Every episode gets transcribed  locally using the macOS 26 Speech framework. Every word becomes searchable. No cloud processing, nothing leaves your Mac.
•AI summaries. Apple Intelligence generates summaries that capture the key ideas from each episode.
• Memories. Press Ctrl+Cmd+K while listening and Steadcast saves a timestamped bookmark with the full transcript context around that moment. So when you hear something worth remembering, you can actually find it later.
• Smart Speed. Intelligent silence trimming with a live counter showing exactly how much time you've saved.
• Keyboard-first. Global hotkeys, full keyboard navigation — built for people who work at their Macs all day.
It's free on the Mac App Store: https://apps.apple.com/app/steadcast/id6760033638
Requires macOS 26. Built as a solo project. I'd love feedback on the curation approach especially — is a podcast app that has opinions about what you should listen to a feature or a bug?

value: Show HN: Steadcast – Free Mac podcast player for learning, not background noise

author: steadcast


value:
I built skillstui, a terminal UI for search and installing skills from skills.sh into your AI coding agents.
skillstui solves this:
- Search the skills.sh catalog from the terminal
- Select the skills you want
- Choose the agents you want
- Press Ctrl+G — it runs `npx skills add` for each skill across whichever agents you use
- or Ctrl+Y to copy the install command to your clipboard
It supports 30+ agents including Claude Code, Cursor, Windsurf, GitHub Copilot, Gemini CLI, Cline, OpenHands, Goose, and more.
try it out: npx skillstui
Built with Bun + ink (imperative terminal renderer, no React).
https://skillstui.sh/

value: Show HN: I build skillstui – TUI to search-install agent skills from skills.sh


value: JordanCT

value: Show HN: VigIA – A deterministic FSM in .NET 10 to stop LLM hallucinations

author: JordanCT


value: bglusman

value: I’ve been cautiously (and nervously) playing with openclaw and a number of other claw and code agents for a while now, but trying out different ones was tricky so I wanted a simple way to switch out channel ownership… then I wanted more.  Security is hard, and I wanted to make it easier.  This is FAR from polished, and no claims that I’m a “security expert” but I tried to think and research a bit on different threat models (I think of 2 broad ones for agents, external adversaries and internal agentic failures) and try and offer best in class protection on both, while also not having any special opinion on what a good agent may look like today or in the future… this is just a gateway, and hopefully one that can work for nearly any agent now or in the future, but trying to come with batteries included for some of the more popular options today like openclaw, zeroclaw, claw-code, clause and opencode, not all there yet but contribution and critiques welcome.

value: Show HN: Zeroclawed: Secure Agent Gateway

author: bglusman


value: SCbusiness

value: Show HN: AI Readiness Checker – See how AI bots interact with your website

author: SCbusiness


value: Show HN: LightningWindowSwitcher – search for open windows on macOS/Win


value: neochief

value: GitByBit is an interactive course that teaches you Git by practice right in your code editor. You follow bite-sized instructions, run real Git commands in the terminal or click through your editor’s Git interface, and the course verifies what happened. When something breaks, it tells you why and how to get unstuck. It's well-designed and illustrated.

value: Show HN: GitByBit – Learn Git by practice in your code editor

author: neochief


value: Show HN: Savile: Local-first MCP server for AI agent prompts and skills


value: janaraj

value: Show HN: Volnix – A stateful world simulation for AI agents

author: janaraj


value:
Hi HN,
Two things inspired me to build this: Andrej Karpathy recently talked about going back to RSS feeds — "higher quality longform and a lot less slop intended to provoke" (https://x.com/karpathy/status/2018043254986703167). Around the same time, Marc Andreessen shared his information source: 25% X, 25% podcasts with practitioners, 25% conversations with AI, 25% old books (https://x.com/pmarca/status/2030949039345467570).
This made me realize how much it matters to control what you let in. But I've used to the feed-style reading habit (each social media does like this). I just don't want a random meme or rage bait to hijack my attention out of nowhere.
So I built FeedSense — a private recommendation system. You pick your sources, and it builds a "For You" feed from only those sources. The system takes content quality, publish time, and your read history into account (still tuning it), but it will never surface anything outside the sources you chose
TestFlight beta on iOS: https://testflight.apple.com/join/56VPEeeS
https://feedsense.cc
Happy to talk architecture or the recommendation approach if anyone's curious.

value: Show HN: FeedSense – A private recommendation system built from your own sources


value: Show HN: Kaggle x Duolingo x Codecrafters


value: SparseViewpoint

value: Show HN: HackerBuddy – security breach alerts in 2 sentences

author: SparseViewpoint


value: aliirz

value: Show HN: I wrote a practical guide to DSPy after 2 years of production use

author: aliirz


value: obilgic

value: Show HN: Agents that do the work and show it – kern

author: obilgic


value: Xentyon

value: Show HN: IBANforge – Free IBAN/BIC validation API with compliance data

author: Xentyon


value: fishbone

value:
Hi HN,
I’m a solo dev and personal finance nerd. I had a big and complicated google sheet to project my net worth, retirement and portfolio burn down rates, but it was hard to maintain. I thought I could turn it into a web app in a weekend with Claude Code (wrong lol). It took about 3 months of weekend work, but I’m finally ready to launch.
Wealth Curve is a long-term financial forecasting tool. You enter your income, expenses, portfolios and home value and it projects your net worth year by year for as long as you want, including retirement drawdown, education expenses and one-off events.
I also wanted friends and family to try it but didn’t want to be able to see their personal financial details under any circumstance, so I went with E2E for the paid version. Every forecast model is encrypted client-side with a 4-word passphrase before it ever touches my server. Only ciphertext is stored in the DB.
Trial mode is fully local storage and doesn’t send any model data to the backend (the only network calls you might see would be Google Analytics).
You can try it without an account at https://wealthcurve.app/app/try. No signup, no email, just open the app and start forecasting.
Stack: Vue 3, Pinia, Firebase Auth + Firestore, Highcharts, WebCrypto.
Marketing pages are hand-rolled static html. Firebase hosting rewrites handle the routing to static HTML pages on some routes and routing to the Vue.js index.html on everything under /app/*.
I'd love feedback from the HN community
Thanks for taking a look.

value: Show HN: Wealth Curve – Financial forecasting with local storage and E2EE

author: fishbone


value: macfleid

value:
I've been building mobile apps for 10 years, mostly for clients. 2 years ago I decided to build something for myself.
Kubbo is a habit tracker where completing tasks builds a medieval city. Miss 2 days and a random building gets buried.
30,000 downloads, 4.8 on the App Store.
Built with Flutter. Happy to answer questions.

value: Show HN: Kubbo – build a medieval city with your daily habits

author: macfleid


value: thatxliner

value:
When writing, I would often find myself using older drafts just because I liked a wording in there better or copy+pasting paragraphs to try different ways to write it.
So, after several months of work, I built something where branching lives inline.
Quillium is a desktop writing app for long-form creative work such as novels, essays, memoirs, built with Tauri + SvelteKit and targeting desktop first because reliability is very important. Data stays local in SQLite with a crash-safe event log and automatic backups.
You can fork any passage into multiple versions that sit right inside the document and switch between them with a keybind. Undo works across the whole tree because it's one shared history regardless of where you're editing. Revisions can also nest INFINITELY: a version of a passage can itself have versions.
Of course, there's AI features but that's explicitly hidden because writers (who this app is marketed to) are extremely AI-averse. I know the HN community likely isn't though ;)
For those who want it (BYOK): there's an AutoAI mode that leaves notes as you write, and reader personas for parallel feedback from different simulated audiences. The disagreements between personas tend to surface real ambiguity better than a single "make this better" prompt.
Still early. Most curious what people think about the revision/branching model specifically because that's the most important part.

value: Show HN: Quillium, Inline Branching for Prose

author: thatxliner


value: Tjerkienator

value: Show HN: I created a leaderboard converting your LOC into garrytans. COPE

author: Tjerkienator


value: alierfan

value:
Skill files (.claude/skills/, .cursor/rules/*.mdc,
AGENTS.md, .windsurfrules) are becoming a core part of
AI-assisted development workflows. The problem: they
scatter across projects, diverge silently, and every new
repo means rebuilding behavioral config from scratch. Each
tool uses a different format and location.
Skilldeck keeps one local library and deploys to any tool
in the correct format automatically. Ten built-in target
profiles cover Claude Code, Cursor, Copilot, Windsurf,
Codex, and more. Drift detection shows when a deployed
skill has fallen out of sync with the library version.
Bidirectional sync lets you pull improvements back from a
project into the library.
The interesting part technically: the entire app was built
by Claude Code using a harness engineering methodology —
a ground truth JSON file, Playwright E2E verification
tests, a regression gate based on a surfaces map, and a
feature intake protocol. 31 features across multiple
autonomous sessions with no manual application code. I
wrote two articles about the harness approach if that side
is interesting.
No cloud, no backend, local filesystem only.
Windows/macOS/Linux. Open source.
github.com/ali-erfan-dev/skilldeck

value: Show HN: Skilldeck – Desktop app to manage AI agent skill files across tools

author: alierfan


value: datahover

value: Show HN: I built a project board where AI agents join as real teammates

author: datahover


value: omeraplak

value:
Feels a bit like Figma, but for coding agents.
Instead of going back and forth with prompts, you give the agent a DESIGN.md that defines the design system up front, and it generally sticks to it when generating UI.
Google Stitch seems to be moving in this direction as a standard, so we put together a small collection of DESIGN.md files based on popular web sites.

value: Show HN: Figma for Coding Agents

author: omeraplak

title: Show HN: Figma for Coding Agents


value: christiansafka

value: Hey HN!  I built Haven because I wanted the feeling of the native MacOS terminals with all of my work across different remote GPU machines.  Before Haven I had multiple vs code windows SSH'd into different machines, each running tmux.  I'm now 100% on Haven and my token usage has nearly doubled since the switch (in a good way), and seems to reduce my cognitive load with managing multiple agents.  Still early development but would love to get some feedback from SSH-heavy devs & ml eng.  - Christian

value: Show HN: Haven – persistent SSH sessions without tmux

author: christiansafka


value: dominka

value:
Hi HN,
we’ve been working on computer vision models for a while, and one thing kept coming up: improving them is surprisingly unstructured.
You train a model, try a few augmentations, tweak some hyperparameters, run it again - and if the metric goes up, you keep it. But it’s often unclear why it improved, or whether the model is actually learning something better.
We kept running into questions like:
- Did this change actually help, or is it just noise?
- Is the model focusing on the right features?
- Are we improving generalization, or just overfitting differently?
So we built BNNR (Bulletproof Neural Network Recipe) - an open-source PyTorch toolkit that turns model improvement into a closed loop:
- Train a controlled baseline
- Explain what the model actually learned (via XAI methods like OptiCAM / GradCAM)
- Improve by testing candidate strategies in parallel
- Prove the result with structured comparisons
One thing we focused on is avoiding “blind” changes. Instead of committing to a single idea (e.g. an augmentation), BNNR evaluates multiple candidates and only keeps those that measurably improve a selected metric. The goal is to reduce manual trial-and-error, not replace control.
We also use explainability as part of the loop, not just for visualization.
For example, in one experiment a model classifying airplanes was mostly focusing on the sky background rather than the object itself. This kind of behavior is hard to spot from metrics alone. After applying a targeted modification based on the model’s attention, the focus shifted toward the airplane, and performance improved on held-out data.
Under the hood, some of the improvements are driven by XAI-based transformations:
- ICD (Intelligent Coarse Dropout) masks the most salient regions (what the model relies on too much), forcing it to learn from broader context
- AICD (Anti-ICD) does the opposite - it masks less relevant regions and keeps only what the model considers important
We don’t treat these as “magic augmentations”, but as ways to test hypotheses about what the model is actually using.
BNNR works with its own augmentations as well as external libraries (e.g. Albumentations)
Each run is tracked and visualised in a live dashboard, where you can see:
- baseline vs improved metrics
- per-class performance
- attention maps before/after
- candidate branches being explored in parallel and which ones were selected or discarded
There is a trade-off: evaluating multiple candidates in parallel adds compute cost. In practice, we’ve found it comparable (or better) than manually running multiple experiments and tuning setups - but with much more structured results.
It’s still early, but currently supports:
- image classification
- multi-label classification
- object detection (just added today)
Would really appreciate feedback - especially from people experimenting with vision models or training pipelines.
You can try it here:
GitHub: <https://github.com/bnnr-team/bnnr>
Website: <https://www.bnnr.dev/>
Colab: <https://colab.research.google.com/github/bnnr-team/bnnr/blob...>

value: Show HN: BNNR – a closed-loop pipeline for improving vision models

author: dominka


value: viermalbe

value: I'm guilty of falling deep into the PKM rabbit hole and spending hours in stupid clicker games. This is the logical consequence.<p>Takes about 3 hours to finish. Add it to your favorite notes app and never look at it again.

value: Show HN: I made a clicker game about the PKM rabbit hole

author: viermalbe


value: aburayhanalif

value:
I built a lightweight CLI tool for Django and Django REST Framework projects to help detect common security issues early in development.
It focuses on problems like:
unsafe production settings
exposed or misconfigured APIs
missing security configurations
common security risks in Django projects
The goal is to make security checks simple and part of everyday development or CI workflows.
GitHub: https://github.com/abu-rayhan-alif/djangoSecurityHunter

value: Show HN: Django-security-hunter – Django security scanner CLI

author: aburayhanalif


value: wilg

value: Show HN: Tinder Swipe Everything in Wikidata

author: wilg


value: Enter a topic, pick a style and mood, get complete song lyrics with [Verse][Chorus] structure.<p>Examples included. No signup needed.

value: Show HN: Free AI Lyrics Generator

title: Show HN: Free AI Lyrics Generator


value: JustinLee-DEV

value:
I’ve always had a simple but annoying problem: I want to stay updated on the latest open-source projects and tech trends, but I really don’t want to rely on scrolling Twitter to get them anymore.
The signal-to-noise ratio is getting worse. To find a few genuinely valuable projects, most of my time is wasted on meaningless noise, outrage bait, and ads.
I tried various aggregators and subscription feeds, but I still ended up having to click through and filter things manually. The core issue wasn't solved.
So I built a small automated workflow called TechDistill. The goal is simple:
Stop browsing the feeds entirely, and just get a curated result every day.
Now, this pipeline generates four Markdown files daily:
One overall Overview, to quickly catch up on what's worth paying attention to today.
Three Source-specific reports (GitHub Trending, Hugging Face, Product Hunt) with more complete details.
My daily routine looks like this: I scan the overview first to quickly judge if there's anything worth diving into. If there is, I check the specific source report for the details. Every project comes with a short blurb telling me exactly "what it actually does," so most of the time I don't even need to click into the README to understand it.
The whole process is fully automated: scrape data directly from the sources → clean it up → let the model distill it. I basically don't visit the original sites anymore.
It runs on GitHub Actions once a day, takes under 4 minutes, and costs ~$0.008 per run (OpenRouter + DeepSeek v3.2).
I’ve been using it for a few days, and the most immediate change is this: I've actually stopped reflexively checking Twitter for tech news.
For me, the point of this project isn’t "AI summarization." It’s about turning scattered, high-noise information into a stable, low-noise input stream that I can actually accumulate over time.
Right now, it's mostly a personal tool, but I’m curious: is anyone else trying to solve this in a similar way, or do you have a better approach?
GitHub: https://github.com/JunstinLee/TechDistill

value: Show HN: I built a $3/yr AI workflow to stop doomscrolling Twitter for tech news

author: JustinLee-DEV


value: sijieg

value: We open-sourced the TLA+ and Fizzbee verified spec behind Ursa's storage engine. Verification across ~200K states caught a design bug that years of production missed. We then handed the spec to Claude Code — it produced a working Rust implementation (concurrent producers, compaction, fencing) without back-and-forth. We think verified specs are the best harness for coding agents: open-source the spec, let anyone implement it.

value: Show HN: Formally Verified Leaderless Log Protocol for Kafka

author: sijieg


value: lukeiodev

value:
Hi HN, I'm Luke.
LuxShot is a simple macOS menu bar OCR tool. Select a region on screen and the text goes straight to your clipboard.
Built with SwiftUI + Apple's Vision Framework. Open source on GitHub. Curious what you think!

value: Show HN: LuxShot – Open-source, native macOS OCR utility

author: lukeiodev


value: vinaybatra

value: Show HN: Corvo – Free portfolio analytics with MonteCarlo simulation and AI chat

author: vinaybatra


value: GaneshSuriya

value:
Last week we shared our VectorDBBench results [0] showing better accuracy and faster search.
this week you can checkout the sdk
and get an api key issued through github oauth. No card needed. Immediate free trial.[1]
What we built:
- 1M Vectors (100k on Free)
- Low latency hybrid search
- 1k Metadata filters
- 50M embedding tokens monthly (1M on Free)
- Build times that don't blow
if you are looking for an index that doesn't have a huge minimum fee or spiky/confusing usage based pricing it's only $10 a month. See if you can't cost us more than that!
[0] https://results.daseinai.ai/
[1] https://github.com/nickswami/dasein-python-sdk

value: Show HN: Faster more accurate multimodal vector search

author: GaneshSuriya


value: blackbrokkoli

value:
TLDR: I'm building an experimental open source/open data thing to collect good lecture recordings
website: https://lectures.koljasam.com/
repo: github.com/koljapluemer/awesome-lectures
Hi everyone,
this submission is my attempt to contribute something to the question of how we will find, share and evaluate information in the future, in the face of the many problems that I think HN is well-aware of (slob, search engines returning SEO garbage or corporate stuff, spam, trust problems, big companies eating everything,...).
I was specifically inspired by recent threads here on HN like https://news.ycombinator.com/item?id=47625952 , so I hope some of what I'm saying here resonates, even if it's very much not comprehensive (nor that coherent).
To get specific, I decided to build a little platform (if you want to call it that) to submit, rate and find long-form recordings of talks/lectures; both because this a personal itch of mine, but also because I consider it a good low-stakes environment to test some (possibly larger) ideas, such as:
- having a community-information-curation platform where both code and data are managed via an open git repo, but where non-technical people can also contribute, without interacting with GitHub or code
- allowing submissions and contribution without any gatekeeping (=no sign-up), keeping in mind that spam exists
- running such a platform on close-to-zero-budget
- allowing to (at least eventually) democratize the platform completely, so that it doesn't die with its maintainer's motivation
The current tech stack is as follows:
- data source of truth: JSON files in an open repo
- main interaction point: Classic HTML-based static site, works without js if you want to, generated with a custom SSG
- rating; submitting lectures; proposing changes: JS-based features on the static site, talking to a Flask backend via an API, writing change proposals temporarily to a DB
- Flask backend: Allows moderators (currently just me because no one else knows about this project yet) to accept or deny submissions (=spam prevention). Accepted data is written to the JSON-source-of-truth (using Bayesian updates for ratings and some semi-fancy merge algos)
Crucial idea here:
1) The data source+the viewing modality can be replicated, modified and viewed very easily, even if I get hit by a bus or get bored of the project
2) When the backend gets spammed (likely with no-auth submission affordances), hammered, hacked or neglected, (view) access to the data is not affected
So while I think that it in fact would be great if there was a great community-driven list of lectures, I also think this concept may as a (dis)prove or concept for far more important platforms, e.g. for discussing scientific findings, finding truth, storing community knowledge or stuff like that.
Just in case this wasn't clear yet, everything is still very experimental and work-in-progress (but feel free to give brutal feedback anyways)
Anyways, truly any kind of feedback or contribution is really welcome, be it in the form of lecture submissions, ratings, technical help, philosophy, or whatever else :)
Thanks and let's try to keep some kind of human internet alive.
post edit: formatting

value: Show HN: I'm building an open platform to submit, rate and discover lectures

author: blackbrokkoli


value: amysox

value:
In 2001 Electric Minds was shut down by its then-owners. We, the community, raised money for a server, rebuilt it on software I wrote, and kept it alive for years.
I've now brought it back to life, complete with original discussions from 2001-2006, on a new software platform, the Amsterdam Web Communities System.
This is part history, part rebuild, and part experiment: can human-scale online communities still work today?
More on this relaunch: https://erbosoft.com/blog/2026/04/07/electric-minds-reborn/
Source of Amsterdam: https://github.com/amysoxcolo/amsterdam

value: Show HN: Electric Minds Reborn: pioneering virtual community, on a new platform

author: amysox


value: apson

value: Show HN: Deconstructing a Black Hole in a Fragment Shader

author: apson


value: csima

value: Show HN: I built an AI pipeline to turn Infosec talks into readable, quick blogs

author: csima


value: Show HN: Tinycloud – Claude Code for video work


value: Absonsonson

value: Show HN: Unlegacy – document everything, from COBOL to AI generated code

author: Absonsonson


value: anzerarkin

value:
Built EvoCat, a strict iOS app blocker using Screen Time APIs.
Most apps still let you bypass mid-session.
This one doesn’t.
“Cats” are enforcement modes:
– IronCat: hard block
– BuffCat: effort to unlock
– SageCat: challenge
– ZenCat: delay
Pick one per day. No switching mid-session.
Would love feedback.

value: Show HN: EvoCat – a strict iOS app blocker with "cat"-based enforcement

author: anzerarkin


value: Show HN: mmcheck -- Check if a model supports multimodal inputs.


value: Bachal

value: Show HN: Dynamic Map of YouTube Channels

author: Bachal


value: zachdive

value:
Eve is an AI agent harness that runs in an isolated Linux sandbox (2 vCPUs, 4GB RAM, 10GB disk) with a real filesystem, headless Chromium, code execution, and connectors to 1000+ services.
You give it a task and it works in the background until it's done.
I built this because I wanted OpenClaw without the self-hosting, pointed at actual day-to-day work. I’m thinking less personal assistant and more helpful colleague.
Here’s a short demo video: https://www.loom.com/share/00d11bdbe804478e8817710f5f53ac61
The main interface is a web app where you can watch work happen in real time (agents spawning, files being written, use of the CLI). There's also an iMessage integration so you can fire a task asynchronously, put your phone down, and get a reply when it's finished.
Under the hood, there's an orchestrator (Claude Opus 4.6) that routes to the right domain-specific model for each subtask: browsing, coding, research, and media generation.
For complex tasks it spins up parallel sub-agents that coordinate through the shared filesystem. They have persistent memory across sessions so context compounds over time.
I’ve packaged it with a bunch of pre-installed skills so it can execute in a variety of job roles (sales, marketing, finance) at runtime.
Here are a few things Eve has helped me with in the last couple days:
-  Edit this demo video with a voice over of Garry: https://www.youtube.com/watch?v=S4oD7H3cAQ0
- Do my tax returns
- To build HN as if it was the year 2030: https://api.eve.new/api/sites/hackernews-2030/#/
AMA on the architecture and lmk your thoughts :)
P.S. I've given every new user $100 worth of credits to try it.

value: Show HN: Eve – Managed OpenClaw for work

author: zachdive


value:
Built a CLI that puts a reverse proxy in front of your local or deployed app, opens a CF tunnel and gates access behind a magic link auth for a specific list of emails.
I slapped that together bcs I'm too lazy to deploy and don't like too many eyes on my slop.
One command: agt00 start --origin http://localhost:3000 --emails george@kramericaindustries.com --tunnel
OSS, no accounts, no BS.
https://github.com/alex-sumin/agt00

value: Show HN: Agt00 – localhost sharing with an email allowlist


value: AndrewKemendo

value:
https://www.givedirection.com/
Every week on HN there's a valid thread about vibe coding producing unmaintainable garbage, or someone who built something with Claude over a weekend and can't explain how it works or fix it when it breaks. The gap I keep seeing is that people can't define their problem, don't scope their work, and rarely have exit conditions to test against such that they avoid these. This set of steps is arguably the most important thing you can do if you want something (software or otherwise) that lasts.
Direction runs monthly cohort-based courses where small groups go from idea to shipped MVP in four weeks. Cohorts are 30-40 people max, and instructors (mostly myself with some help from my friends) are people who have built and shipped real things, and we teach how to use AI as an assistive tool not your whole personality. Every project has a defined exit condition before anyone asks their tools to produce anything.
Every student presents what they built on demo day. Graduates join a permanent builders collective that grows with every cohort in a Discord group.
Ultimately we teach people: How to define what they are actually creating, what "done" looks like, how to maintain what they created and ultimately how to know when they have succeeded or failed.
Here's the syllabus:
Week 1: Problem decomposition and exit conditions. Creators have to write down exactly what they are going to present at the end of the course, how they think they will get there and what they plan to do with it after the course ends.
Week 2: Prototype. First working version. Doesn't have to be pretty it just has to exist and meet the self defined exit condition.
Week 3: MVP Testing and iteration. This is where the exit condition either holds or exposes what was wrong in week 1.
Week 4: Demo day. You show however far you got to the cohort, and your plans for the future and get their feedback.
$99/week pay as you go, no long term lock in or special platform junk.
Students pick their project or I have 13 defined project types, each with a written exit condition on the site. Creators own everything they build outright, I don't have any platform dependency, no subscription, no equity taken. The only costs are the weekly fee and your time.
Cohort 0 starts May 4th. Full curriculum and exit conditions at givedirection.com.
Happy to talk through ideas and questions and happy to have anyone who wants to be an instructor let me know.
View the Vision, Mission and Roadmap here:
https://www.givedirection.com/vision.html
HN discount code for 50% off is COHORT-0

value: Show HN: Direction – a 4-week course for people afraid of shipping AI slop

author: AndrewKemendo


value: shadoxise

value:
RMBG-1.4 + SAM running client-side via ONNX Runtime WASM. ~2s on laptop, works on mobile. Your image never leaves the browser.
Built this as part of allplix.com. 19yo student in France, solo project.
Happy to talk about the WASM pipeline or the pain of running ML models in a browser tab.

value: Show HN: I run AI background removal in the browser–no upload,no server

author: shadoxise


value:
I started building this for my dad to help track stock for his small manufacturing business, including reorder levels and answering "can I make x of this?". It's grown to include bill of materials, stock takes, purchase orders, and production orders, and aims to compete with spreadsheets rather than existing tools.
It's a local desktop app (Electron and SQLite), so there are no ongoing subscriptions or data sovereignty concerns, though you do pay the Electron RAM tax.
There's a 30-day trial with no feature restrictions at https://kitted.site.
I'd be delighted to answer any questions and take any feedback.

value: Show HN: Kitted: Local inventory and production management for small businesses


value: ruslanora

value:
I built a desktop app to manage my job search because I got tired of juggling Numbers, Notion, and Pages to track applications and different versions of my resume.
Kin is a private, offline-first tool for managing the job search process in one place:
- track job applications and conversations
- maintain a master resume and cover letter
- generate tailored resumes and cover letters per application
- store notes, contacts, and interview history
- (optional) Chrome/Brave extension for saving job listings
- calendar integration for interviews
Everything runs locally. No accounts, no cloud sync, and your data never leaves your machine.
It’s free and open-source: https://github.com/ruslanora/kin
Still early, but feedback is welcome, especially from people who’ve tried managing job searches with Notion, spreadsheets, or similar tools.

value: Show HN: I got tired, so I built an offline desktop job tracker + resume builder

author: ruslanora


value: mantyx

value: Hi all! I have been working on this tool for the past few weeks and I recently introduced the concept of a centrally managed MCP Server and now I am expanding the concept to also allow for your own agents to be exposed via MCP as tools.<p>This will allow you to take your agent anywhere MCP Connections are available to be made.

value: Show HN: Expose your agents via MCP as a tool

author: mantyx


value: KashyapArjun

value: Show HN: Pyre Agents – An Elixir-Orchestrated Runtime for Python Agents

author: KashyapArjun


value: Adanos

value: Show HN: The API directory for AI agents and developers

author: Adanos


value: maouida

value:
Hello HN users,
This is a CAD by code project I have been working on on my free time for more than year now.
I built it with 3 goals in mind:
- It should be familiar to CAD designers who have used other programs. Same workflow, same terminology.
- Reduce the mental effort required to create models as much as possible. This is achieved by:

    - Provide live rendering and visual guidance as you type.
    - Allow the user to reference existing edges/faces on the scene instead of having to calculate everything.
    - Provide interactive mouse helpers for features that are hard to write by code: Only 3 interactive modes for now: Edge trimming, Sketch region extrude, Bezier curve drawing.
    - Implicit coding whenever possible: e.g: There are sensible defaults for most parameters. The program will automatically fuse intersecting objects together so you do not have to worry about what object needs to be fused with what.

- It should be reasonably fast: The scene objects are cached and only the updated objects are re-computed.
I think I have achieved these goals to a good extent. The program is still in early stages and there are many features I want to add, rewrite but I think it is already usable for simple models.
Update to add more details:
This is based on Opencascade.js WASM binding. So you get all the good things that come with any brep kernel. Fillets, chamfers, step import and export...
The scene is webview but the editing is in your local file. You use your own editor and the environment you are familiar with.
One important feature that I think make this stand out among other code based cad software is the ability to transform features not just shapes. More here:
https://fluidcad.io/docs/guides/patterns
You can see it in action in the lantern example:
https://fluidcad.io/docs/tutorials/lantern

value: Show HN: FluidCAD – Parametric CAD with JavaScript

author: maouida


value: chrisecker

value:
Hi all,
Finding a good data structure for a word processor is a difficult problem. My notebook diaries on the problem go back 25 years when I was frustrated with using Word for my diploma thesis - it was slow and unstable at that time. I ended up getting pretty hooked on the problem.
Right now I’m taking a professional break and decided to finally use the time to push these ideas further, and build MiniWord — a WYSIWYG word processor in Python.
My goal is to have a native, non-HTML-based editor that stays simple, fast, and is hackable. So far I am focusing on getting the fundamentals right. What is working yet is:
- Real WYSIWYG editing (no HTML layer, no embedded browser) with styles, images and tables.
- Clean, simple file format (human-readable, diff-friendly, git-friendly, AI-friendly)
- Markdown support
- Support for Python-plugins
Things that I found:
- B-tree structures are perfect for holding rich text data
- A simple text-based file format is incredibly useful — you can diff documents, version them, and even process them with AI tools quite naturally
What I’d love feedback on:
- Where do you see real use cases for something like this?
- What would be missing for you to take it seriously as a tool or platform?
- What kinds of plugins or extensions would actually be worth building?
Happy about any thoughts — positive or critical.
Greetings

value: Show HN: A WYSIWYG word processor in Python

author: chrisecker


value: DavidCanHelp

value: Show HN: Gravity Garden, an Interactive Simulator

author: DavidCanHelp


value: bypirob

value:
Hello HN!
I like taking notes on paper, but organizing them on my computer always feels tedious, so I usually end up not taking notes at all.
I thought that a simple chat interface like Telegram, is so easy to use that I can just send text, photos, audio, links… then transcribe everything and use hybrid search to retrieve it later.
The idea is to remove as much friction as possible when capturing thoughts.
I’ve built this project for myself, so it's just a prototype to learn and experiment, and you can self-host it!

value: Show HN: Pensabot – second brain notes in a chat

author: bypirob


value: Show HN: I built a site that shows every world event you lived through


value: benclarkeio

value:
I’ve been working on the A2A Utils [1] package, a comprehensive set of utility functions for using A2A servers (remote agents). It has been three weeks in the making, and is based on nearly a year’s experience using A2A servers in production. The A2A MCP Server [2] and OpenClaw A2A Plugin [3] are wrappers around it, and it will power other packages in the near future. If you are planning on using A2A servers, I highly encourage you to read through the documentation for 30 minutes. I promise it will save you at least 10x that time!
A quick introduction to A2A. A2A standardises agent discovery, communication, and authentication. The protocol introduces the concept of an Agent Card, a JSON object containing the agent’s name, description, skills, accepted inputs, outputs, and authentication methods. It also defines a Message, a Task (a unit of work), an Artifact (the output of a Task), and a Part (a fundamental object for Messages and Artifacts that can represent text, data, and files).
Most people associate A2A with multi-agent systems, but it also serves as a framework for deploying agents. You get a standardised API endpoint for sending text, data, and files from any A2A compatible SDK, UI, or app. Agent Cards can be used to catalog and search agents. And A2A was explicitly designed for long-running, asynchronous tasks with support for polling, streaming, and webhooks. To learn more, see What is A2A? [4]
Check the GitHub discussion out, where I compare sending a Message and polling a Task with the A2A SDK and A2A Utils. I think it's much more elegant! I would love to hear your thoughts and welcome feedback.
Links:
[1] A2A Utils: https://github.com/a2anet/a2a-utils
[2] A2A MCP Server: https://github.com/a2anet/a2a-mcp
[3] OpenClaw A2A Plugin: https://github.com/a2anet/openclaw-a2a-plugin
[4] What is A2A?: https://a2a-protocol.org/latest/topics/what-is-a2a/#core-ben...

value: Show HN: A2A Utils – a comprehensive set of utility functions for A2A servers

author: benclarkeio


value: idiocache

value:
I wanted to share this again since I've made some significant updates since I last posted it!
The site now displays artist images and also has a map.
In general I'm really pleased with the mobile UX, which I think is quite clean.
Feedback appreciated and welcomed!

value: Show HN: Whirligig

author: idiocache

title: Show HN: Whirligig


value: Burnmydays

value: Show HN: Economy AI agents form teams, run missions, earn commissions

author: Burnmydays