value: alongub

value:
Hi HN, I'm Alon, and I'm building Alien, an open-source platform for deploying your software into your customer's environment and keeping it fully managed.
In my previous startup, I heard the same question from every single enterprise customer over and over again: "My data is sensitive. Can I deploy your product to my own cloud account?"
Self-hosting is becoming very popular because it lets users keep their data private, local, and inside their own environment. Unfortunately, self-hosting breaks down when someone starts paying for your software. Especially if it's an enterprise customer.
Customers usually don't actually know how to operate your software. They might change something small — Postgres version, environment variables, IAM, firewall rules — and things start failing. From their perspective, the product is broken. And even if the root cause is on their side, it doesn't matter... the customer is always right, you're still the one expected to fix it.
But you can't. You don't have access to their environment. You don't have real visibility. You can't run anything yourself. So you're stuck debugging a system you don't control, through screenshots and copy-pasted logs on a Zoom call. You end up responsible for something you don't control.
I think there's a better model of paid self-hosting: the software runs in the customer's environment, but the developer can actually operate it. It's a win-win: for the customer, their data stays private and local, and the developer still has control over deployments, updates, and debugging.
Alien provides infrastructure to deploy and operate software inside your users' environments, while retaining centralized control over updates, monitoring, and lifecycle management. It currently supports AWS, GCP, and Azure targets.
GitHub: https://github.com/alienplatform/alien
Getting started: https://alien.dev/docs/quickstart
How it works: https://alien.dev/docs/how-alien-works
Excited to share Alien with everyone here – let me know what you think!

value: Show HN: Alien – Self-hosting with remote management (written in Rust)

author: alongub


value:
NVIDIA still ships their occupancy calculator as an Excel file from the SM 7.x era. I wanted something I could link a colleague to, that supports newer architectures (Hopper, Ada, Blackwell) and shows the sweep across block sizes inline.
It's pure client-side JS — no backend, no tracking, no signup. The math lives in formulas.js so you can sanity-check it against the CUDA Programming Guide. Architectures and their per-SM limits are in presets.js.
Things I'd love feedback on:
* Are the per-arch limits correct for [arch you're least sure about]?
* The "compare two configs side-by-side" view - is the diff readable?
* Anything you wish the Excel version did that this doesn't?
Link: https://toolbelt.widgita.xyz/cuda-occupancy-calculator/
(There are a few other small tools at the root, but this one is the reason for the post.)

value: Show HN: A web-based replacement for Nvidia's CUDA occupancy spreadsheet


value: jerryluk

value: Show HN: Mailto.Bot – Email API for AI agents with native MCP support

author: jerryluk


value: insin

value:
Hi HN, I needed a distraction from the new and scary thing I was working on this weekend, so I grabbed HN's stylesheet, extracted CSS variables for every colour it defined, then re-applied them back onto HN using its own selectors (plus some extras for bits of HN which are styled inline, and some separation between header and content styling), allowing it to be themed with variables.
After using them to implement a dark mode (and a pure black variant for OLED), plugging everything into my existing HN browser extension which already lets you apply custom CSS, and making it handle theme switching via attributes on <html>, custom styles and theming are now manageable using it. There are a few examples in the friendly release notes above, with screenshots and copy-pasteable CSS.
If you just want to grab the stylesheet which sets up the CSS variables and application rules to use in your own thing, it's here [1], but not _everything_ is themeable without a bit more work - in particular, I had to replace the HN <img src="y18.svg"> logo with an inline version of the SVG, so its fills can be controlled by CSS.
[1] https://github.com/insin/comments-owl-for-hacker-news/blob/m...

value: Show HN: Themeable HN

author: insin

title: Show HN: Themeable HN


value: zonovar

value:
I revived an old idea I had, a small native macOS menu bar app that shows your tmux windows as Touch Bar buttons, so switching windows is one tap away.
It runs quietly in the menu bar, watches which terminal is focused (Terminal, iTerm2, Ghostty), and refreshes the Touch Bar with your current tmux windows.
This was a fun “vibe coding” side project, but also a practical tool I wanted for my own workflow. Hope it can be useful to someone else.

value: Show HN: Tmux-bar – One-tap switching between windows in current tmux session

author: zonovar


value: MalviyaPriyank

value:
I wanted a way to get the power of a multi agent system, handling everything from schema design to security hardening, without the "API tax."<p>That’s why I built Gyrus. It's a suite of open source, self hosted agentic frameworks: Frosty for Snowflake, Zeus for SQL Server, and Mick for Postgres.The core philosophy is total control: you host it, you own the credentials, and you choose the model.
I am also updating the snowflake agent this week to support open source Gemma 4 models, I ran evaluation against state of the art models, and its performing equally well when it comes to accuracy. Its little slower than them but it gets the job done for Free.
I've also implemented a "Safety First" architecture, including hard coded blocks for destructive commands like DROP at the tool level, because in data ops, prompt based safety isn't enough.

value: Show HN: Gyrus :Open-Source AI Agents for Snowflake, SQL and Postgres

author: MalviyaPriyank


value:
With Einlang, you can write codes as
let x = [

    [[1.0, 2.0], [3.0, 4.0]],

    [[5.0, 6.0], [7.0, 8.0]]

];
let row_sums[..batch, i] = sum[j](x[..batch, i, j]);
let loss = sum[..batch, i](row_sums[..batch, i] * row_sums[..batch, i]);
let dloss_dx = @loss / @x;
Einlang also supports recurrence. You can write codes like
let alpha = 0.25;
let x[0] = 8.0;
let x[k in 1..6] = {

    let prev = x[k - 1];

    let loss = prev * prev;

    let g = @loss / @prev;

    prev - alpha * g

};

value: Show HN: Einlang, a math-intuitive language with lots of good stuff


value: Whyachi

value: Last week I upgraded my GDL to version 12.1 with some key additions to the lengthy pipeline and switched the API's to calling Opus 4.7 and Gpt 5.4. Much more diverse and rich invention outputs.

value: Show HN: My Invention Engine – GDL is more powerful

author: Whyachi


value: zacksiri

value:
Honestly I didn't think it would be possible when I started, my background is Elixir / Phoenix / Backend engineering. But thx to Codex the app turned out to be something I'm quite proud of.
The app is designed to help you find movies to watch. Give you back control, instead of just taking what the algorithms give you, and you end up scrolling for 30 mins not picking anything just to end up on youtube or tiktok.
You can find movies based on your interest, ask it for top 10 lists on specific providers and so on...
Do let me know your thoughts. I've personally discovered many gems I never knew existed for example:
- Uncut Gems
- Awakenings
- Wake up Dead Man (Knive's Out)
- A Quiet Place I / II
- Blackberry
- Army of Thieves / Army of the Dead
- Infernal Affairs
- The Amateur
I hope it gives you as much joy as it has given me.

value: Show HN: My First iOS App

author: zacksiri

title: Show HN: My First iOS App


value: ecesena

value: Show HN: Open security key on nrf52480 with NFC

author: ecesena


value: RyanProietto

value: Show HN: Release of Writing App: Alistair v1.0

author: RyanProietto


value: pzxc

value: Each day I'm making a new HTML5 video game, competitive with high scores. This is day 5. Happy to answer any questions, please tell me if this project is too trivial or too ambitious, depending on the day I feel both ways :)

value: Show HN: Making video games every day with Claude (Day 5: Minefield)

author: pzxc


value: keepamovin

value: Show HN: Make an immutable web flipbook from any doc, video or browser replay

author: keepamovin


value:
ctx is a local SQLite-backed skill for Claude Code and Codex that stores context as a persistent workstream that can be continued across agent sessions. Each workstream can contain multiple sessions, notes, decisions, todos, and resume packs. It essentially functions as a /resume that can work across coding agents.
Here is a video of how it works: https://www.loom.com/share/5e558204885e4264a34d2cf6bd488117
I initially built ctx because I wanted to try a workstream that I started on Claude and continue it from Codex. Since then, I’ve added a few quality of life improvements, including the ability to search across previous workstreams,  manually delete parts of the context with, and branch off existing workstreams.. I’ve started using ctx instead of the native ‘/resume’ in Claude/Codex because I often have a lot of sessions going at once, and with the lists that these apps currently give, it’s not always obvious which one is the right one to pick back up. ctx gives me a much clearer way to organize and return to the sessions that actually matter.
It’s simple to install after you clone the repo with one line: ./setup.sh, which adds the skill to both Claude Code and Codex. After that, you should be able to directly use ctx in your agent as a skill with ‘/ctx [command]’ in Claude and ‘ctx [command]’ in Codex.
A few things it does:
- Resume an existing workstream from either tool
- Pull existing context into a new workstream
- Keep stable transcript binding, so once a workstream is linked to a Claude or Codex conversation, it keeps following that exact session instead of drifting to whichever transcript file is newest
- Search for relevant workstreams
- Branch from existing context to explore different tasks in parallel
It’s intentionally local-first: SQLite, no API keys, and no hosted backend. I built it mainly for myself, but thought it would be cool to share with the HN community.

value: Show HN: Ctx – a /resume that works across Claude Code and Codex


value: ramonga

value: Vibe-coded it some months ago, open sourcing so you can fork and made your own.

value: Show HN: Open-source alternative HN front page with point highlights and search

author: ramonga


value:
Enlist AI is a free web app I built to help people prepare for job interviews. You paste a job description, and it generates a personalized study plan with topics, priority levels, and estimated hours. It also includes a CV builder and voice training to practice answers.
No sign‑up required during beta. Just paste a JD and start.
I'd love brutal feedback. What features are missing? What's confusing?
Also, if you fill out the feedback form on the site, you get one month free when we launch.

value: Show HN: Enlist AI: A tool that turns any job description into a study plan


value: vfalbor

value: Show HN: Reproducible benchmark – OpenAI charges 1.5x-3.3x more for non-English

author: vfalbor


value: szamski

value: Show HN: Hora – A Native SwiftUI Google Calendar Client for macOS

author: szamski


value: Show HN: Noise.widgita.xyz – a zero-back end noise map for anywhere in the world


value: kiosktryer

value: Show HN: My Hyperliquid Terminal

author: kiosktryer

title: Show HN: My Hyperliquid Terminal


value: amallia

value:
Hi HN, Antonio here. Founder of Seltz.
Seltz is a web search API built for AI agents. We wrote the crawler, the index, and the retrieval models ourselves, in Rust, by a team that's spent years building web search at scale. In our tests, queries come back in under 200ms.
Efficiency was the first design principle. Search sits on the critical path: agents  can't generate their first tokens or kick off the next tool call until results come back. When you run tens or hundreds of queries in parallel, every millisecond of tail latency compounds.
Most search APIs for agents are wrappers around Google or Bing. If your agent already has a Google tool, a second call to a Google-wrapped API returns the same ten documents. We run our own independent index, so you get different results and different rankings.
Coverage starts with US news. More verticals are coming.
There's a free tier with $100 in credits at the link. I'd love feedback from anyone building agents: how does it compare to what you're using, and where does it fall over?

value: Show HN: Seltz – The fastest, high quality, search API for AI agents

author: amallia


value: mcisternino

value:
Hi HN,
I’ve been working on pwneye, a CLI tool for interacting with IP cameras exposing ONVIF and RTSP services.
During penetration tests and red team engagements, I kept running into the same friction, with discovery, authentication testing, enumeration and stream validation spread across different tools or quick one-off scripts.
pwneye was built to handle that workflow end-to-end, from discovery to actually accessing and validating streams.
Current features include:
- ONVIF discovery and authentication testing (wordlists, multithreading)
- Post-auth enumeration (device info, users, network config, media profiles)
- RTSP extraction via ONVIF
- RTSP port detection and basic vendor identification
- Vendor-aware RTSP bruteforce
- Stream validation, preview and recording
- ONVIF reboot support
It’s still early, but already usable in real-world engagements.
Would be interested in feedback, especially from people who have dealt with ONVIF/RTSP cameras or IoT security in general.
Repo: https://github.com/hackerest/pwneye

value: Show HN: Pwneye – discovering and accessing IP cameras (ONVIF/RTSP)

author: mcisternino


value: cavalrytactics

value:
Hello, looking for some users interested using a devtool that allows developers to centrally manage AI Coding Agent tools that supports all AI Coding Agent tools like Claude Code, Codex, Antigravity, etc.
Try it free!
https://www.producthunt.com/products/sigma-shake-governance-...

value: Show HN: AI Coding Agent Guardrails enforced at runtime

author: cavalrytactics


value: jakubb

value:
Hi HN,
I wanted an app to practice public speaking and get feedback on my English, since I’m a non-native speaker. I couldn’t find anything like that since most tools are AI tutors, which feel very repetitive and boring.
The idea is simple: you prepare and record your opinion on a random topic, then improve over time. Topics are varied, so you can practice defending your point, sharing your experiences, or talking about your plans.
I’m open to any feedback: orratio.com

value: Show HN: I built an app to practice public speaking for ESL learners

author: jakubb


value: delduca

value: Show HN: Poor's Man Shaders

author: delduca

title: Show HN: Poor's Man Shaders


value: duman

value: Show HN: Glimpse – A native macOS Markdown viewer with on-device AI

author: duman


value: macwhisperer

value:
go to -- https://freelava.neocities.org --
it's a free digital lava lamp!
works on desktop and mobile..
use it as a desktop screensaver (I like to use two separate windows of it)
or just touch the goo on your mobile phone / touch screen device!

value: Show HN: Freelava – Lava Lamp in an HTML Page

author: macwhisperer


value: Show HN: We built Cursor, but for data transformations (open source)


value: adzicg

value:
Hey HN,
For people using ICE score to triage ideas, I just made a free online ICE score calculator. Would love your feedback.
It's designed for teams to quickly type in or copy/paste a bunch of ideas and rank/score them to see which ones are worth taking further into the backlog.
The calculator is relatively opinionated, with two confidence presets, one inspired by Itamar Gilad's Confidence Meter (from Evidence Guided) and the other from Trisha Greenhalgh's Levels of Evidence model (from How to Read a Paper). For people wanting something custom, it also allows people to easily configure their own scales and evidence types, including impact and effort ranges, units and switching from logarithmic to exponential or linear progression.
Works in the browser, data fully private to your profile, no sign up required.

value: Show HN: Online ICE Score calculator/prioritization

author: adzicg


value: informsyed

value: Show HN: troubleshooting.sh – paste a error, get a fix with root cause explained

author: informsyed


value: no-mistakes is how I kill AI slop. It puts a local git proxy in front of my real remote. I push to no-mistakes instead of origin, and it spins up a disposable worktree, runs my coding agent as a validation pipeline, forwards upstream only after every check passes, opens a clean PR automatically, and babysits CI pipeline for me.

value: Show HN: Git Push No-Mistakes

title: Show HN: Git Push No-Mistakes


value: DavidCanHelp

value: Show HN: Clock-MCP, stop guessing the time in AI

author: DavidCanHelp


value: hideload

value:
While editing a document, it is a general practice to create backup files, and naming the "final", "final v2", "final v2 updated" etc. They make the desktop untidy and bring confusion on the latest version in future.
My document snapshot solution (Hideload Version tracker) allows user to manually take document snapshots before editing a document.
• Snapshots are hidden, and there is only one visible file in the desktop.
• Snapshots are compressed saving a lot of storage space. (Around 50-60% compression)
• You can add Unique comment to each snapshot to understand the contents of it in future.
• Snapshots can be opened and viewed in respective app anytime for comparison.
• Original document can be restored to any snapshot, any time.
• You can move the original document anywhere. Hideload still identifies all the associated snapshots with the tracking ID appended to the file name.
Open the link to view screenshots or download Hideload for free.

value: Show HN: A document snapshot solution to counter backups with name "Final_final"

author: hideload


value: dunetrace

value: Show HN: Dunetrace – Runtime failure detection for AI agents

author: dunetrace


value: Show HN: Resume Script for VLC

title: Show HN: Resume Script for VLC


value: recvonline

value: Show HN: The Guesthouse – A quiet place to begin the day

author: recvonline


value: pierrepomes

value: Show HN: Myanon – fast, deterministic MySQL dump anonymizer

author: pierrepomes


value: laurentiurad

value: Inspired by the success of OpenClaw, I built Comrade, which is an open-source AI workspace for teams focused on security. It provides a premium interface for AI-powered workflows, built with transparency, extensibility, and local-first principles. Check it out here: https://github.com/LaurentiuGabriel/comrade

value: Show HN: I built Comrade – the security-focused AI agent

author: laurentiurad


value: Nortey

value:
As someone who likes to keep up with politics but finds legislation a pain to read, I created Explain The Law to make understanding bills and executive orders easier. I’ve seen a number of other websites that also do this, but the summaries were either too brief or too wordy and poorly structured. I wanted to strike a balance between “give me the gist of it” and “tell me everything this legislation does”.
Some information about the tech:

   - I use Gemini 2.5 Pro to generate the summaries

   - I use the Gemini .NET library using structured objects to invoke prompts. This lets me receive structured responses in a guaranteed format, which allows each page to be uniform.

   - I locally generate each summary one by one and store them in a local database. I then statically generate the html for each page at build time. I’ve seen similar sites that invoke LLMs and generate summaries at runtime, which feels slow and doesn’t scale well.

One of my biggest worries was hallucinations, as accuracy is essential for websites dealing with legislation. After a lot of testing, I learned that prompting to “anchor facts to actual text from the legislation” effectively eliminates hallucinations. This also allows me to provide direct references to the official text for individual sections of the summary pages, allowing users to easily verify information themselves.
You can see an example of this with the recently trending “Parents Decide Act” here:
https://explainthelaw.com/bill/hr8250-parents-decide-act/
One of the initial reasons I created this site was because I was curious about some details in the “Big Beautiful Bill”, but was having a hard time manually parsing the official text. In addition to the high level summary pages linked above, the site also provides itemized breakdown pages for large omnibus and appropriation bills:
https://explainthelaw.com/details/119-HR-1/
I update the site daily so that the latest legislation is always available. Would be happy to hear any thoughts, feedback, or suggestions about the site.

value: Show HN: Explain The Law – Simplified legislation and executive orders using AI

author: Nortey


value: rngil

value: Hi HN,<p>I made a little something that could be useful to those like me that read pdfs at night.

value: Show HN: Simple CLI tool to convert PDFs to dark mode, with TOC preservation

author: rngil


value: chernikovalexey

value: Show HN: A tiny macOS app that clears app caches and NPM/Docker/Xcode junk

author: chernikovalexey


value: rupestre-campos

value:
Hello HN,
built this project to unify cutting edge tech for fast vector and raster serving over the web into a single docker compose, using only open source technologies.
The main language is python, DB is postgres with postgis, vector tiles made with tippecanoe, satellite image search via STAC and rendered with titiler.
OGC API spec is the glue to make it all integrable with existing software like Qgis.
The project code was created using ai assistance,  following my architecture decisions gathered building (and using) systems to serve large geospatial content.
Rather than a job done this is a start, being a base to integrate more tools and allow more analysis in future.
Code on github:
https://github.com/rupestre-campos/geofastmapAPI

value: Show HN: GeoFastMapAPI – open-source Fast vector and raster server for mapmakers

author: rupestre-campos


value: RyanZhuuuu

value: Show HN: I Built SwiftUI but for macOS MDM

author: RyanZhuuuu


value: zeroecco

value:
I got tired of libvirt XML and Vagrant's Ruby/reload dance for single-host VM stacks, so I built a compose-style runtime directly on QEMU/KVM.
What's there: GPU passthrough as a first-class primitive (VFIO, OVMF, per-instance EFI vars), healthchecks that gate depends_on over SSH, socket-multicast L2 between VMs with no root and no bridge config, cloud-init wired through the YAML, Dockerfile support for provisioning.
What it's not: Kubernetes. No clustering, no live migration, no control plane. Single host.
Prototype, but I'm running it on real hardware. Curious what breaks for people.

value: Show HN: Holos – QEMU/KVM with a compose-style YAML, GPUs and health checks

author: zeroecco


value: coderai

value:
I’ve been building and using agents heavily lately. The Model Context Protocol ecosystem is growing insanely fast, but discovering and configuring new tools is still highly manual. Every time I needed to connect an agent to a new service, I had to browse registries, figure out the transport type, identify required env vars, and manually update "mcp.json" files.
So I built MCPfinder. It aggregates servers from the official MCP registry, Glama, and Smithery (around 25,000 combined entries) into a deduplicated, ranked catalog.
But the real twist is the DX: MCPfinder is itself an MCP server :D
You only install it once as your "base capability" via standard stdio: npx -y @mcpfinder/server
From then on, when you tell your AI, "I need to query my PostgreSQL database," the magic happens autonomously.
It's completely free, AGPL-3.0 licensed, and built purely to optimize AI-tool surface discovery.
I'd love to hear your thoughts, feedback, or edge cases where JSON generation for specific platforms is acting up.

value: Show HN: MCPfinder – An MCP server that finds and installs other MCP servers

author: coderai


value: Show HN: Virtual Frame – Microfront end projection for the web


value: Sibexico

value:
So, I wanna show my personal project, what I made for myself and already used it for some time... This is a lightweight PGP workstation for work with text messages. Very simple interface, encrypted storage and basic process protection from tempering (in Windows and Linux). I made it as a lightweight and simple alternative for Kleopatra. Just basic workflows for sign/verify/encode/decode text messages. I will rly appreciate any feedback about this project.
Direct link to the project at GitHub: https://github.com/sibexico/Eris
For Windows users available thru WinGet: winget install --id sibexico.Eris -e

value: Show HN: Eris – desktop PGP workstation with simple GUI

author: Sibexico


value: nickswami

value: Show HN: Dynamic Hybrid Search That Beats Pure Dense and Fixed Hybrid

author: nickswami


value: mohamedattahri

value: Show HN: CLI – A Go command-line library shaped like net/HTTP

author: mohamedattahri


value:
I run three to seven Claude Code sessions in parallel terminals, and I kept losing track of which was doing what, especially toward the end of the day when your mind is so tired with the constant context-switching.
which-claude-code is a small plugin that adds a title and color to each Claude Code, so you know right away which Claude Code session does what.
1. On every prompt submit, a UserPromptSubmit hook forks a background claude -p --model haiku call that reads the last few transcript turns and writes a 3-6 word title to ~/.claude/which-claude-code/titles/<session_id>.txt. The hook returns in ~10ms so the prompt isn't delayed.
2. A statusline script prints ● <title> · <model> · <cwd> (<branch>) on every render. The dot and title are tinted from a 20-color palette hashed off the session ID.
Enjoy!

value: Show HN: Auto-generated titles and colors for parallel Claude Code sessions


value: BleedingXiko

value:
I’ve been building a full-stack framework where you write both backend and browser code in Python.
No separate frontend, no API layer, it compiles Python to JS for the browser and keeps everything in one model (state, actions, realtime, etc).
It’s pre-alpha but already usable. Curious what people think.

value: Show HN: Sprag – full-stack Python framework with no JavaScript Required

author: BleedingXiko


value: jokera

value: Show HN: Trees Hate You Guide – play the demo

author: jokera


value: ymaws

value: Show HN: Mimi in the browser – hear the semantic/acoustic split

author: ymaws


value: bobbies-treats

value:
Weekly Log is a minimalistic social media website designed for you to do journaling and creative writing.
A lot of modern social media apps are set up in a way that addicts and detriments the users, meanwhile profiting off of their data. I really wanted to make a site that doesn't operate in that way.
Some of its distinctions:
- You can create one post per week. This encourages care and consideration.
- Nobody knows who you follow or what posts you react to, besides you and the other user. These stats are personal, so people view your logs free of outside influence.
- Posts are rich text-only, no images or videos, in an effort to reduce mental clutter.
- Your feed only features users you follow, to give you increased control of what you see, unless you click the "global" checkbox to see all posts.
quick demo: https://www.youtube.com/watch?v=7CTnORsGnL8
overview page: https://www.weekly-log.com/about/overview
---
I have soft-launched this website, and a handful of my friends have signed up and made posts. They're posting cool stuff, which has me excited.
I still have a number of big features that I'd like to implement, such as:
- prompts that users can create and select as weekly writing inspiration for their posts. (ex. "A dream you wish you had")
- saving content to different folders, and perhaps allowing users to organize folders of their own content on their profile page
- commenting on posts (would also be solely an interaction between the commenter and the poster)
- ability to make your account private
- advanced search features for content discovery without ambiguous algos
But anyway, I think it would be fantastic to get some strangers using it too. I think my consumer base is realistically- writers, creative types, introverts, people burnt out from modern software and tech.
I wanted to see what you all thought of this project. Any feedback on the concept, the design, the features, etc.? Any changes you would suggest or things to look out for? Also, I have toyed with the idea of starting to find ways to advertise this more, but curious if you all think now is a good time to start, or if I should wait until after I have developed more of the features I mentioned above? Or if you have any ideas for how I could approach the advertising side of it...
Feel free to check it out yourself, if you'd like: https://www.weekly-log.com/

value: Show HN: Weekly Log, Old-school journaling social media

author: bobbies-treats


value: robeenly

value:
I've been working on NeuG (pronounced "new-gee"), an embeddable graph database that follows the same philosophy as sqlite and DuckDB — in-process, zero configuration, just pip install and query.
What's different from existing embedded graph DBs:
- Dual-mode: start embedded, flip one line to expose as a network service — same data, same queries, no migration
- Built on GraphScope Flex, the engine behind the current LDBC SNB Interactive world record (80k+ QPS)
Local benchmark highlights on LDBC SNB SF1 (~3M nodes, 17M edges):
Embedded mode vs LadybugDB (Kuzu-based): NeuG wins 8/9 LSQB queries single-threaded vs LadybugDB's best multi-threaded result. 287x on triangle patterns (Q3), 91x on two-hop filtering (Q2).
Service mode vs Neo4j: 617 QPS vs Neo4j's 12 QPS on LDBC SNB Interactive — 50.6x throughput. P95 latency 20ms vs Neo4j's 1,728ms.
Currently Python only. Node.js bindings and GraphRAG/vector extensions are on the roadmap.
Would love feedback — especially from anyone who's tried Kùzu, LadybugDB, or runs Neo4j in production.
GitHub: https://github.com/alibaba/neug
Blog post with full details: https://graphscope.io/blog/tech/2026/04/12/neug-one-engine-t...

value: Show HN: NeuG – High-performance Embedded graph DB, one line to serve

author: robeenly


value: daco

value: Show HN: Real-time visualization of Claude Code agent orchestration

author: daco


value: caihongxu

value:
Hi HN — I built Palmier.
Palmier bridges your AI agents and your phone.
It does two things:
1. It lets you use your phone to directly control AI agents running on your computer, from anywhere.
2. It gives your AI agents access to your phone, wherever you are — including things like push notifications, SMS, calendar, contacts, sending email, creating calendar events, location, and more.
A few details:
* Supports 15+ agent CLIs
* Supports Linux, Windows, and macOS
* What runs on your computer and your phone is fully open source
* Works out of the box — no need to set up GCP or API keys just to let agents use phone capabilities
* Your phone can act as an agent remote: start tasks, check progress, review results, and respond to requests while away from your desk
* Your phone can also act as an agent tool: agents can reach into phone capabilities directly when needed
* Optional MCP server: if you want, Palmier exposes an MCP endpoint so your agent can access phone capabilities as native MCP tools. This is optional — you can also use Palmier directly from the phone app/PWA, with those capabilities already built in
* Still in alpha stage, with bugs. Opinions and bug reports very welcome
The basic idea is that AI agents become much more useful if they can both:
* interact with the device you actually carry around all day
* be controlled when you are away from your computer
Palmier is my attempt at that bridge.
It already works with agent CLIs like Claude Code, Gemini CLI, Codex CLI, Cursor CLI, OpenClaw, and others. You can run tasks on demand, on a schedule, or in response to events.
Would especially love feedback on:
* whether this feels genuinely useful
* which phone capabilities are most valuable
* which agent CLIs I should support next
* what feels broken, awkward, or confusing
Site: https://www.palmier.me
Github:
* https://github.com/caihongxu/palmier
* https://github.com/caihongxu/palmier-android
Happy to answer questions.

value: Show HN: Palmier – bridge your AI agents and your phone

author: caihongxu


value: samirketema

value: Show HN: pg_roast – A Postgres extension that harshly judges your database

author: samirketema


value: chaidhat

value: Show HN: I built an AI that assigns YOU tasks

author: chaidhat


value: obilgic

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

author: obilgic


value: andrewchilds

value: Hi HN. I built this to help me keep my books in order and get my personal + small business tax returns for this year filed. I had been using an older piece of accounting software I wrote maybe 10 years ago that I never open-sourced; I realized that agents can actually help quite a bit with accounting tasks, so I built this new version. It's a local-only app that uses Bun and Postgres. No telemetry aside from what you choose to send to an agent. It makes backups, you can undo/redo, and you can export/import using JSON. Federal, state and corp tax categories are built-in so you can link accounts to specific schedules and lines. It handles imports from a lot of different sources quite well.

value: Show HN: Local, agent-friendly double-entry bookkeeping and tax prep

author: andrewchilds


value: blirio

value: Show HN: A fake small claims court for petty complaints

author: blirio


value: tmatsuzaki

value: Show HN: Kachilu Browser – a local browser automation CLI for AI agents

author: tmatsuzaki


value: Show HN: AI agents deploy apps autonomously (no accounts, no API keys)


value: madatbay

value:
I built Alignear because I kept seeing the same problem: teams running healthy Linear workflows but still writing manual client updates after every cycle.
The issue isn't access — clients don't need to be in Linear. The issue is translation. Linear data is internal by nature, and turning it into something a stakeholder actually understands is tedious work that falls on someone every sprint.
Alignear sits on top of your Linear workspace and handles that layer:
- Automatic cycle reports generated from your Linear data
- Custom reports with any filters you need
- Secure client portal — clients open a link, no account required
- AI agent inside Linear — tag @alignear in any ticket comment to capture tickets as meeting notes, more capabilities coming
Built this solo. It's live and working in production.
Would love feedback from anyone who's dealt with this problem — particularly interested in hearing how larger teams handle client communication today and where the current solution breaks down.
alignear.com

value: Show HN: Alignear – Client communication layer for Linear teams

author: madatbay


value: linuz

value:
I built OpenBridge: a local bridge that lets agents and tools talk to models through the web chats you already have access to, using a standard OpenAI-style API.
The idea is simple: if you can use a model from a browser chat, OpenBridge exposes that access as a local endpoint, so tools like OpenCode, OpenClaw, PI, or anything else that speaks the OpenAI format can use it too.
How it works:
* runs locally
* uses your existing authenticated web session
* translates requests and responses into a standard OpenAI-compatible interface
* supports normal chat flows and tool-style interactions
I’ve already used it to build multiple complex apps with it, including through OpenClaw, and it’s been great.
---
The motivation is bigger than just saving tokens.
I think inference should be as accessible as possible. If a person already has access to a model, they should be able to use that access from their own tools, on their own machine, without being forced into a separate paid API path just to automate legitimate personal workflows.
If your main concern is protecting the ToS of billion-dollar AI companies that ingested the open web at massive scale and now charge users for access to models trained on it, then this project is not for you.
https://github.com/uncensoredcode/openbridge
And yeah, this post was also written using OpenBridge.
Cheers,
Linuz

value: Show HN: OpenBridge – turn web chat access into an OpenAI-compatible endpoint

author: linuz


value: vinserello

value: Show HN: DSS, a new human-readable and plain format for XLS and spreadsheets

author: vinserello


value: jmkni

value:
I travel a lot and commonly find myself connecting to public wifi networks where the details are written down on a card or a piece of paper, which then results in having to fiddle about finding the network and typing in the password
Built this little app so I can just take a photo of it, and then it figures out the details and connects my phone to the WiFi
No sign up, no ads, no tracking
Let me know if you find it useful
Cheers

value: Show HN: TapFi – Join any WiFi just by scanning the details with your camera

author: jmkni


value: eropatori

value:
Here's a game my kids and I vibe coded, inspired by another game I saw here a couple of days ago.
This one is supposed to be hard, but not hard to understand, and it's cooler on mobile.
This was my first pure vibe-code-and-I'll-never-look-into-the-code experience. I've been developing for more than 40 years, so it's not natural to me. I'm pretty impressed so far.
Feedback is very welcomed.

value: Show HN: Tiltbump – another game in a single HTML file

author: eropatori


value: bebedi

value: Hey everyone, I recently built AnyHabit, a minimalist, self-hosted habit tracker designed for home servers, and I just released v0.1.0 and made it fully open-source under GPLv3. I wanted something simple without subscriptions or bloat, so I built this to track both positive habits you want to build and negative ones you want to avoid, and it even calculates the money you save from avoiding those bad habits.<p>It's definitely not perfect and is still a very simple app at its core, but since this is my first major open-source launch, I'd really love to get some eyes on it. I'm actively looking for feedback, feature ideas, and pull requests if anyone is looking for a React or FastAPI project to contribute to.

value: Show HN: AnyHabit – A minimalist habit tracker for Raspberry Pi and Docker

author: bebedi


value: mariusbolik

value: Show HN: WeTransfer Alternative for Developers

author: mariusbolik


value: keepamovin

value: Show HN: Static Flipbooks of Complex Media

author: keepamovin


value: surrTurr

value: Show HN: My AI Native Obsidian Setup

author: surrTurr

title: Show HN: My AI Native Obsidian Setup


value: hoponthestack

value:
Anvil.works is a low-code Python web-app platform. Its "Server Uplink" lets an external Python process act as a server module — connect over a websocket and you can call server functions, query Data Tables, etc.
anvil-uplink-cli is a thin CLI over that library. The bits worth looking at:
- query, call, row, run, repl — the things you'd otherwise do by pasting into the web Server Console
- multi-app profiles, pretty/JSON output, works the same on Windows / macOS / Linux / WSL
- a dotenv: key_ref scheme designed for AI coding agents: the Uplink key stays in a gitignored .env, never in a tool-call argument, never in the agent's context
That last bit is the part I most want feedback on. The standard "just use an env var" advice works fine for humans, but when a coding agent is driving your CLI, any inline KEY=... cmd lands in the transcript — and a malicious row from the database could then instruct the agent to exfiltrate it. dotenv: side-steps this by making the CLI read the key itself and never exposing it to the caller.
Built this scratching my own itch while using Claude Code on my Anvil apps. Early alpha, MIT.

value: Show HN: Anvil-uplink-CLI – agent-safe terminal CLI for Anvil.works apps

author: hoponthestack


value: websku

value: Launched first version of our chrome extension for ActorDo - Work Assistant

value: Show HN: Chrome extension for always on Work Assistant (ActorDo)

author: websku


value: Samuellrose

value:
Hi HN. I'm Samuel, founder of Agensi (agensi.io). I'm a  non-technical founder in the Netherlands. Built the platform mostly with Claude Code and Lovable over the last few months.
What it is: a curated marketplace for SKILL.md skills. SKILL.md is the folder-plus-instructions format Anthropic shipped for teaching AI coding agents (Claude Code, Cursor, Codex CLI, Gemini CLI, and others) new capabilities. Creators publish skills, users install them into their agent. Every listing goes through an automated security scan before going live.
Two things I've tried to do that felt missing from the
ecosystem:
1. Curation with security. Running someone else's code on your machine without review is a real risk, especially given the ToxicSkills and ClawHavoc research that came out earlier this year (36% of sampled skills had prompt injection vectors). Every skill on Agensi runs through an automated scan checking permission boundaries, outbound network requests, dependency red flags, and common malware patterns. It's not perfect and doesn't replace reading the code yourself, but it filters the obvious bad stuff.
2. Creator monetization. Two paths, creator picks whichever fits the skill. Direct sales: set a price, buyer pays once, creator keeps 80% minus a $0.50 per-sale fee. MCP subscription pool: 70% of net MCP subscription revenue distributed monthly based on which skills paying users actually pulled in via MCP. The idea is that time spent encoding your workflow knowledge as a SKILL.md shouldn't just earn you GitHub stars.
There's also an MCP server that makes skill discovery agent native. Four tools: search_skills, get_skill, submit_skill_request, get_skill_requests. Your agent can search the catalog and pull in a skill mid-task
instead of you browsing the site. If the skill is not on the marketplace, the agent can add a skill request that pings every creator on the platform. Subscription is $9/month with a 3-day trial.
Honest state of things:
- 40 creators, 200+ skills listed
- 66 articles in the Learn section, ~7k active users over
  the past 28 days
- MCP subscription launched last week. 1 paying subscriber
  so far (yearly), 1 trialist who cancelled before
  converting. Too early to say anything about conversion.
- Pre-seed discussions with VC’s ongoing
- GMV month 1 of ~200$
Things I'd genuinely want feedback on:
- Creator split. Direct 80/20 and MCP 70/30. I picked numbers that felt defensible after running the math on infrastructure and payment costs. Open to the argument that either should skew further toward creators.
- Security scan depth. The current scan is automated and covers the basics. Whether to add creator identity verification, manual review queues, or public scan reports per skill is an open question for me.
- Moat. Anthropic, Cursor, and others could launch first-party skill stores whenever they want. My thesis is that a curated cross-agent marketplace is defensible because first-party stores are always vendor-locked. I would like to hear counterarguments.
- Skills you've wished existed but couldn't find. Open to
  hearing what's missing from the catalog.
Browse is free, no signup needed: https://agensi.io
I'll be in the comments.

value: Show HN: Agensi – Curated marketplace for AI agent skills (SKILL.md)

author: Samuellrose


value: mparas

value: Show HN: Learn languages by tilting, shaking, and smiling at your phone

author: mparas


value: przemekdz

value:
Hi!
I'm currently building some apps, and one thing that bothered me was that I started to lose ideas. I tried writing them in Linear, but it just didn't click with me.
So I created an app that solves two things for me. First, it has one board for all projects. Second, it's simple.
One board is super useful if you work on a few projects at a time, which I think is the new reality right now. I'm jumping from project to project many times a day, so not having to jump between tabs or boards in a task manager is a huge plus.
Let me know what you think!

value: Show HN: One board with tasks for all your projects

author: przemekdz


value: maziggy

value:
Show HN: BamBuddy – a self-hosted print archive for Bambu Lab 3D printers
Bambu makes great hardware, but your data lives in their cloud and there's no way to export it. When a print finishes, the job is basically gone from any useful record-keeping perspective.
BamBuddy fixes that by running on your own machine and tapping into the printer's local MQTT interface — so it captures everything as it happens: thumbnails, filament usage, timing, slicer settings. You end up with a fully searchable archive of your print history that's entirely yours, works offline, and never touches Bambu's servers.
The catch: their local API is undocumented, so a lot of the early work was reverse-engineering the protocol. That's still ongoing as firmware updates occasionally break things.
Stack: TypeScript, self-hosted, ~1000 stars, active contributor community.
GitHub: https://github.com/maziggy/bambuddy
Website: https://bambuddy.cool Forum/Chat: https://forum.bambuddy.cool Docs: https://wiki.bambuddy.cool

author: maziggy


value: mchab

value:
Ad blockers aren’t really enough anymore. There’s still a lot of noise and low-quality content that slips through.
I built Unwired, an open-source DNS layer that uses an LLM to filter what you see based on your preferences, not just static blocklists.
Repo: https://github.com/moe18/Unwired/tree/main
Extension: https://chromewebstore.google.com/detail/unwired/eagjafndbce...

value: Show HN: Unwired – LLM-powered DNS to filter the internet

author: mchab


value: dinarino

value: Show HN: Doxa – open-source platform for multiagent simulations using easy YAML

author: dinarino


value: WasimBhai

value: I built rapunzel because in the MacOS terminal, I had many agents running across tabs but they were difficult to track. I built it because I love the Tree Style Tab Extension in Firefox. I built it because, it is the time for Chrome, but for agents. I made it, to make it as simple as possible and nothing more.

value: Show HN: Rapunzel, a tree-style tab browser for agents

author: WasimBhai


value: privaloops

value: Show HN: Hevc.js – HEVC/H.265 to H.264 transcoding in WebAssembly (236KB)

author: privaloops


value: jblox

value:
I got tired of reading the same bedtime stories every night. Then I tried some AI story generators and they all just produced generic slop. So decided to have a crack at it myself and built Dreamtime.
I've spent a few weeks now iterating on the prompting. At first this also produced generic slop, but I've slowly built a few cool features into the prompting and the stories are getting good!
1. You can select from a list of values that resonate with you, these values get woven into the stories.
2. Stories are targeted by age. Length and vocabulary reflect the age of the children they are for (A 2-year-old gets ≤300 words with sensory refrains; a 9-year-old gets up to 2000 and can handle ambiguous endings.) and the stories also target certain developmental milestones for children.
3. Added variety and randomness by using RNG on the server to select things like setting and theme on the server. I found the LLM alone just always collapses to pretty much the same story - so the server picks the species, setting, angle, tone, and structure independently and hands all of that to the LLM. One seeded 32-bit RNG drives the lot, so I can reproduce any story exactly from its seed.
Any feedback is greatly appreciated!

value: Show HN: Dreamtime – A fresh bedtime story for your children every night

author: jblox


value: Please give your feedback after trying it out.

value: Show HN: Vibe coding t-rex.world

title: Show HN: Vibe coding t-rex.world


value: zzet

value:
The core idea doesn't seem new after the hype of a few similar tools.
I wanted to have a solution for a smart search between repositories, contract recognition (across repositories/business flows), where they're broken, and where a bug sits in multi-step user interaction, considering the product is built in different languages, which are in different repositories. It evolved into the daemon that indexes the code and, paired with a coding agent via MCP protocol (in a mono-repo or multi-repository mode), provides real-time code indexing and many MCP tools (47 at the moment) for cases like getting exact function code (instead of reading whole file), query code structure, trace call chains across repos, detect dead code, semantic search across the code.
VS Code (10.7K files) indexed in ~1 minute, Linux kernel (70K files) in ~3 minutes
Licensed under PolyForm Small Business — free for personal use, open source projects, small businesses, education, and healthcare.
I knew a few similar projects were launched in the middle of Gortex's development, but after recent testing, I found it worth sharing the project with others and listening to their feedback.

value: Show HN: Gortex – MCP server for cross-repo code intelligence

author: zzet


value: kolx

value:
Hi HN,
I built VidStudio, a privacy focused video editor that runs in the browser. I tried to keep it as frictionless as possible, so there are no accounts and no uploads. Everything is persisted on your
machine.
Some of the features: multi-track timeline, frame accurate seek, MP4 export, audio, video, image, and text tracks, and a WebGL backed canvas where available. It also works on mobile.
Under the hood, WebCodecs handles frame decode for timeline playback and scrubbing, which is what makes seeking responsive since decode runs on the hardware decoder when the browser supports it.
FFmpeg compiled to WebAssembly handles final encode, format conversion, and anything WebCodecs does not cover. Rendering goes through Pixi.js on a WebGL canvas, with a software fallback when WebGL is
not available. Projects live in IndexedDB and the heavy work runs in Web Workers so the UI stays responsive during exports.
Happy to answer technical questions about the tradeoffs involved in keeping the whole pipeline client-side. Any feedback welcome.
Link: https://vidstudio.app/video-editor

value: Show HN: VidStudio, a browser based video editor that doesn't upload your files

author: kolx


value: keepamovin

value:
Repo for Rust binary releases: https://github.com/DO-SAY-GO/flipbook-releases
Site (explanation & demos): https://flipbook.browserbox.io
I like the idea of scrubbable assets in a consistent format. Toyed with making it an actual fileformat (zipped manifest + folder of images) but for now settled on this static site generator.
You can also capture your browser sessions (e.g. https://browser-session-it94u.pages.dev/ ) if you have a BrowserBox license. Example: https://asciinema.org/a/eXhizwQ9FU5y49eP
I like doing a lot with simple technology.

value: Show HN: Archiving Videos and PDFs on Cloudflare Pages Using JPEGs


value: ABSALOMMAXY

value:
https://roadmap-project-bygrl.vercel.app/
I've been using a small version of this on myself at the gym for the past year. Instead of logging sets and counting macros, you could just upload a photo of yourself every week and the AI tells you how close you are to the goal and what to adjust in the plan.

value: Show HN: I made an AI fitness coach that actually makes sure you reach the goal

author: ABSALOMMAXY


value: Show HN: Intake – Secure client document collection with browser-side encryption


value: boratanrikulu

value: Show HN: Bpfvet – minimum kernel version and CO-RE analyzer for BPF objects

author: boratanrikulu


value: blemis

value:
We were running 5 fine-tuned MiniLM models for a resume-to-job matching pipeline — 455MB on an $11/month VPS, one per task. I consolidated them into a single shared encoder with 5 lightweight heads: 25MB total, same latency, zero API calls. The matching score went up, not down.
The 5 tasks:
1. Classify JD lines (requirement vs boilerplate)
2. Split requirements into required vs preferred
3. Disambiguate skill mentions (Python-the-language vs Python-the-ecosystem)
4. Textual entailment (does resume experience satisfy a requirement?)
5. Semantic embeddings for similarity search
All five share MiniLM-L6 (22M params). Before: 5 x ~91MB fine-tuned copies — essentially the same encoder with different weights, burning RAM for no reason on a 4 vCPU / 8GB box. The obvious idea: share the encoder. One copy in memory, five lightweight heads (~580KB each) routing its output to task-specific predictions.
Attempt 1: Frozen encoder, linear heads. Cache CLS embeddings, train heads on cached vectors. Fast. Every head lost 10-15% accuracy. Pretrained representations weren't tuned for our tasks.
Attempt 2: Multi-task fine-tuning, 4 objectives. Unfreeze, train all four heads simultaneously with alternating batches, differential LR (encoder 2e-5, heads 1e-3).
Classification recovered to within 2% of standalone. But embedding quality collapsed — "Python programming" and "cooking recipes" hit 0.91 cosine similarity. Classification
objectives pushed all representations into a small region where heads could classify, destroying the distance structure embeddings need.
Attempt 3: Add contrastive objective as 5th task. Cosine similarity loss on positive/negative pairs alongside the four classification objectives. Explicitly penalizes the collapse. Encoder now has two competing incentives: make CLS tokens classifiable AND keep similar texts close / dissimilar texts far apart.
Gotchas:
Task weighting. Smallest dataset (65K) was drowned by largest (1.6M). 3x weight fixed it.
Embedding objective needs mass. 270K contrastive pairs vs 2.1M classification wasn't enough. Scaled to 1M pairs at 2x loss weight.
Some heads need independent training. Required-vs-preferred head wouldn't converge multi-task. Diagnostic showed encoder representations separated the classes (0.80 within vs 0.02 between cosine). Encoder fine, head was the problem. Froze encoder, retrained just that head in 30 seconds. 99% accuracy.
Result: one 22.9MB INT8 encoder + five ~580KB heads = 25MB total. Also a DeBERTa encoder (68.5MB) with two heads for token-level tasks (NER + section segmentation). Total: 94MB
for 7 models, $11/month VPS, zero API costs.
The kicker: matching score went UP (71 → 75) because the entailment head became more accurate. It identifies when experience satisfies a requirement that a keyword matcher would miss. Pipeline speed 19s → 8.7s. Consolidated for RAM, got better accuracy as a bonus.
One thing I'd do differently: start from sentence-transformers/all-MiniLM-L6-v2, not the cross-encoder checkpoint. Sentence-transformer's embedding space is already oriented toward similarity; cross-encoder's is oriented toward ranking. Better starting point for the contrastive objective.
Happy to answer questions about multi-task training, the embedding-collapse diagnostic, quantization, or production deployment.
Soft launch — product is live at the URL, free to try one report. Feedback welcome, especially from anyone who's been through ATS-backed applications. And if you want to argue with the architecture choices, even better.

value: Show HN: We replaced 5 ML models with 1 shared encoder on an $11/month VPS

author: blemis


value: Show HN: Ketchup – a Pomodoro timer with separate work and break budgets


value: tetrakai

value:
I built a security game that lets you try to break an AI support agent.
I work on security engineering, and it's incredibly hard to try to defend against an attack that you don't know how to perform yourself. There's also next to nowhere to improve your skills. I'd heard all about fooling AI agents with just "IGNORE ALL PREVIOUS INSTRUCTIONS", but I'd never actually put that into practice, and it turns out it's harder than you'd expect!
Just like knowing basic security skills is important for all software engineers, anyone working with AI should know what prompt injection looks like, and should be thinking about how to prevent it. Flight Risk lets you practice your AI agent manipulation skills: it's got your standard prompt injection and social engineering, but more than that too, each a real vulnerability.
Think you could crack it? Every engineer I've given it to has been surprised by the challenge! You can use the hints, but they affect your score ;)
Give it a try, and let me know how you do!

value: Show HN: Flight Risk: Can you break an AI agent?

author: tetrakai


value: Show HN: Orbital – Give Your Agent a Project, Not a Prompt


value: jalapenobasil

value:
Hey HN. Graph Compose is a hosted platform for orchestrating API workflows on Temporal. You define workflows as graphs of nodes (HTTP calls, AI agents, iterators, error boundaries) and everything runs as a durable Temporal workflow under the hood.
Three ways to build the same graph: a React Flow visual builder, a typed TypeScript SDK (@graph-compose/client), and an AI assistant that turns plain English into a graph.
Open-core: the execution foundations and integrations service are AGPL-3.0. The platform orchestrator, visual builder, and AI assistant are proprietary.
Longer backstory on why I built this in the first comment. Would love feedback, especially from anyone who's dealt with the "services work fine, the glue between them doesn't" problem.
Docs: https://graphcompose.io/docs

value: Show HN: Graph Compose – Temporal workflows with visual builder, SDK, and AI

author: jalapenobasil


value: AmarGandhi

value: Show HN: Claude Buddy Pico – Pi Pico 2 W Port of Claude Desktop's Hardware Buddy

author: AmarGandhi


value: Show HN: Gennie - Turns Meeting Discussions into Assigned Tasks with Due Dates


value: quenzo

value:
We'll all have personal agents soon. They will know our tastes, our humor, our schedule.
FlirtingBots puts that to work for dating: your agent talks to other people's agents, surfaces shared interests, tests compatibility, and only hands off to you when both sides detect a spark.
You open the match with icebreakers and date ideas already prepped. No cold-start.
Also shipped as an OpenClaw skill on ClawHub if you run your own agent.

value: Show HN: FlirtingBots – My AI agent flirts with yours, we meet if it clicks

author: quenzo


value:
Hey HN. This is my first  time posting here so please be patient with me if I make any mistakes with the format.
I want to tell you about Anvil. Anvil is two open-source tools that're in the same repository. They help solve two problems I have been having at my job. At my job I have to work with 5 repositories and we use Kafka and a shared Postgres database.
My first problem was that I got tired of explaining my project to Claude every time I started a session. Every time I started a session I would spend the first ten minutes explaining my project pasting files and talking about which services communicate with each other and what Kafka topics we use. The window where I could type would fill up quickly. I would run out of space to do my actual work. It felt like a waste of time and money. I was paying for the information to be repeated over and over.
So I built Anvil Pipeline. Anvil Pipeline looks at every repository in my project builds a graph of how everything's connected and automatically detects the relationships between them like Kafka topics and HTTP routes. This graph is then added to every agent call so the agent already knows how my project is set up. I do not have to paste files
The pipeline runs across all my repositories. Has many stages, including planning, building and validating. Every stage is saved, so if I lose my connection or my laptop goes to sleep it can pick up where it left off. I built this feature because I got frustrated with losing my work when the connection timed out.
My second problem was that every time I used an MCP client like Claude Code or Claude Desktop it would suggest functions that do not exist in my code. I also tried using AI code search tools. They were either tied to a specific IDE or required a SaaS backend that I did not want to use.
So I built Code Search MCP. It is a MCP server that any client can use.
Code Search MCP uses Tree-sitter parsing for 8 languages and has a search function with many tools, including find_callers and find_dependencies. The default embedding provider is Ollama so it is free to use. I also support providers like Voyage and Mistral if you want better results.
I spent a lot of time working on indexing, which means that only the parts of the code that have changed are updated. This makes it much faster and more efficient.
Both Anvil tools are fully local which means they do not send any information back to me or require you to create an account. They are also source under the MIT license. The dashboard is not very pretty. I ran out of time to work on the design.
I would really appreciate your feedback on the following things:
Whether the cross-repo detection strategies work for codebases or just mine.
-Whether the 8-stage pipeline is too rigid, for how other people work.
-Which of the 11 MCP tools are actually useful. I think 2 or 3 of them might not be needed.
-You can find the repository here: https://github.com/esanmohammad/Anvil

value: Show HN: Anvil – a multi-repo AI pipeline and an MCP server for code search


value: florinmatinca

value: Show HN: SimCast – Control iOS Simulators remotely with real-time interaction

author: florinmatinca


value: calebevans

value:
I built Mulder for the SANS "FIND EVIL!" hackathon. My background is not in forensics, but I was interested in building the agent. I've been seeing some really cool results and thought this community might like it!
Mulder is an MCP server that exposes forensic tools like Volatility, Sleuthkit, Plaso, and more as typed tool calls. Every invocation is recorded in an append-only audit log. When an agent finds something, it submits a "finding" to the case database. Each finding must have evidence citations that are validated before being admitted. If the agent cites evidence or a tool execution that doesn't exist, the finding is dropped.
The biggest problem I needed to solve was context window pressure. These investigations often contain a lot of data, and processing it produces a lot of noise that will fill a context window quickly. To avoid this, all tool output is stored in a per-case SQLite database with full-text search. The agent can then search the database and request segments of tool output as much as it wants.
It ships as a container with all forensic binaries, symbol tables, YARA rules, MITRE ATT&CK data, and Claude Code pre-configured. You just have to mount your read-only evidence directory, start the container, and ask Claude to start an investigation.
I tested it against two test scenarios that I found online. Based on the ground truth I have been able to find, Mulder is producing pretty impressive results. I have provided the output from these runs in the examples in my repo.
If you know a lot about digital forensics or if it's something that interests you, please check it out. I'd appreciate any feedback.

value: Show HN: Mulder – Containerized MCP server for digital forensics investigations

author: calebevans


value: vovanidze

value: Show HN: A stateless search proxy using Cloudflare Workers

author: vovanidze


value: dassh

value:
Hi HN, I built a thing that turns any webpage you're visiting into an interactive arcade: https://playanypage.com/
It's a fun little project built entirely around bookmarklets and DOM manipulation. Inspired by the classic Kick Ass app, I loved the idea of playing on any website, so I decided to take it a step further and build an entire arcade inside a single bookmarklet.
You just drag it to your bookmarks, click it on any site, and it immediately plays on top of the DOM.
Brickout: Turns every text block and element on the page into a brick you can smash.
Also made Snake, Space Invaders, Whack-a-Mole, and a chaotic Page Taxi that drives all over your screen.

value: Show HN: Turn Any Webpage into a Game

author: dassh

title: Show HN: Turn Any Webpage into a Game


value: benldrmn

value:
Hi HN, I am excited to share with you something I have been working on for the past 6 months or so.
Isola is an open-source sandbox platform for running untrusted code in your own Kubernetes cluster with gVisor.
It took me quite a few iterations to get the api just right. Some design choices:
* REST and streaming APIs (building SDKs on top) - executing commands, transferring files, etc
* flexible network policies, tailored for untrusted workloads
* operational simplicity: one Helm install, no external database / Redis / queues etc
One example of a feature I like is the ability to snapshot the root filesystem, storing it in some bucket for later restore (exposing the snapshots via a NFS on each cluster node). Useful for initializing a sandbox once and reusing many times, or checkpointing between interactions.
It strives to give you a strong platform to develop on, while keeping your data within your network, with your existing observability tools, cloud resources and in-cluster latency.
Happy to get your thoughts, answer questions or talk more about the design and implementation of Isola.

value: Show HN: Isola – Open-source sandboxing on Kubernetes

author: benldrmn


value: This is a silly experiment inspired by a thought I always have when downloading large files: I've always wondered if there was any use for a system that only let's downloads progress if the user stays "active" in some way - maybe as a perverse way to ration the large file downloads to the people who really want them.

value: Show HN: Jiggle: speed up the download by jiggling the mouse


value: yincrash

value:
Aide is an Android app that replaces your default digital assistant. It can
register as your default assistant, so corner-swipe and power-button-hold summon
it instead of the Google assistant.
I wanted to do something other than Google, but ChatGPT and Claude's integration couldn't do anything on device, so I built this.
Bring your own key for Claude, OpenAI, or any
OpenAI-compatible endpoint (Ollama, LM Studio, vLLM). Keys are encrypted
on-device; conversations go straight to your provider.
Free: chat on any provider, multi-provider switching, web search + URL
fetching as built-in tools, custom system prompt, markdown.
Pro ($6.99 launch week, $9.99 after, one-time): voice input + streaming
TTS, voice-first overlay, photo/file attachments, device actions
(SMS/calendar/alarms, every intent confirmed), screen context, Home
Assistant integration.

value: Show HN: Aide – A customizable Android assistant (voice, choose your provider)

author: yincrash


value: jamestransient

value:
CLI permission policy and audit layer for AI agents. Two minute installation.
When an agent goes wrong the question is always the same: what did it do, was it authorised, can you prove it.
Only 21% of companies have a mature governance model for autonomous agents.
Transient wraps your agent process and enforces a permission policy before execution. Define what the agent is allowed to do. Anything outside that gets blocked. Every action gets a signed, tamper-evident receipt the agent can't alter.
pipx install transient-trace
transient-trace wrap install git curl pip uv sudo --auto-rc
source ~/.zshrc
transient-trace run claude
Start in audit mode to see what your agent is actually doing. Switch to strict when you want to enforce.
No code changes. Works with Claude, any CLI tool, anything you can wrap.
Alpha. Keen to hear from anyone deploying agents in production.
github.com/james-transient/transient

value: Show HN: Transient – CLI Governance layer for AI agents

author: jamestransient


value: mnapoli

value:
I'm writing a book of my family's history and I want to add good looking trees for each family.
I started building them by hand but it's a lot of work to design and maintain.
So I built this "Family Tree Maker".
You can use the built-in form and download the image, as well as save the URL to come back to your tree later.
It also works as an API and MCP server, for use with AI like ChatGPT or Claude. I'm using this to automate building this trees: I ask Claude to take the FamilySearch data and build the tree image of a single family.
The website is free and the code is open-source on GitHub: https://github.com/mnapoli/family-tree-maker

value: Show HN: Family Tree Maker

author: mnapoli

title: Show HN: Family Tree Maker


value: xydac

value: Show HN: CheckAgent The open-source pytest testing framework for AI agents

author: xydac


value: AnchorFlow

value:
While building a payment orchestration system, I ran into a problem:
Most monitoring tools alert when a threshold is already breached (e.g. P95 > 1000ms). But in practice, systems often degrade before hitting those limits — especially under bursty traffic.
So I experimented with detecting degradation before thresholds are crossed, directly inside a FastAPI app.
I built a small middleware that:
Tracks P95 latency per route template (e.g. /users/{id})
Learns a baseline dynamically from recent traffic
Detects spikes using rate-of-change (not just static thresholds)
Computes a 0–100 health score with trend direction (improving / stable / degrading)
Stores events in Redis Streams for replay and debugging
One interesting result:
In synthetic load tests (gradual latency ramp from ~200ms to ~1200ms over 60 seconds, with a P95 warning threshold at 1000ms), rate-of-change detection consistently surfaced degradation slightly before static threshold alerts. The window is small, but it was often enough to notice system stress before crossing alert thresholds.
Design constraints:
Near-zero overhead on the request path (async, fire-and-forget writes)
Must fail silently if Redis is unavailable
No external monitoring stack required (runs in-app)
Example usage:
pythonapp.add_middleware(RequestMetricsMiddleware, alert_engine=engine)
Context:
This is part of a larger system I'm building that integrates cloud services with mobile money APIs (EcoCash, etc.), where partial failures and latency spikes are common.
Still early — hasn't been tested under real production traffic yet.
Curious how others are handling early degradation detection in FastAPI or similar systems.
Repo: https://github.com/Tandem-Media/fastapi-alertengine
PyPI: https://pypi.org/project/fastapi-alertengine/

value: Show HN: Detecting API degradation before thresholds are crossed

author: AnchorFlow


value: gslepak

value: Show HN: Group Income – FOSS Privacy Respecting Basic Income System

author: gslepak


value: santiago-pl

value:
Hi, I’m Jakub, a solo founder based in Warsaw.
I’ve been building GoModel since December with a couple of contributors. It's an open-source AI gateway that sits between your app and model providers like OpenAI, Anthropic or others.
I built it for my startup to solve a few problems:

  - track AI usage and cost per client or team
  - switch models without changing app code
  - debug request flows more easily
  - reduce AI spendings with exact and semantic caching

How is it different?

  - ~17MB docker image
    - LiteLLM's image is more than 44x bigger ("docker.litellm.ai/berriai/litellm:latest" ~ 746 MB on amd64)
  - request workflow is visible and easy to inspect
  - config is environment-variable-first by default

I'm posting now partly because of the recent LiteLLM supply-chain attack. Their team handled it impressively well, but some people are looking at alternatives anyway, and GoModel is one.
Website: https://gomodel.enterpilot.io
Any feedback is appreciated.

value: Show HN: GoModel – an open-source AI gateway in Go

author: santiago-pl


value: namin

value: I created LemmaScript to compile TypeScript to a verification backend (Dafny or Lean) and prove properties on the systematically derived model. I'll keep developing this, but I have a few case studies already, and it looks quite promising, with the caveat that each case study pushed the development of the core further. I can support both greenfield and brownfield projects, and in many cases, verification can be in-place: the TypeScript source is just annotated and verified independently but runs as is.

value: Show HN: LemmaScript, a verification toolchain for TypeScript via Dafny

author: namin


value: hiribarne

value:
I built ProtoWall to solve a problem I kept running into: needing to share a working prototype with an investor or client, but not wanting to just hand out a URL with no protection.
ProtoWall sits as a reverse proxy in front of your app. You invite reviewers by email, they click a link, read and sign a versioned NDA, and then get proxied through to your prototype. No SDK, no code changes on your end.
How it works:
- You add your prototype's origin URL and configure an NDA
- Invite specific people by email; they get a one-click link
- Reviewer accepts the NDA (name, timestamp, IP, user agent all recorded)
- A 30-day proxy session is created; traffic flows through to your app
- You can revoke access instantly; the session terminates immediately, not at the next token refresh
Every action is audit-logged. You can export a CSV of the full trail or download a per-reviewer PDF evidence package with consent records, NDA text, and SHA-256 content hashes; useful if you ever need to prove someone agreed to your terms.
Auth is magic-link only (no passwords to manage or leak). NDAs are versioned; if you update the text, existing reviewers must re-accept before they can access again.
Free tier: 1 project, 5 invites. Pro is $19/mo for 5 projects and PDF evidence export.
Happy to answer questions about the architecture or the legal side of things.

value: Show HN: ProtoWall – NDA wall and reverse proxy for sharing prototypes

author: hiribarne


value: AndyCappDev

value:
Stet is a PostScript Level 3 interpreter, a PDF reader, and a print-quality PDF writer, all in pure Rust. All three converge on a single DisplayList type, so any output device (PNG, desktop viewer, PDF, WASM) works with any source — you can render a PS file to PDF or PNG, a PDF to PNG, or to a display list for a custom backend all through the same pipeline.
The link above is the WASM build running entirely client-side — drop a PS, EPS, or PDF and it renders. It's a capability sampler, not a production viewer: no system fonts (browser sandbox), fixed zoom stops, single-threaded at ~2× native overhead.
Why build it: GhostScript is AGPL, pdfium is enormous, and there wasn't a pure-Rust stack that covered PostScript and PDF end-to-end. Apache-2.0 OR MIT.
Source: https://github.com/AndyCappDev/stet
Install: cargo install stet-cli for the CLI, cargo add stet for the library (the stet facade crate re-exports the whole toolkit).

value: Show HN: Stet – PostScript Level 3 interpreter and PDF toolkit in Rust

author: AndyCappDev


value: cjbarber

value:
I also went a bit overboard on the UI.
Some of the backstory:
- I'd seen Boris's X thread of lesser known claude code features
- I taught two of my non-technical friends some claude code features in person recently (I did a few AI tutoring sessions with friends, for fun and curiosity)
- In the process of teaching others, I consumed some of the official educational content from Anthropic
- I saw how many not well known features there are!
- With a lot of Claude's help I made this.
- The UI scope expansion was very fun to indulge.
Let me know what you think!

value: Show HN: I made a quiz to help people learn Claude Code features (with macOS UI)

author: cjbarber


value: octobereleven

value:
A bit of context…
I've been building https://blogmaker.app since April 2021, 5 years now. The launch tweet: https://x.com/BlogmakerApp/status/1383742023627247630
I had built it initially as a personal challenge to see if I could have a working product for 20 hours worth of work, and I did it. This was way before AI tools.
A few months later, I included a Stripe button and the first payment came immediately in.
In September 2022 I decided to focus (give up my contract gigs as a designer/dev). I took out a personal loan for $20K and then an angel investor handed me another $30K, so I could fully focus on Blogmaker (blogstatic then). And that's what I did. Night and day. Mostly working on the product and getting it to where it is now. It was super basic in the beginning, with one theme and non–SEO advanced features that it has now.
Up to the end of 2024, prices were yearly only with $19/year and $49/year being the bestsellers.
Throughout this time, I was constantly told (by good meaning friends) that I am charging too low and I should charge more. Combine that with my restlessness to make it a real monthly MRR (yearly prices kinda skew MRR), so at the end of 2024, I took the dive and changed the pricing to monthlies. First starting with $25/month, which I think due to January being a "new year's resolutions" month, got me a solid few upgrades, but it turned out to be a false positive, because sales stalled after that.
Then throughout 2025, I flailed with various monthlies: $12, $19, $29, $39, and even $49/month at one point. The $12/m and $19/m seemed to be working fine, but customers would stay a few months and then leave.
In the back of my mind, I always wanted to go back to yearlies because, in all honesty, I felt "yearly prices" were "the brand" and I loved the kick I would get from customers saying: "WOW! What a product at this price!". I loved being the face of accessibility and running a product that is filling a real gap.
To test my assumptions that "yearlies" are great, throughout the "monthlies" period in 2025, I would run flash sales with $19/year and $39/year plans, and they'd sell like hot cakes.
So after 16 months of not really being convinced on the monthlies, this April I happily reverted to the original yearly prices of $19, $49, and $59/month, and I've already sold a few, as expected.
Changing back to yearlies, feels like a huge burden has been lifted off my shoulders. Customers really loved the yearly Blogmaker and I'm 100% happy to be that!
I strongly believe Blogmaker is an amazing product at an insanely great price, but I'm banging my head against the wall not knowing how to get everyone wanting to start a blog to know about it.
If you look at the showcase of current customer blogs, you'll see what I mean: https://blogmaker.app/showcase
An important note: Historically, yearly prices have converted 10% visits–to–trial, and 15% trial–to–paid (sometimes insanely more), and this was all done with just 40 visits/day, some of those visits were actual customers coming back to the website to login, so % were clearly higher.
I've tried most marketing things, short of paid ads, which there was never a real budget for AND the yearly prices didn't really allow for much wiggle room as far as CAC goes.
Currently there are ~250 active paying customers with blogs ranging from business, SEO, product, services, journals, culture, hobbies, and everything in between. The peak it's ever been was circa 500.
There are two individuals currently interested in buying it out and the money would somewhat help to focus on another SaaS, but I'm crying inside not wanting to let it go.
The ideal outcome would be to convert 5 payments/day which would make it a $5K/month revenue business, and that's completely fine. Which statistically means roughly about 300 visits/day.
Technically, not sure how to get there.
Please, feel free to ask me anything. I've been super open throughout.

value: Show HN: I built a blogging platform (5 years in, struggling with distribution)

author: octobereleven


value: fagnerbrack

value: Show HN: Read.place/view – Reader view for any article and TL;DR summary

author: fagnerbrack


value:
So as I was scrolling LinkedIn for a long time, I started noticing how little actual matches I get with my real background. Not even the keywords I use seem to matter. If I look for ML or AI Engineer I get more often than not completely unrelated: DevOps, Java, even Electric Engineer! The new AI feature they have where you describe the job you want to find doesn't seem to help either.
I decided I would make my own AI workflow to find these good matches.
The basic idea is simple: load your information and job search preferences, find the LinkedIn posts, give a scoring for every job post, a recommendation if to apply or skip, so I can focus only on the few jobs I actually have a shot at. Since the point of LLMs is to understand semantics and language patterns, this task seems like a fit.
The scope of the project is divided into three AI agents, the last one being a total plus: profiling agent, rank & match agent and an autoapply agent. The current stack is Python, using LiteLLM for model access and Qt for a simple dashboard, and playwright for browser automation.
The profiling agent takes your resume and, optionally, your LinkedIn profile. This is because many people write on their LinkedIn past jobs, projects and activities that are not necessarily documented on their resume. It ends up with a profile of the candidate which will be evaluated by the second agent against the job posts. The agent is also required to suggest the user with possible job searches.
When we need to fetch jobs, things get interesting: there is no public API to do it. So I needed to wrestle with browser automation and heuristics to get the job posts.
Next, the agent evaluates the posts one by one, giving a score from 1 to 100 (depending on the LLM, they can be more or less creative with their scoring), based on rules that are as non-vague as possible when prompting: assess the candidate's skills, previous experience and search preferences, and give a reasoned decision on whether to skip, review or apply for the job.
My first tests conducted a few weeks ago showed just how my first impressions of needing an automation for this were right: out of 300+ found jobs, only around 25 actually were worth applying. The agent also outputs the skills gap and skills match for each job, so I can see exactly what I'm missing.
Lastly, the autoapply feature was more of an exercise to see if I could get it done and how, than something needed, but it was really fun to program: the agent takes every field of the easyapply functionality on LinkedIn and infills its field, or chooses an alternative based on a user profile with personal information (like where you live for example). It's a hybrid between browser automation and AI Agent that is very fun to look at while it infills the fields. It even writes a cover letter for me! This was the biggest challenge by far: handling what to do when the website rejects a field and finding the submit button was a nightmare.
The challenges didn't end here though: automation can be dangerous. I wanted not just to avoid spamming on the website but also give a real user feeling. So I introduced various actions, delays taken from a non-uniform distribution, pauses, and consistent browser fingerprinting.
This was my first attempt at building a workflow in this way! I'd be glad to hear what people think!

value: Show HN: An AI workflow to automate your LinkedIn job search


value: victor-craton

value: Show HN: Zero-allocation embedded security in Rust (fits in 256KB Flash)

author: victor-craton


value: theseidel

value: Show HN: F0rtune500 – No one can prove you *didn't* work at these companies

author: theseidel


value: Show HN: Designer creates first app, with Claude Code


value: Show HN: Agentathon, hackathon where AI agents compete autonomously


value: ZeidJ

value:
Team up with your agent to trade, battle, and collect every Clawemon!
This has been a fun side project for us, and we had a great time playing it with friends over the weekend.
We’ll keep adding more towns and expanding the game in our spare time. Let us know your thoughts and what you’d like to see next  - thank you!
Send your agent to clawemon.com and join the world of Clawemon!

value: Show HN: Clawemon, A Pokemon-style MMO for your agents

author: ZeidJ


value: mlapeter

value:
I originally started this so my kids could share simple games they made with AI, and wanted to broaden it to anyone (or anything) making games with AI.
I'm exploring how to make something as low friction as possible - you make your game in claude etc, tell it "help me post this to arcadelab.ai", and it should handle the rest. No logins or personal info needed. The goal is that even caleb's dog from this post can easily share his game: https://news.ycombinator.com/item?id=47139675
Open to ideas and contributions, I know there's many larger sites to share games but I think the current internet could use a few more smaller/ independent places to share things without requiring a face scan worth of personal info.
Github Repo: https://github.com/mlapeter/arcadelab

value: Show HN: Easily share games made by you/ your kids/ your dog etc.

author: mlapeter


value: Show HN: My Silly Sun Server

title: Show HN: My Silly Sun Server


value: kentf

value: Show HN: Runner – A Better Claude Cowork

author: kentf


value: iglesiasbrandon

value:
I built LennyFighter to explore how far Cloudflare's developer platform can go for real-time multiplayer. Everything runs at the edge with zero origin servers: Vinext (React SSR) + Workers + Durable Objects for match state + D1 for stats + KV for session tokens + WebSockets for real-time play.
It's a 1v1 trivia fighting game where you pick a tech industry leader as your fighter (Brian Chesky, Marty Cagan, Elena Verna, etc.) and answer trivia from their real Lenny's Podcast interviews. Correct answers deal damage scaled by type effectiveness; wrong answers cost you recoil HP.
Each match is a MatchmakingQueue DO → MatchRoom DO (one per match) with hibernatable WebSockets, 20s reconnection grace period, and an optional pre-match wager/item selection phase. Source: https://github.com/iglesiasbrandon/lennyfighter
Inspired by PokeLenny. Would love feedback on the architecture or the game or new features to add!

value: Show HN: LennyFighter: A multiplayer fighting game on Cloudflare Durable Objects

author: iglesiasbrandon


value: jmagland

value:
There are a few sites I visit very frequently and I find myself always opening a new tab. I'm used to an IDE where if you click on a file on the left it takes you to a new editor, and if the editor already exists it just takes you to that. So I thought I'd make something similar for a web browser. I admit I used AI. One hour well spent because now I don't have the too-many-tabs problem anymore.
Maybe this solution already exists? I couldn't find it.
Enjoy! And if you decide to tweak it, please submit your work back in a PR! Or of course you're welcome to fork it. Please share your improvements!

value: Show HN: Too many browser tabs! I solved it with a simple electron app

author: jmagland


value: Show HN: App Promo Video with Claude Design and Claude Code


value: asparagui

value: Show HN: Verified Deep Learning with Lean 4

author: asparagui


value: iusevim

value: Show HN: Four years of my CS degree, typeset in LaTeX (850 pages)

author: iusevim


value: shake-n-fries

value: Show HN: Handler – Open-source local sandboxes and control plane for code agents

author: shake-n-fries


value: eliadmualem

value: Show HN: LLMSecure – prompt injection detection, no signup

author: eliadmualem


value: fcpguru

value:
We started with a simple question.
Can a bot buy a DialtoneApp membership?
We looked at Stripe machine payments, Skyfire, Crossmint, Worldpay, Google Universal Commerce Protocol, MCP, A2A, and a bunch of other new agent payment ideas. There is a lot of good work happening. The whole space is moving fast, and it feels like the early web again, except now the user agent may actually be an agent. (ha!)
Trying to get bot allowed merchant account credit card processor (that's not crypto) is like the early days of accepting cards before stripe! We applied to all of them but are still waiting. But instead of just waiting we are building the Network.
Bot budget owners can register cards with us. Website owners list things that bots are allowed to buy via .well-known/* files. Bots search the DialtoneApp catalog, request purchases, and DialtoneApp charges the saved card only when the owner approved rules allow it. The exciting part is bot commerce itself. I think we are about to see a new kind of web traffic. Not just crawlers. Not just scrapers. Actual economic actors with budgets, policies, memory, and jobs to do.
Our current writeup is here:
https://dialtoneapp.com/dogfood
and our FAQ keeps growing:
https://dialtoneapp.com/faq
If anyone is interested in helping to test a bot-to-bot transaction please get in touch. Thanks!

value: Show HN: DialtoneApp Network, card payments for bot commerce

author: fcpguru


value: sanjayparekh

value:
Hey all, we're reposting from our previous Show HN about 5 years ago: https://news.ycombinator.com/item?id=28644205
Since then we've grown to more than 5k users across nearly 1k groups and have sent out more than 100k update prompts. The premise is simple - social media stinks and you either don't see updates from people you care about (they never post) or you miss the updates (flooded by other people's updates or an algorithm that downplays an update you'd care about even if it's seemingly unimportant).  And we're ramen profitable (more so now that we've migrated the majority of our infrastructure off of Amazon and especially RDS).
A few things we do - the main organizer of a group only ever has to login to create a group.  They invite everyone else via email address to which they accept the invite.  After that, they all (including the organizer) has to click the link they get regularly (weekly, bi-weekly, monthly, or quarterly) and submit a short (char limited) update.  No logging in and no bugging people to login, download an app, rate us on an app store, ads, or anything else.
The system combines the updates into a newsletter and sends it to the group.  The updates are NEVER published on the web (thus shielded from search engines and AI scraping) and you can never do a reply-all to a newsletter.  You can click on a person's name to reply back just to them and strengthen your one-to-one relationship.  You're welcome to saving you from a flood of "Congrats!" emails from everyone in the group.
We're reposting now because in the great Atlanta example of MailChimp, we're looking at stats and seeing this just grow on its own without any marketing from us.  So we've been spending more time on it to migrate the infrastructure and codebase to something more resilient and are looking to expand usage and impact.  Plus more marketing than just word of mouth.  :-)
Free for groups <10 and bi-weekly or less frequent.  Great for families, book clubs, alumni groups, companies, etc.  And before you ask, we've raised no money and have fully bootstrapped this since inception.  Criticism only helps us get better so feel free to roast us.

value: Show HN: TogetherLetters – Group newsletters with no app, no feed, no login

author: sanjayparekh


value: rileyt

value:
For almost two years, we've been developing Charlie, a coding agent that is autonomous, cloud-based, and focused primarily on TypeScript development. During that time, the explosion in growth and development of LLMs and agents has surpassed even our initially very bullish prognosis. When we started Charlie, we were one of the only teams we knew fully relying on agents to build all of our code. We all know how that has gone — the world has caught up, but working with agents hasn't been all kittens and rainbows, especially for fast moving teams.
The one thing we've noticed over the last 3 months is that the more you use agents, the more work they create. Dozens of pull requests means older code gets out of date quickly. Documentation drifts. Dependencies become stale. Developers are so focused on pushing out new code that this crucial work falls through the cracks. That's why we pivoted away from agents and invented what we think is the necessary next step for AI powered software development.
Today, we're introducing Daemons: a new product category built for teams dealing with operational drag from agent-created output. Named after the familiar background processes from Linux, Daemons are added to your codebase by adding an .md file to your repo, and run in a set-it-and-forget-it way that will make your lives easier and accelerate any project. For teams that use Claude, Codex, Cursor, Cline, or any other agent, we think you'll really enjoy what Daemons bring to the table.

value: Show HN: Daemons – we pivoted from building agents to cleaning up after them

author: rileyt


value: Show HN: Nobulex – Cryptographic receipts for AI agent actions


value:
Hey all, I am the founder of a data intelligence company, started up a year back. We started as a service company where we used to scrape data for strategy teams (any data from the web - e-comm, social media, listings etc.). So, we had to build simple custom dashboards for each team.
Every time we had to go through the same prompts on Claude/Cursor telling them how we wanted the fonts, graphs, icons to be. We built a simple system (prompt file), but still each dashboard used to look quite different.
We didn’t find any good dashboarding tool as well so we built this for our own use. It’s so cool that we also added a MCP layer on top of it, so that Claude Code uses it to build dashboards for us.
The whole dashboard is basically a YAML file. Claude generates it for us, and we can open it anytime to edit charts, filters, layout, colors, queries, or branding ourselves. It’s super simple to understand, easy to customize, and easy to reuse.
Now we have moved away from being a service company, building an Apify-like platform for our data APIs. We saw that even MBAs (our typical ICP), have started using these coding tools, hence making this open source for them to build their own custom dashboards.
I would love it if you guys gave it a try and gave your feedback. Quite a lot of things can be made better of course, will keep updating as we get more feedback from you all.
Link - https://github.com/mindcase-co/lens

value: Show HN: Built an open-source dashboarding MCP


value: ggamecrazy

value: Show HN: Image to Explorable 3D Scene

author: ggamecrazy

title: Show HN: Image to Explorable 3D Scene


value: codingblink

value: I just added some individual product pages to the site so you can link and share GPUs. I eventually want to add a comments system and a 24-hour price history graph (since some stores don't like me storing the history for more than 24 hours).<p>So far the site fetches and updates prices every 5 minutes, and organizes everything by cost. I've been developing and maintaining this for around 8 months, so I'd like to hear what other people think of the project and if there are any suggestions to improve it going forward!

value: Show HN: I'm making a GPU price tracker

author: codingblink

title: Show HN: I'm making a GPU price tracker


value: Show HN: A static website that behaves as a Linux shell


value: Show HN: Hands-on x86-64 page table walk:finding a flag in physical RAM with GDB


value: chrismaltby

value:
Hi HN, I've been working on an open-source, Electron (sorry) app for creating Game Boy games with no-code for a few years now. Recently I've been making some improvements to the inbuilt music editor/tracker and have got it running in the browser as a PWA.
https://www.gbstudio.dev/music
https://music.gbstudio.dev/
It runs entirely client-side (no backend), using the File System Access API where available, and works offline.
The file format is that same as in https://superdisk.github.io/hUGETracker/ so you can take any files made with this and edit them with hUGETracker instead.
And then you can drop these into a GB Studio project to make a quick GameBoy ROM too.
Any feedback is appreciated. Thanks!

value: Show HN: GBS Music – web based, open source Game Boy music editor/tracker

author: chrismaltby


value: Show HN: TickerDB – pre-computed market context for agents


value: oneprofiledev

value: Show HN: YouDeserveNow – An AI enabler that rationalizes your impulse buys

author: oneprofiledev


value: antoninkus

value: Show HN: Dropshot – built a browser tool for animated product shots

author: antoninkus


value: theletterf

value: Show HN: Medievalizer, an extension that rewrites pages into Old English scripts

author: theletterf


value: elvean

value:
If you don't like Claude Desktop or ChatGPT app you're not alone, here are some of the reasons why I don't like them and decided to built an alternative.
Lack of control
You can’t control the web-search (depth,  breadth and number of sources, image search,  video search providers - yeah I like to search stuff on youtube  and embed them into canvas)
you can’t control how many tokens you’re willing to burn for specific prompt, number of agentic loops, all you got is only “Extended Thinking” toggle
local MCP servers is pain to setup, Anthropic/ChatGPT pushes you to use curated Connectors or mess with local with .json configs
Privacy
there’s no opt-out for keeping your conversation history on their servers, means you’re the product. No way you will ever switch to competitor or any open-source model in their app as they try to lock you in.
Missing some native integrations
I want to use my own tools: i.e. Apple Maps, Calendar, TradingView charts integration
UX/Productivity
can’t fork conversation or start a thread for a particular response with mentioning or tagging other model.  Everything is getting bloated with 10 new features shipping every week, code, cowork, artifacts, dispatch  etc - everything crammed into single app and shoved down your throat, the feature creep is real and reminds me a time when messenger apps started to adding games directly into chat canvas.
So I spent the last ~3 months building my own AI client from scratch in SwiftUI. It works with any local model via MLX/Ollama/OpenAI-compatible API, plus cloud providers like OpenRouter.
Here's what it can do right now:
- Agentic tool calling & web search
- Interactive charts (pie, bar, line, TradingView lightweight)
- Native Apple Maps embedded in conversations
- WeatherKit cards
- Screenshot to AI feature
- Dynamic sortable tables
- Inline markdown editing of model responses
- Threaded conversations (Slack-style)
- Mentiones "@" switch models mid-conversation
- MCP server support
Built in SwiftUI, no Electron so your RAM will not blowup with useless stuff.

value: Show HN: Modern AI client for Mac with agentic tools, clean UI, builtin privacy

author: elvean


value: ronaldsvilcins

value: Show HN: Check the shutter actuations of any camera by uploading a photo

author: ronaldsvilcins


value: Show HN: Design Skills

title: Show HN: Design Skills