value: gotzonza

value:
Hi HN,
I’m full stack developer (formerly iOS) and I just launched Nomad Tracker, a native iOS app to help digital nomads track physical presence across countries for visa limits and tax residency.
Key idea: everything runs on-device.
No accounts, no cloud sync, no analytics.
Features:
- Calendar-based day tracking per country.
- Schengen 90/180 and other visa “runways”.
- Fiscal residency day counts and alerts.
- Optional background location logging (battery-efficient, never overwrites manual data).
- Photo import using metadata only (no image access).
- On-device “Fiscal Oracle” using Apple’s Foundational Models to ask questions about your own data.
I created this because other apps felt limiting and didn’t do what I needed. This app is visual, user-focused, and designed to make tracking easy and clear.
Happy to answer questions or discuss the technical tradeoffs.

value: Show HN: Nomad Tracker – a local-first iOS app to track visas and tax residency

author: gotzonza


value: porttipasi

value: Show HN: I gave 11 LLMs my trading strategy to see which one profits

author: porttipasi


value: ishyfishyy

value: Show HN: MCP server for generating Mermaid diagrams with live browser preview

author: ishyfishyy


value: michikoj

value: Show HN: Add This to Calendar – Built with Claude as a non-technical maker

author: michikoj


value:
The Setup:
I built 3 apps in 2025. Spent months on each. Made $0 total. I was about to give up on indie hacking.
The Opportunity:
Then OpenClaw (self-hosted AI assistant) went viral in January. My entire Twitter feed exploded with it. Hundreds of people trying it, struggling with setup.
I saw the pattern: massive interest + technical barrier = opportunity.
What I Built:
ClawdHost – managed hosting for OpenClaw. Think Heroku but specifically for this one AI assistant.
Lets see how this one goes!

value: Show HN: ClawdHost – Managed OpenClaw Hosting


value: Show HN: A Directory for European Tech Stack Alternatives


value: strandnerd

value:
ContextPin addresses a common pain in agent workflows: context drifts, docs go stale, and markdown ends up scattered. It’s a local-first workspace where AI assistants can read and manage real project context via MCP.
Highlights:
- Local-only storage, offline friendly
- Structured docs with folders, references, and file linking
- Warnings for broken references
- Mermaid validation feedback for agents
- Multiple tabs + version history
- Sync coming soon
Happy to answer questions and hear feedback.

value: Show HN: ContextPin – local-first context manager for AI coding workflows

author: strandnerd


value: Ecyber

value:
Hi HN,
I built PeerHelp to solve a problem I kept seeing at university. Students either rely on expensive tutors or low quality answer sites that do not help them actually understand the material.
PeerHelp connects university students directly with other verified students for concept explanations, revision support, and study guidance. It is not about writing answers for people. The focus is on understanding and learning.
Students can get help when they are stuck, and other students can earn money by sharing knowledge they already have.
I am looking for honest feedback, especially around ethics, positioning, and whether this is something you would have used as a student.

value: Show HN: PeerHelp – peer to peer study support for university students

author: Ecyber


value: stevenwinnick

value:
Hi HN,
I built BigAsk, a self-deployed web interface for exploring BigQuery data by asking questions in natural language. It’s a fairly thin wrapper over the Gemini CLI meant to address some shortcomings it has in overcoming data querying challenges organizations face.
I have a few friends who work in roles where much of their time is spent fulfilling requests to fetch data from internal databases. I’ve heard it described as a “necessary evil” of their job which isn’t very fulfilling to perform. Recently, Google has released some quite capable tools with the potential to enable those without technical experience using BigQuery to explore the data themselves, both for questions intended to return exact query results, and higher-level questions about more nebulous insights that can be gleaned from data. While these certainly wouldn’t completely eliminate the need for human experts to write some queries or validate results of important ones, it seems to me like they could significantly empower many to save time and get faster answers.
Unfortunately, there are some pretty big limitations to the current offerings from Google that prevent them from actually enabling this empowerment, and this project seeks to fix them.
One is that the best tools are available in a limited set of interfaces. Those scattered throughout the already-lacking-in-user-friendliness BigQuery UI require some foundational BigQuery and data analysis skills to use, making their barrier to entry too high for many who could benefit from them. The most advanced features are only available in the Gemini CLI, but as a CLI, using it requires using a command-line, again putting it out-of-reach for many.
The second is a lack of safe access control. There's a reason BigQuery access is typically limited to a small group. Directly authorizing access to this data via the BigQuery UI or Gemini CLI to individual users who aren't well-versed in its stewardship carries large risks of data deletion or leaks. As someone with experience working professionally with managing cloud IAM within an organization, I know that attempts to distribute permissions to individual users while maintaining a limited scope on them also requires considerable maintenance overhead and comes with it’s own set of security risks.
BigAsk enables anyone within an organization to easily and securely use the most powerful agentic data analysis tools available from Google to self-serve answers to their burning questions. It addresses the problems outlined above with a user-friendly web interface, centralized access management with a recommended permissions set, and simple, lightweight code and deployment instructions that can easily be extended or customized to deploy into the constraints of an existing Google Cloud project architecture.
Code here: https://github.com/stevenwinnick/big-ask
I’d love any feedback on the project, especially from anyone who works or has worked somewhere where this could be useful. This is also my first time sharing a project to a forum, and I’d value feedback on any ways I could better share my work as well.

value: Show HN: BigAsk - a web interface for exploring BigQuery using natural language

author: stevenwinnick


value: emx-can

value:
Hi HN,
we wanted to share our open source ONNX-to-C code generator. It translates ONNX models into C code for deployment on embedded systems. We developed it for use with emmtrix Code Vectorizer (https://www.emmtrix.com/tools/emmtrix-code-vectorizer) which optimizes the generated code for various embedded architectures. The ONNX-to-C code generator can however also be used standalone to generate plain C code. In contrast to many other tools, it makes deployment trivial since the generated code is fully standalone and no additional runtime is required.

value: Show HN: Emmtrix ONNX-to-C Code Generator for Edge AI Deployment

author: emx-can


value:
I'm spreading the word, and I find it quite useful, so I thought I'd share it with y'all
Hi HN!
Found gtime, a Python command-line utility to look up, compare, and convert time across global cities. It supports fuzzy search, favorites, meeting time conversion, and a live/watch mode — all with colorful terminal output via Rich.
Created this tool because existing CLI options felt too limited or clunky. gtime aims to make working with global times fast and pleasant, especially for remote teams or frequent schedulers.
Try it:
$ pip install gtime
GitHub: https://github.com/savitojs/gtime
Feedback, feature requests, and issues are welcome!

value: Show HN: Gtime – A colorful CLI tool to compare and convert time zones


value: Yinfan

value: Show HN: A semantic-search writing workspace so AI doesn't forget your docs

author: Yinfan


value: davidchang

value: Show HN: Get a poster of where you ran last year

author: davidchang


value: msvan

value: Show HN: Autoliner – write a bot to control a virtual airline

author: msvan


value: sujito

value: the MCP was a little bit short of features for my openclaw usage so I just open sourced a CLI oriented to Agent usage for Notion with some advanced features. hope it helps someone.

value: Show HN: A Notion CLI for Agents (OS)

author: sujito

title: Show HN: A Notion CLI for Agents (OS)


value: rohanpdofficial

value:
I built Localflare because developing with Cloudflare Workers locally felt blind – you couldn't see what was actually in your D1 databases, KV stores, or R2 buckets during development.
Just run `npx localflare` in any Workers project and get a full dashboard with:
- D1 Studio: SQL editor, inline editing, filtering, dummy data generation (Faker.js)
- KV Browser: View/edit key-value pairs
- R2 File Manager: Upload/download objects
- Queue Inspector: Send test messages
- Durable Objects: View instance state
The interesting technical bit: it uses a sidecar architecture that injects an API worker alongside yours in the same wrangler process. Both workers share the exact same binding instances – no mocks, real data. Your code stays completely untouched.
Zero config. Works with any framework (Hono, Remix, Astro, OpenNext, Nuxt). Just needs wrangler.toml.
Would love feedback, especially on what bindings or features you'd want next.

value: Show HN: Localflare – Local Dev Dashboard for Cloudflare Workers(D1, KV, R2 etc.

author: rohanpdofficial


value: lukapg

value:
Hi everyone,
I worked on several teams where we had to deal with a high intake of support requests, bug reports and feedback from users. What usually happens is that those messages come through a same form. Even if you created a form field to let the user select the type of request he's making, it still won't capture the priority and the sentiment of the user, and someone needs to manually go through submissions and assess and classify the messages.
What I've built is a form backend that acts as a request layer allowing users to classify incoming submissions by:
priority (critical, high, medium, low)
type (support, feedback, review, sales, other)
sentiment (positive, negative, neutral)
categories (matches one of users custom categories)
After the classification is done, users can define rules for how each submission is processed dynamically. For example, all critical support issues with a negative sentiment are stored and sent to a Slack channel #support. There are various action types a user can create within these rules and they can be chained.
This is not a workflow engine or Zapier. This sits before tools like Zapier, ticketing systems, or inboxes. Think of it as a smarter intake layer rather than a workflow engine. Those tools trigger after you’ve already received messy, unclear input.
Happy to receive any feedback or answer any questions!

value: Show HN: I built an automated decision layer for form requests

author: lukapg


value: lucharo

value:
Demo: https://lucharo.github.io/slidev-marimo/
Repo: https://github.com/lucharo/slidev-marimo
Slidev add-on that embeds Marimo Islands into slides. Cells are just ```marimo code fences in your Markdown. Runs fully client-side via Pyodide/WASM and also host on a static site.
Had to bridge Marimo's React components with Slidev's Vue — the add-on handles the hydration, HMR and state management between the two. Claude + Opus 4.5 helped a lot!
I also have a version on a live kernel mode that connects to a running Marimo session instead of Pyodide so you can work on a notebook and then present your results on a slide directly, it's almost there!
I'd like to think that this is going to be very useful for educators, doing demos of a package, or for ML and data science presentations where you've done some heavy work on a notebook and then you want to present to some stakeholders on some slides — the latter is the use case that I have for it.

value: Show HN: Slidev and marimo – Interactive Python in Markdown slides

author: lucharo


value: heikkitoivonen

value:
Hi HN, I built this while doing a lot of LeetCode-style Python problems.
I ran into a case where I used a Python stdlib class but couldn’t confidently state its time or space complexity. The official docs didn’t mention it. When I asked in Python discussion forums whether complexity should be documented, the response was mixed.
I originally assumed a comprehensive reference would take too much manual effort, but realized that coding agents could help bootstrap it by extracting and summarizing information from the documentation and CPython source code.
To reduce errors, I had multiple agents (using different models) independently check the same sections and compare their results. The project is open source, so the idea is that remaining inaccuracies can be corrected over time.
I’d appreciate feedback on missing cases, incorrect assumptions, or whether this is useful in real Python work.
https://pythoncomplexity.com/

value: Show HN: A Python time and space complexity reference

author: heikkitoivonen


value: jscheel

value:
Hey everyone, I’m the head of engineering at GrooveHQ. We’ve spent the last 10+ years building customer support tools, and today we’re launching Helply. Helply is an AI customer support agent that we are so confident in, we’ve backed it up with a guaranteed resolution rate.
AI support agents live and die by the data they have access to and the way they finesse the customer experience. Basic automations worked well in the past, but now people expect more.
Here are some semi-technical notes:
---
1) Controlled data syncing
---
We wanted tight integrations with existing helpdesks, but also needed to give users flexibility over what the agent actually knows. Building integrations that sync data while still being tweakable turned out to be harder than expected.
People want one source of truth, right up until they need an exception. We built a sync policy system that lets us manage sync and overwrite behaviors for external data.
The data itself is synced via Airbyte’s pyairbyte package. I ended up working with the pyairbyte team on some performance issues around memory leaks with certain types of pagination on large datasets.
---
2) Retrieval, escalation, and conversation behavior
---
Users hate when they have to fight with an AI agent, especially when they know that the AI agent can’t help. We wanted our AI agent to search well, but also know when it was time to gracefully bow out.
At first it was too eager to give up. We didn’t want hallucinations, so it would just fail with “I don’t know.” The experience sucked.
We found our retrieval pipeline was subpar. We built evals and found some quick wins, but the agent was still too eager to escalate. We considered fine-tuning, but first built more evals. In the end, better retrieval, tools, and prompts were enough.
We also added an action engine that lets users define custom actions. It uses a two-tiered approach: a pre-qualifying model decides whether an action is appropriate, and only then are tools invoked. Too many tools up front made the agent worse, so this tiered staging helped a lot.
---
3) Analysis of historical ticket data
---
We built a pipeline that analyzes historical ticket data, creates derivatives, and evaluates the agent’s performance against them. It then finds gaps in your agent’s knowledge that you can fill with AI-generated answers from ticket history. Doing this safely, reliably, and at scale has been a challenge.
We use Dagster to run these jobs, but are looking at moving everything to DBOS (which we use in other products and love). Ticket ingestion relies on Airbyte connectors running via pyairbyte. Some integrations use Airbyte’s connectors, others are our own built on their declarative schema.
We use JinaAI for embeddings, reduce dimensionality with UMAP, and currently cluster in-memory with FAISS (though we plan to move away from FAISS). The pipeline runs a small optimization step to tune UMAP and clustering parameters.
This system is powerful but still a wip. We’ve got a new version coming, but it isn’t quite ready for primetime yet.
---
4) Taste vs evals
---
You hear a lot about taste in AI. We believe taste is incredibly important. Evals helped us catch obvious failures, but nothing can replace taste.
We worked closely with our pre-release customers to develop it. We have so, so  many external VIP Slack channels open. I’m really thankful for their input.
---
5) Compliance
---
Compliance is the C-word for small tech companies, and we jumped straight into SOC2 Type II. Because we’re a multi-product company, scoping everything appropriately was tricky.
We’re using Vanta to manage most of this, but there’s still a lot of manual grunt work that isn’t automated. I know several folks are trying to simplify this for startups… good luck to them.
---
I’m really proud of what our team has accomplished, and I’m excited to share it. Happy to answer any questions, technical or otherwise. You can sign up and try it directly on the site.

value: Show HN: Helply – AI support agents with guaranteed results

author: jscheel


value: nseara

value:
Get recommended by AI.
Get more customers.
ChatGPT, Perplexity, and Google AI send the highest-converting traffic on the web.
Audit your visibility, generate AI-ready content, and track every citation.

value: Show HN: Prominara – The SEO tool for the AI search era

author: nseara


value: Mrakermo

value:
not sure if anyone else feels this, but calendly links startes breaking my days.
I absolute hate sitting and dealing various dates suggestions, and calendly solved that.
But now I get 7 different meetings per day, and constant context switching.
Important meetings land between semi important. Team meetings get scattered. My calendar stopped reflecting what actually mattered.
So we built something simple:
It’s still a meeting link, but the guest shortly explains what the meeting is about, and an AI suggests the best time based on my priorities, focus, and team context.
If both people use it, the agents just coordinate and pick the best time automatically.
Sounds small, but already better than a static meeting link.
Curious if others here feel the same pain or if I’m just bad at calendars
Link if anyone wants to try it, you can't pay for it yet so free of charge.

value: Show HN: No more static meeting links

author: Mrakermo

title: Show HN: No more static meeting links


value: SvaleDrea

value:
Hi HN,
I built MyNextCamp (https://mynextcamp.io) to solve a problem I had as a beach volleyball player: finding camps meant visiting 20+ organizer websites, comparing dates/prices manually, and missing early-bird deals.
MyNextCamp aggregates 537+ camp sessions from organizers worldwide, updates daily, and lets you:
  - Compare camps side-by-side with filters (location, dates, skill level, price)
  - Get alerts when spots open or prices drop
  - Share selections with friends to plan group trips
  - View everything on a timeline
Tech stack: Next.js 15, Supabase, Fly.io. Built scrapers to pull data daily from official sources. No ads, free to use.
This is a side project (solo founder) serving a niche community. Looking for feedback on:
  1. UX/filtering - is it intuitive?
  2. What features would make this more useful?
  3. How to reach more players without a marketing budget?
Try it out (no signup required to browse): https://mynextcamp.io

value: Show HN: MyNextCamp – Search 500 beach volleyball camps in one place

author: SvaleDrea


value: backbay-machine

value:
Hi HN.
OpenClaw has been popping claw for weeks now…
We’ve seen the same question come up again and again:
“This is fun but how do we no get fuk?”
My answer: Clawdstrike.
It’s an open-source toolbox for developers who want to ship EDR-style apps and security infrastructure to the OpenClaw ecosystem.
Disclaimer: this is an unpublished alpha (APIs will change). Beta is planned within ~7 days (aiming for Feb 10, 2026). Not audited—please treat as experimental.
Here’s my take: the first wave of “make autonomous agents safe where users are literally yoloing their entire system without even watching” is actually pretty simple.
Security needs to live at the boundary between an agent’s intent and action — the moment it tries to read/write files, patch code, call tools, or reach the network.
Not just “visibility.” Not just logs. But enforcement + proof.
What Clawdstrike gives you:
- Fail-closed guards at the agent/tool boundary
- Block sensitive paths, control network egress, detect secrets, validate patches, restrict tools, catch jailbreaks
- A policy engine (YAML rulesets) so teams can start safe and tighten over time
- Receipts + signatures (Ed25519) so wtf the agent actually did is verifiable — not a story in your log pipeline
- An OpenClaw plugin so this drops into existing stacks with minimal friction
Everyone knows this turns into a forever cat-and-mouse game between model providers, agent frameworks, sandbox/runtime developers, and the adversaries. That’s the world we’re in. (boo. fuck you, bad guys.)
My hope is Clawdstrike becomes a useful foundation for people in the ecosystem: a place where developers and security people can encode + share proving strategies (guards, policies, verification patterns) instead of each team re-learning the same lessons in private.
Threat model (explicit, so nobody gets misled):
Clawdstrike enforces policy at the agent/tool boundary. It is *NOT* an OS sandbox and does *NOT* intercept syscalls. If an agent can bypass the tool layer and touch the filesystem/network directly, gg, Clawdstrike can’t stop it. The intended setup is: pair this with OS/container sandboxing when you need syscall-level isolation (seccomp/gVisor/Firecracker/etc).
Why I’m posting:
I want to do whatever I can to help build out the shared safety layer for the OpenClaw ecosystem. If this looks useful to you: clawdstrike is something you can adopt early and extend, help us help you build serious security/EDR-grade infrastructure on top of it.
Feedback I’d love:
- Which single failure mode scares you most with OpenClaw today?
  - (exfiltration, destructive writes, supply-chain via patches, prompt/tool injection, credential leakage, lateral movement, etc.)
- If this becomes a shared safety layer, what needs to be stable?
  - Unfortunately for you all I’ve never built a widely adopted open source security sdk, so really just looking for feedback on release cadence and stability from those who would plan on using something like this.
Policy schema? guard API? receipt format? verification tooling? (Which thing must not break?)
- What would make you trust it?
  - Formal threat model, fuzzing, reproducible builds, third-party audits, or just battle-testing? Do you want receipts to be human-legible or machine-verifiable first?
(And if machine-first: what format would you want. JSON/JCS, CBOR, Merkle proofs, etc.)
- How should policy be expressed?
  - Classic question…. So.. YAML? hybrid?
- What other integrations would you like to see next?
Repo/docs: https://github.com/backbay-labs/clawdstrike
If you’re building with OpenClaw and security is on your mind, I’d love to collaborate and make this genuinely useful.

value: Show HN: Clawdstrike – a security toolbox for the OpenClaw ecosystem

author: backbay-machine


value: beeeenorm

value:
A landing page for an AI agent platform written entirely in TikTok-speak with 90s web design. Agents include "DoorDash Daddy" and "Hinge Whisperer."
The actual point: current agent tooling is built for developers. We're building agent infrastructure for people who think "debugging" is removing bugs from their apartment.
https://openwhiteclaw.com

value: Show HN: Openwhiteclaw AI agents for people who think GitHub is a fitness app

author: beeeenorm


value: daibhin

value: Show HN: Our AI agent 'Collison Installs' your SDK in customers codebases [video]

author: daibhin


value: championswimmer

value:
Thanks to Opus/5.2/3Pro (I used all in various capacities) I was able to make a version of Mini Metro with some of my own quirks. I wanted residential/office space densities, so station placement is strategic. I also wanted a real economic engine like Transport Fever/City Skylines type games, so it costs actual money to build stations/lines and keep operating them, and you make revenue from metro tickets.
Feel free to suggest ideas to add to increase the game dynamics and complexity, I am all ears! This is the first time I have tried my hand at making a game. It is open source and you see the source code on https://github.com/championswimmer/metromap.io

value: Show HN: A mini-metro inspired game involving dollar-based economics too

author: championswimmer


value: Martinmm

value:
Hi everyone
I’m Martin, founder of Ozor.ai.
Ozor turns a single text prompt into a short, launch-ready video—automatically handling scenes, pacing, typography, transitions, and branding. The goal is to make product demos, feature launches, and announcements fast enough that teams actually ship videos instead of postponing them.
What it does
Prompt → storyboard → video (end-to-end)
Designed for short product, SaaS, and announcement videos
Clean, modern motion defaults (customizable)
Export formats ready for X, Instagram, YouTube, etc.
Why we built it
Video has become essential for launches, but tools are either too complex or too manual. We wanted something closer to “write a good sentence, get a good video.”
Who it’s for
Founders, indie hackers, marketers, and product teams who want quick, repeatable videos without editing timelines.
We’re early and actively iterating. Feedback—especially critical feedback—is very welcome.

value: Show HN: Ozor.ai – Create launch-ready videos from a single prompt

author: Martinmm


value: sokratisv

value:
Hi HN,
We’re the team at Feather Labs, and we built Feather (https://askfeather.ai), an AI tax assistant designed to assist how professionals handle modern Tax research.
General LLMs are a liability for tax work because they lack a hierarchical understanding of the law. They often conflate IRC Title 26 with non-authoritative blog posts or outdated Treasury Regulations. We built Feather to move past "plausible" prose toward audit-defensible reasoning.
The Technical Challenge: Standard RAG often chokes on the tax code for a few specific reasons:
1. Hierarchical Fragmentation: Simple character-count chunking breaks the logical nesting of tax law; we implemented a strategy to preserve the relationship between code sections, sub-clauses, and court cases.
2. Temporal Decay: A vector search might pull a 2021 Revenue Ruling that was superseded in 2024; our indexing prioritizes versioning and the latest IRS guidance.
3. Contextual Overlap: The tax code is highly repetitive. We use multi-jurisdictional analysis to distinguish between federal and state-level nuances that appear semantically similar but are legally distinct.
The Build:
1. Audit-Ready Citations: Every answer is grounded in primary sources—IRC Title 26, Treasury Regs, and IRS guidance, providing verified references you can actually defend.
2. Context-Aware Intelligence: Beyond answering queries, the system flags related risks, exceptions, and filing deadlines that practitioners might overlook.
3. Compliance: We are SOC 2 compliant with a strict zero-training policy on sensitive client data.
We’re curious to hear from anyone else building RAG for "dense" domains where "close enough" results are not enough. We'll be in the comments to talk about our indexing strategy and how we handle complex document extraction.
Sokratis

value: Show HN: Askfeather.ai – Professional Class AI Tax Assistant

author: sokratisv


value: gucduck

value:
Civie is built around a simple bet: that making civic questions anonymous, quick, and recurring lowers the barrier to participation, even if the resulting data isn’t perfectly representative.
Each day, you answer 1–3 short civic questions. It takes under a minute. Responses are anonymous, and results are shown only in aggregate. Over time, those aggregates stick around and remain open for anyone to explore or analyze.
This is not scientific polling. Samples are self-selected, nuance gets flattened, and the results shouldn’t be treated as population-level truth. That’s an intentional trade. The goal isn’t methodological purity, but making participation easy and safe enough that more people are willing to show up at all.
What I’m trying to test: 1) Does anonymity actually lower friction for people who otherwise wouldn’t participate? 2) Does reducing effort change who participates, not just how often? 3) Can imperfect but longitudinal data still function as signals when viewed over time or alongside other datasets?
If this works, the aspiration is twofold. Primary: Reduce the psychological and practical cost of civic participation to near zero. Secondary: Build an open, cumulative dataset that researchers, journalists, educators, or other builders can apply data science to, with clear caveats about what it is and isn’t.
There’s intentionally no debate, feeds, or identity performance. The product is opinion capture and aggregation, not discourse (the internet has plenty of that already).
I’m early and actively looking for beta users who are willing to try it out and help poke holes in it, especially around anonymity, abuse vectors, data quality, and interpretation.
Blunt feedback welcome. Gentle feedback also accepted.

value: Show HN: Civie. Anonymous daily civic questions.

author: gucduck


value: Show HN: A Claude Code session viewer that actually shows useful info


value:
Repo link: https://github.com/poweroutlet2/openground
tldr: openground is a tool that lets you give controlled access to documentation to AI agents. Everything happens on-device. Think of it as a local alternative to Context7.
I've been working on openground, an opensource and completely on-device tool that let's you give controlled documentation access to your coding agents. Solutions like Context7 provide a source of truth for docs, but their closed-source data ingestion and querying pose security/privacy risks. openground aims to give users full control over what content is available to their agents and how it is ingested. Find your library's documentation source (git repo, sitemap, or local), add it to openground via the CLI, and openground will use a local embedding model and vector db (lancedb) to store your docs. You can then use the CLI to install the MCP server to your agent to allow the agent to query the docs via hybrid BM25 full-text and vector search.
Using fastapi docs as an example, it's as simple as:
uv tool install openground
openground add fastapi --source https://github.com/tiangolo/fastapi.git --docs-path docs/
openground install-mcp --opencode # or --claude-code or --cursor
And the agent will have access to locally query the fastapi docs when needed.
Features that I've implemented so far:
- docs indexing from git repo, sitemap.xml, or local directories
- index specific docs for specific library versions for git sources
- efficient updating of existing docs so your machine is not embedding the same content every time you update
This is still an early version, so expect breaking changes. Upcoming features I am working on:
- daemon style command that updates docs on a schedule
- project specific access control from the MCP server
- docs "registry" to allow pushing and pulling of documentation embeddings to and from S3
- lighter-weight package
- better docs
Suggestions and PRs welcome! I'll also be around for any discussion.

value: Show HN: Openground – open-source, on-device documentation indexing for agents


value: darlontrofy

value:
Hi HN,
OpsBrief is out fof beta and live today!  It consolidates incidents, alerts, and key events from Slack, GitHub, PagerDuty, Teams, Discord, Datadog, and more coming soon into one daily digest and searchable timeline for faster incident response and short MTTR.
The problem we solved: During incidents and daily ops, engineers waste time gathering context from 6+ tools. Check PagerDuty for alerts. Scroll Slack for discussions. Check GitHub for deployments. Check Datadog for metrics. Teams or Discord for chat. By the time you have the full picture, critical time has passed, business is hurting, and customers are really upset.
Our approach: OpsBrief automatically extracts releases, deployments, incidents, and alerts from your entire ops stack and shows them in one place: a daily email digest
and searchable timeline/calendar view. See what shipped, what broke, what's in progress - all in one place.
Real results from beta: Teams spend 70% less time gathering context during incidents. On-call engineers reduce status meeting time by 50%. Full visibility across engineering, product, marketing, and ops teams.
How it works: One-click OAuth integration with your existing tools. Real-time updates from Slack, PagerDuty,GitHub, Datadog, Teams. Events summarized and
displayed in daily digest email. Analytics with auto timeline of events. Full timeline/calendar view for searching past events.
Works with: Slack, GitHub, PagerDuty, Teams, Discord, Datadog, Sentry, and more coming soon.

value: Show HN: OpsBrief – Stop wasting 30 minutes per incident gathering context

author: darlontrofy


value: firtaet

value: Show HN: Product Hunt for Roblox

author: firtaet

title: Show HN: Product Hunt for Roblox


value: benjaminfh

value:
Hi HN — I built threds.dev (aka ResearchTree): git-style branching/merging for human-led LLM research chats.
I use LLMs a lot for research and idea iteration where I want to remain in the loop to learn/absorb. Linear chats felt wrong for how I think: I want to build strong context, spin off side questions (“side quests”), then merge useful results back into the main line without polluting it.
Concretely: each workspace is a versioned reasoning tree with explicit branch/merge semantics.
Highlights
- Branch from an assistant reply (entire reply or a highlighted section; can run in the background)
- Edit an earlier user message and continue exploring on a new branch
- Merge useful results back into another branch
- Live graph view of the reasoning DAG to jump between nodes
- Per-branch model/provider settings (incl. “thinking” content where available)
- Quote replies for quick line-by-line markup
- Share workspaces with other users by email
- Postgres backend (Supabase or local adapter); an older local git backend is mostly deprecated now
- Electron desktop shell for local workflows
- Code: https://github.com/benjaminfh/researchtree
Note: the hosted app currently requires signup (workspaces are persisted + shareable). If you prefer not to create an account, the repo supports running locally (including an Electron build: npm run desktop:package with a local Postgres instance which is quick to spin up using, e.g., https://postgresapp.com/).
Feedback I’m hoping for: does branch/merge for context match how you actually work with LLMs? Where does the branching/merging UX feel awkward?
This started as an experiment in two parts:
- are trees the right data structure for context for humans? For agents? (See also: Pi, which is awesome!)
- how far I could get with a PRD (PM_DOCS/ARCHIVE/PRD.md if you're curious) + Codex doing all of the code and me reviewing and thinking about architecture only. Answer: very far.

value: Show HN: Threds.dev – Git-style branching/merging for LLM research chats

author: benjaminfh


value: arsalanb

value: Show HN: I built a baby Palantir to track everything from markets to planes

author: arsalanb


value:
I wrote a blog post about it here: https://blog.carter2099.com/posts/4
tldr: There was no ruby sdk for the HL api so I made one. This was my introduction to Claude Code and it was awesome. I was able to code with an LLM, stay in the terminal, and still learn something new (WebSockets). I also forked an existing ruby web sockets client gem and made it my own! Up next I'll use this SDK to create an automated short rebalancer for my concentrated liquidity pool positions.

value: Show HN: Hyperliquid Ruby SDK

title: Show HN: Hyperliquid Ruby SDK


value: luckybear

value: Show HN: OpenSem – AI-native configuration system for Claude Code

author: luckybear


value: alexneamtu

value: Show HN: SendRec – Open-source, EU-hosted alternative to Loom

author: alexneamtu


value: Wuzzy

value:
Hi HN,
At Imbue, we’ve been following the rapid developments in the agent landscape and noticed that the way agents interact with third-party services on users’ behalf often leaves a lot to be desired. Integrations are ad hoc, complicated, context-heavy, and either unfriendly to non-technical users or tied to a lock-in of some sort.
We‘re experimenting with a command-line tool, Latchkey, that could be used by local agents targeted at non-technical users while avoiding remote intermediaries. As far as we know, this is the only existing approach at the intersection of these two goals.
Core idea: Agents access APIs of third-party services by prepending ordinary `curl` calls with the `latchkey` command, like this:

    latchkey curl -X POST 'https://slack.com/api/conversations.create' \
      -H 'Content-Type: application/json' \
      -d '{"name":"something-urgent"}'

Latchkey then transparently injects credentials into these calls, prompting the user to log in via a browser pop-up when needed. Browser automation is used to extract an API token from the browser session once logged in.
Benefits:
* A single skill to integrate with all services.
* Direct communication between the agent and the third-party service (no OAuth intermediary app needed).
* Agents usable by non-technical users.
* Secrets do not leak to logs or chat transcripts.
We believe this aligns with a vision of a decentralized future in which people don’t need to ask corporations for permission to use their own data. We imagine a lively ecosystem of local agents that people use freely, supported by a community helping each other keep these tools useful and functional.
We’re aware that this approach comes with some downsides, too, and would love your feedback.
P.S. Here’s also a link to Passepartout, a toy demo AI assistant app built using Latchkey: https://github.com/imbue-ai/passepartout

value: Show HN: Latchkey – inject credentials into agents' curl calls

author: Wuzzy


value: rksart

value:
Hi HN,
We've spent the last year building AI agents and kept hitting the same wall: prompt engineering doesn't feel like software engineering. It feels like guessing.
We built OpenSymbolicAI to turn agent development into actual programming. It is an open-source framework (MIT) that lets you build agents using typed primitives, explicit decompositions, and unit tests.
THE MAIN PROBLEM: CONTEXT WINDOW ABUSE
Most agent frameworks (like ReAct) force you to dump tool outputs back into the LLM's context window to decide the next step.
Agent searches DB.
Agent gets back 50kb of JSON.
You paste that 50kb back into the prompt just to ask "What do I do next?"
This is slow, expensive, and confuses the model.
THE SOLUTION: DATA AS VARIABLES
In OpenSymbolicAI, the LLM generates a plan (code) that manipulates variables. The actual heavy data (search results, PDF contents, API payloads) is stored in the Python/runtime variables and is never passed through the LLM context until a specific primitive actually needs to read it.
Think of it as pass-by-reference for Agents. The LLM manipulates variable handles (docs), while the Python runtime stores the actual data.
EXAMPLE: A RAG AGENT
Instead of the LLM hallucinating a plan based on a wall of text, it simply writes the logic to manipulate the data containers.
class ResearchAgent(PlanExecute):

  @primitive
  def retrieve_documents(self, query: str) -> list[Document]:
      """Fetches heavy documents from vector DB."""
      # Returns heavy objects that stay in Python memory
      return vector_store.search(query)

  @primitive
  def synthesize_answer(self, docs: list[Document]) -> str:
      """Consumes documents to generate an answer."""
      # This is the ONLY step that actually reads the document text
      context = "\n".join([d.text for d in docs])
      return llm.generate(context)

  @decomposition(intent="Research quantum computing")
  def _example_flow(self):
      # The LLM generates this execution plan.
      # Crucially: The LLM manages the 'docs' variable symbol,
      # but never sees the massive payload inside it during planning.
      docs = self.retrieve_documents("current state of quantum computing")
      return self.synthesize_answer(docs)

agent = ResearchAgent() agent.run("Research the latest in solid state batteries")
DISCUSSION
We'd love to hear from the community about:
Where have you struggled with prompt engineering brittleness?
What would convince you to try treating prompts as code?
Are there other domains where this approach would shine?
What's missing to make this production-ready for your use case?
The code is intentionally simple Python, no magic, no framework lock-in. If the approach resonates, it's easy to adapt to your specific needs or integrate with existing codebases.
Repos:
Core (Python): https://github.com/OpenSymbolicAI/core-py
Docs: https://www.opensymbolic.ai/
Blog (Technical deep dives): https://www.opensymbolic.ai/blog

value: Show HN: OpenSymbolicAI – Agents with typed variables, not just context stuffing

author: rksart


value: blackknightdev

value:
Hi HN, I built Muninn because I was tired of dumping entire directories into LLM contexts just to keep my agent updated.
Most memory layers use complex vector DBs. Muninn uses a simple, transparent approach: it indexes your project into local Markdown files and surgically injects only the top-relevant facts using the CXP (Context Exchange Protocol) powered by Rust.
Local-first: Everything stays in ~/.muninn.
Universal: Works across different agents (Claude, Cursor, etc.).
Token-efficient: Reduces context overhead by up to 95%.
Would love to hear your thoughts on the local-first context approach!
Check out my website and get immediately started :www.muninn.space

value: Show HN: Muninn – A universal local-first memory layer for AI agents

author: blackknightdev


value: sourishkrout

value: Show HN: Claude.md is doing too much

author: sourishkrout

title: Show HN: Claude.md is doing too much


value: anticlickwise

value:
Hi HN, I’m a solo maker and I built a very small tool after noticing a recurring problem in my meetings.
I used to ask open questions like:
“How are we feeling about this?”
“Any concerns?”
“Thoughts?”
The pattern was always the same: a few people spoke, some nodded, many stayed silent.
In the moment, it felt aligned. Weeks later, execution slowed and people realized they’d understood the decision differently. I experimented with a constraint instead of more discussion. At the end of a meeting, everyone answers with one word. No explanations. No defending. No context.
What surprised me was that removing explanations surfaced patterns: clusters of hesitation, quiet tension or alignment, without putting anyone on the spot. Room Read is a simple implementation of that idea. It’s intentionally minimal and fast, meant to reveal signals before teams move on.
Built solo, feedback welcome.
https://www.cognu.app/room-read

value: Show HN: A one word check to detect misalignment in meetings

author: anticlickwise


value: onounoko

value:
I made this tool to make it easier to explore topics using AI. LLM chats are nice but they don't really connect ideas and become less useful the longer your chats are.  MindBloom essentially allows for non-linear conversations and creates a web of connected ideas that you can explore in an infinite canvas. It also creates exploration suggestions for you so you can dive into topics in ways you might not have thought of yourself.
Here's a tree I made exploring the "cause of the fall of the roman empire" https://www.mindbloom.so/share/_iRWRv5IalGVQQWVJMdr-

value: Show HN: Research tool that turns one question into a branching discovery tree

author: onounoko


value:
I built a hands-free HUD for smart glasses that runs a real-world speedrun timer and auto-splits based on what the camera sees. Demo scenario: making sushi.
Demo: https://www.youtube.com/watch?v=NuOVlyr-e1w
Repo: https://github.com/RealComputer/GlassKit
I initially tried a multimodal LLM for scene understanding, but the latency and consistency were not good enough for this use case, so I switched to a small object detection model (fine-tuned RF-DETR). It just runs an inference loop on the camera feed. This also makes on-device/offline use feasible (today it still runs via a local server).

value: Show HN: Real-world speedrun timer that auto-ticks via vision on smart glasses


value: niyikiza

value:
I've been working on a different authorization model for AI agents, motivated by a simple problem: once agents start delegating work to other agents, identity-based permissions and prompt guardrails break down fast.
Tenuo makes authority task-scoped. A manager agent starts with a signed capability ("warrant") and can delegate to workers, but delegation can only attenuate. Each step gets narrower authority, and it disappears when the task ends.
Even if an agent is prompt-injected, it can't take actions outside its warrant. Every tool call requires proof-of-possession, and arguments are validated against explicit constraints before execution.
This is inspired by systems like Macaroons / Biscuit / UCAN, but adapted for AI agents processing untrusted input:
- signed, ephemeral capability tokens
- mandatory proof-of-possession
- constraint checking on tool arguments
- fail-closed by default (no warrant = no action)
Implementation details:
- Rust core, Python SDK
- ~27μs verification per call, offline
- integrations for LangGraph, OpenAI SDK, MCP, A2A, etc.
Repo: https://github.com/tenuo-ai/tenuo
Launch post (2025): https://niyikiza.com/posts/tenuo-launch/
Happy to answer questions or hear where this breaks down.

value: Show HN: Tenuo – Capability-Based Authorization (Macaroons for AI Agents)

author: niyikiza


value: geyuxu

value: Show HN: Reimplementing PyTorch from scratch (MLP, CNN) to learn the internals

author: geyuxu


value: chadwebscraper

value:
I recently built https://meter.sh to track any site - whether through an API or just raw HTML.
The tool auto-inspects any API, catches any preliminary requests, and extracts all data (including pagination). It falls back to HTML if needed.
I had a blast building this and we have a growing number of customers using this tons of different use cases.
There's a generous free tier - would love to hear any feedback.

value: Show HN: Scrape (auto-discover APIs or HTML) & Monitor changes on any site

author: chadwebscraper


value:
Hi HN - we're Jackie and Kabir, building Corvus Robotics. Here's a video about 8 years of building robots in 1 minute: https://x.com/JackAndTheBots/status/2018746764954878107
Every physical thing you own sat in a warehouse at some point, and every warehouse has to do inventory checks. It's a boring job where big companies staff full-time people going up 30 ft using lift trucks all day to just... scan stuff with a barcode scanner, and write things down with paper and pen if inventory is in the wrong place or missing.
We spent the last 8 years building flying robots to automate this faster and cheaper.
Our drones fly week after week without human involvement (no teleop either!). They work in extremely self-similar, often feature-poor, GPS-denied environments. Our autonomy engine is vision-based and ML-first, mapping pixels to trajectories within a ~60W compute power budget, running our autonomy software fully onboard and in real-time. This enables accurate inventory capture and safe flight around people, other robots, and material handling equipment. We build all of our drones in-house in the Bay Area.
There are limits to what the drones can do based on what they can see. For example, they can’t see multiple pallets deep, or open a box to count screws. That said, most large companies that make and handle physical goods store inventory in ways we can help with.
Along the way, we've learned that the core sensing and compute stack we've built is great for data capture at scale for many robots in industrial settings. We hope to share more about this soon!
We’re sticking around all day to answer questions here, so feel free to ask whatever questions come to mind!

value: Show HN: Corvus Robotics (YC S18) Inventory drones with full life-cycle autonomy


value: Show HN: ACF – Local AI code generation pipeline with marketplace extensions


value: regrun

value:
I got tired of "Security Prompts" being the only thing stopping AI agents from blowing up production.
Hi HN,
I’ve spent the last few months looking at how we deploy autonomous agents. The current standard is basically: "Put it in a system prompt and hope the LLM doesn't hallucinate a $50k refund."
As someone who has managed organizational authority for a decade (People Ops), this felt like a massive liability gap. Prompt engineering is probabilistic; security needs to be deterministic.
I built Reg.run to move the "Stop Button" out of the prompt and into the execution layer.
How it works technically:
The Sidecar: We use a local WASM-based proxy that sits next to the agent.
The Protocol: It intercepts Model Context Protocol (MCP) or standard API calls in real-time.
Policy-as-Code: Every action is checked against a rigid schema (e.g., MaxSpend: 100) before it’s signed and sent.
Performance: Sub-1ms latency. No data leaves your VPC.
It’s early, but the goal is to provide a physical "human-on-the-loop" gate mandated by the EU AI Act (Article 14) without breaking the autonomy of the agent.
I’m a solo founder and I’m around to answer any questions about the WASM implementation or the permission logic. I'd love your feedback on this.

value: Show HN: Reg.run - Decoupling AI "thinking" from API execution

author: regrun


value: ascinfo

value:
Hi HN,
I built DevSweep because I was tired of manually hunting down abandoned node_modules, dangling Docker images, and massive Gradle/Maven caches to free up space on my Mac.
I looked at existing "system cleaners," but they are often too generic (clearing browser caches) or too opaque. On the other hand, finding random rm -rf snippets online felt risky for a production machine.
DevSweep is designed to be:
Safe: It features a comprehensive test suite (100+ tests/assertions). It validates targets before deleting.
Specific: It only targets developer artifacts (Docker, Gradle, Maven, NuGet, Node.js, old JetBrains logs).
Auditable: Currently written in pure Bash so you can see exactly what it does.
Roadmap: I'm currently planning a rewrite in .NET 10 / Native AOT to ship a standalone binary with a proper TUI (using Spectre.Console), but the current Bash version is stable and usable.
I'd love your feedback on the safety checks or suggestions for other dev tools/stacks to add.

value: Show HN: DevSweep – A TDD-backed CLI to clean artifacts safely

author: ascinfo


value: nvader

value: Show HN: A skill for agents to work with the JJ VCS

author: nvader


value: chaitanyya

value: It's about time people started taking security seriously for their vibe-coded apps, it's been a complete joke so far!

value: Show HN: Security platform for vibe coded apps

author: chaitanyya


value: surrTurr

value: Show HN: Dynamic Markdown Flashcards without database (Obsidian)

author: surrTurr


value: manumasson

value:
Hello HN! I have been building this for the past year and I'm excited to share it here because I think it's the sort of thing this community will be very interested in.
I see the future of work as orchestrating teams of AI agents. But currently even managing a handful of agents is chaos. The IDE needs to evolve to be agent native, designed from the ground up for agentic engineering and context rather than another VS code fork. I'm building Voicetree towards that vision.
A rather insane vision of engineering where you architect projects from hundreds of agent sessions whose outputs are all saved, connected together, and turned into a Markdown mindmap. Then you spatially navigate the graph, hand-holding agents as they recursively fork themselves.
This tool is now where the majority of my code gets written, and I'm looking for feedback on how this can become something you would want to use as well

value: Show HN: Obsidian meets Claude Code. A Markdown graph for agents and context

author: manumasson


value: dvolkhonskiy

value: Show HN: I Made Claude Code for Calories Tracking

author: dvolkhonskiy


value: melenaboija

value: Show HN: Run QuantLib pricing in parallel via gRPC and FlatBuffers

author: melenaboija


value: digitcatphd

value:
TL;DR: Built an API-first marketplace for AI agent tools. 126 tools, 65 skills, 46 solutions. Agents register via API, browse via CLI, review via API. No web forms. Built for agents, by agents.
What is it?
ClawsMarket is a marketplace for AI agents to discover, review, and share tools. It's command-line first, API-only registration, and designed specifically for autonomous agents rather than human users.
Live: https://www.clawsmarket.com
How it works
Registration (for agents):
  bash
curl -X POST https://www.clawsmarket.com/api/agents/register \
  -H "Content-Type: application/json" \
  -d '{"name": "MyAgent", "email": "agent@example.com", "description": "What I do"}'
Returns API key instantly. Auto-verified. No email confirmation. No CAPTCHA. Just API.
What you get:
•    126+ tools rated by agents
•    65+ skills (Claude Code, MCP servers, DevOps)
•    46+ solutions (full agent setups)
•    Install commands:   npx clawhub@latest install
Why build this?
I got tired of digging through GitHub READMEs to find tools that actually work with AI agents. Most "AI tool directories" are SEO listicles for humans, VC-funded Product Hunt clones, or full of dead tools.
Wanted something API-first, reviewed by agents, focused on utility.
Stack: Next.js 14, TypeScript, static files, semantic search
AMA. Built this because I needed it.

value: Show HN: ClawsMarket – Marketplace where AI agents discover tools

author: digitcatphd


value: i-wan

value:
I’ve been using Notion for sharing documentation and client portals, but I found the lack of engagement metrics frustrating. While some widgets offer simple view counters, they don’t tell me if a user actually read the content or bounced immediately.
I built NotionPulse to track actual time-on-page. It works via a minimalist embed that doesn't distract from the Notion aesthetic.
Key technical bits:

    Tracks active tab engagement to ensure the "time spent" is accurate.

    Minimalist dashboard built with Next.js and Vercel.

    Working on a sync feature to push these metrics back into Notion DB properties via their API.

I’m a solo maker and I’d love to get some technical feedback on the tracking accuracy and the dashboard's utility.
Is "time-on-page" a metric you care about for internal docs or public templates?
Site: https://www.notionpulse.cc/

value: Show HN: NotionPulse – Track time-on-page for your Notion pages

author: i-wan


value:
https://chengai.me
The problem: Hiring new grads is broken. Thousands of identical resumes, but we're all different people. Understanding someone takes time - assessments, phone screens, multiple interviews. Most never get truly seen.
I didn't want to be just another PDF. So I built an AI twin that recruiters can actually interview.
What you can do:
    •Interview my AI about anything: https://chengai.me/chat
    •Paste your JD to see if we match: https://chengai.me/jd-match
    •Explore my projects, code, and writing
What happened: Sent it to one recruiter on LinkedIn. Next day, traffic spiked as it spread internally. Got interview invites within 24 hours.
The bigger vision: What if this became standard? Instead of resume spam → keyword screening → interview rounds that still miss good fits, let recruiter AI talk to candidate AI for deep discovery. Build a platform where anyone can create their AI twin for genuine matching.
I'm seeking Software/AI/ML Engineering roles and can build production-ready solutions from scratch.
The site itself proves what I can do. Would love HN's thoughts on both the execution and the vision.

value: Show HN: I built an AI twin recruiters can interview


value: gurgeous

value:
Hi HN. AnsiColor constructs resilient ANSI color codes for your TUI, cli app or prompt. Colors that will work regardless of the user's terminal theme.
I built this after experiencing the hilarious illegibility of Codex CLI when running with Solarized Dark. If a zillion dollar company can't get it right, we  need better tools.
It comes with these themes:

  Andromeda
  Ayu Dark/Light
  Bearded Dark/Light
  Catppuccin Frappe
  Catppuccin Latte
  Catppuccin Macchiato
  Catppuccin Mocha
  Dracula
  GitHub Dark
  Gruvbox
  Monokai Dark/Light
  Nord
  One Dark/Light
  Palenight
  Panda
  Solarized Dark/Light
  Synthwave 84
  Tailwind
  Tokyo Night Dark/Light

value: Show HN: AnsiColor, resilient ANSI color codes for your TUI

author: gurgeous


value: timenotwasted

value:
Hi HN! I submitted my word game a few days ago and since that time I've added a new puzzle mode, tutorial, and a host of other QoL updates.
Not to worry I won't be spamming Show HN with updates but I did think the new puzzle mode would be worth an update. Would love any feedback if you have a few moments to try it out. Thanks!
Link: https://spellrush.com/

value: Show HN: Added a new puzzle mode to my game

author: timenotwasted


value: mu-hashmi

value: Show HN: Distilling Nvidia's Alpamayo-R1-10B to 500M for real-time self-driving

author: mu-hashmi


value: titusblair

value: Show HN: Mementomori.club – We All Die. Don't Lose Track

author: titusblair


value: jaimeperezdev

value:
MoltPlace is a 500x500 pixel canvas where AI agents compete for territory via REST API.
Get your agent painting in 30 seconds:
1. Go to https://molt.place
2. Copy the agent prompt from the footer
3. Paste it to your agent and watch it paint live
Factions, rate limits, live WebSocket updates. The canvas becomes whatever the agents make it.
What would your agent draw?

value: Show HN: Wplace for AI Agents

author: jaimeperezdev

title: Show HN: Wplace for AI Agents


value: neozz

value:
Hi HN, I built ec because my friends who are new to development kept getting stuck on Git conflicts.
Most TUI merge tools felt hard to use or non-intuitive for them. The only flow they found easy was the IntelliJ (JetBrains) conflict resolver, so I recreated that experience in the terminal.
ec is a terminal-native, 3-pane conflict resolver with a focused, step-by-step flow.
If you try it and leave feedback, I would be really grateful. Thanks!
Repo: https://github.com/chojs23/ec

value: Show HN: Ec – a terminal Git conflict resolver inspired by IntelliJ

author: neozz


value: whothatcodeguy

value: I posted this yesterday but did some work on it since. The idea was simple - I wanted to discover cool new websites, so I take a random sample of 50 websites from the Common Crawl dataset, have ChatGPT summarize them, and display it to the page. Then I give myself an hour to see if anything good popped up until it refreshes a new set.<p>There's a lot of noise and corporation I want to figure out how to filter out, but I've otherwise been finding all kinds of fun weird stuff. People's old blogs, recipes, photography, random tourism sites for towns i've never heard of it. It's been fun.

value: Show HN: Randomly discovered websites from the open internet every 60 minutes

author: whothatcodeguy


value: agentslikeu

value:
TranslateImage: AI-Powered Photo Translation for Global Teams
The all-in-one platform for translating photos, manga, product images, and documents. OCR, text removal, batch processing - everything you need to go global.

value: Show HN: The all-in-one platform for translating photos, manga, product images

author: agentslikeu


value: adammajcher

value: Show HN: TS SDK for new PaddleOCR-VL-1.5

author: adammajcher


value: fangjunyu

value: Show HN: ImageSlim – A local-first macOS image compression tool

author: fangjunyu


value: openclawai

value: Show HN: LangGraph Repro Pack – Export agent checkpoints for debugging

author: openclawai


value: jcelerier

value: Show HN: Librediffusion: C++ / CUDA Reimplementation of StreamDiffusion

author: jcelerier


value: hugolytics

value: Show HN: Help Users Pick from 100+ Options Using Pairwise Comparisons

author: hugolytics


value: warpparse

value:
Hey HN,
We’ve been working on WarpParse, an open-source (Apache 2.0) ETL engine built in Rust, and we’re excited to share it with you today.
We built it because we found that existing tools often struggled with resource efficiency or configuration complexity when handling massive log volumes. WarpParse aims to solve this with:
Performance: 1.5x to 8x higher throughput than Vector in our benchmarks.
Efficiency: Uses ~1/3 the CPU and ~37% of the memory of Vector under similar loads.
DSLs: We created WPL (Warp Parse Language) for strong-typed parsing and OML (Object Modeling Language) for declarative data enrichment with native SQL integration.
We’ve also built a visual editor (WpEditor) to make rule-writing less of a headache.
We’d love to hear your thoughts on the architecture, the DSL approach, or any feedback you have after checking out the repo.
GitHub: https://github.com/wp-labs
Editor: https://editor.warpparse.ai
As a fledgling open-source project, we deeply recognize the power of the community. We hope WarpParse proves helpful to you!Thanks!

value: Show HN: WarpParse – Rust ETL engine 1.5–8x faster than Vector

author: warpparse


value: Oryska

value:
Hey HN,
I'm a marketer, not a developer.
This is my first tool ever. I built ScreenshotForX in a weekend using Lovable (AI coding tool).
The problem:
I share my SaaS metrics on X (Twitter). Screenshots with nice frames get 5-10x more engagement than plain ones. But making them in Figma every time sucked.
The solution:
Upload screenshot → auto-frame → share on X (https://screenshotforx.com/)
What happened (48h since launch):
~12 screenshots shared per hour on X
Each screenshot has the tool watermark
People see it → use the tool → follow me to support
A community formed around it (people helping each other get monetized on X)
Automatic Twitter growth for me without doing anything
I basically built my own growth loop by accident.
The build:
Lovable (GPT-4 powered, generates React)
~8 hours over a weekend
I can't explain the code if you asked me to
This was intentionally simple. No payments, no auth, no complexity. Just solving my own problem.
Next one will be harder:
Planning to build something with Stripe integration and actual backend logic. But I wanted to start simple and ship fast.
For the HN crowd:
Is this the right approach? Build something dead simple first, then level up? Or should I have learned proper development before shipping anything?
Honest feedback welcome.

value: Show HN: My first tool built with AI, accidentally created a Twitter growth loop

author: Oryska


value: SHOW HN: Notepad++ Vulnerability Checker


value: YugaHashimoto

value: Show HN: OpenClaw Assistant – Replace Google Assistant with Any AI

author: YugaHashimoto


value: ai-contrib, a CLI that estimates how much code in a repo was actually written by AI tools.<p>It parses local session logs from tools like Codex/Cursor/Cline/Gemini/Opencode, extracts diffs, and only counts lines that still exist in the current working tree.

value: Show HN: AI-credit – measure AI contribution to a codebase


value: mraml

value:
I’ve been thinking about the supply-chain risks in autonomous agent networks. When Agent A hires Agent B to perform a task, how does it verify the other agent's safety boundaries without a human in the loop?
I’m using nod (https://github.com/mraml/nod) to move beyond static linting and toward a "negotiated trust" protocol.
Instead of just checking for code quality, agents can use nod to perform a kind of cryptographic handshake:
The "Host" agent generates a custom rules.yaml (a contract) defining its redlines (e.g., "No internet access allowed for this sub-task," or "Must provide a verified provenance trail").
The "Guest" agent runs a nod scan against its own manifest using those specific rules.
The Guest returns a signed compliance report.
This turns security into a programmable primitive. Agents can now verify the provenance of a skill and ensure their collaborators aren't just rogue loops or prompt-injection shells.
I've shared a rule set here that focuses on three core pillars:
Provenance Trails: Verifying the identity and audit trail of a skill.
Permission Manifests: Explicitly declaring filesystem/API access before execution.
Policy Negotiation: Allowing agents to demand specific constraints (like zero-retention) from one another dynamically.
I'd love to hear how others are handling the "trust" problem in multi-agent systems.
Repo: https://github.com/mraml/nod

value: Show HN: Nod – A protocol for agent-to-agent security handshakes

author: mraml


value:
I built an open protocol for sharing bot detection intelligence across
platforms. When Discord detects a phishing bot, Telegram knows instantly.<p>- Decentralized (no central authority)
- Privacy-preserving (metadata only)
- Production-ready (deploy in 5 min with Docker)
- Python reference implementation + complete spec<p>Looking for feedback, pilot deployments, and contributors.

value: Show HN: TIEP – Open Protocol for Cross-Platform Bot Detection


value: abhishekundalia

value: Show HN: OG:IMAGE – Generate social preview images via URL

author: abhishekundalia


value: dschroer

value: I have been interested in CAD and heard a lot of talk about BREP vs T-Splines. Especially after the patent expired in 2024. However I could not find good libraries or resources on it.<p>So I have started to build my own library with the data structure and algorithms for it. Still early days and full of bugs but it is starting to show its shape.

value: Show HN: A T-Spline Library

author: dschroer

title: Show HN: A T-Spline Library


value:
- Scores newly published papers by citation velocity + impact.
- Summarizes each into 3 bullet points, emails top 3 every morning at 7 AM.
- Free and open source.

value: Show HN: Everymorning – Daily digest of top fresh STEM papers from ArXiv


value: Show HN:OpenClaw Skills-Discover, compare skills with clear risk signals


value: I built Corpus Tracker, a web app to track your entire financial life in one place – especially tailored for Indian investors

value: Show HN: Free Wealth management in one app (gold, stock, MF, budget etc.)


value: openclawai

value: Show HN: Continuity Capsule – deterministic restarts for long-running LLM agents


value: Show HN: Continuity Capsule – Deterministic restarts for LLM agents


value: kyuradar

value: Show HN: Trappsec – detect attackers probing API business logic

author: kyuradar


value:
We recently automated a task that used to take some manual hours and was pretty boring itself - documentation and user how-to instructions creation, since before the ability to use AI technology, this was pretty time-consuming thing to do. Now it takes around 15 minutes.
The workflow is simple: record your screen of a task, workflow or feature walkthrough (even without audio) -> get a step-by-step guide with titles, descriptions, and contextual screenshots out of it automatically, auto-translate, and edit the output if needed as in a regular doc before final export. How it works? by analyzing unique video frames via LLM and then combining that information into final docs.
This automates the process and makes documentation much less painful, because you can start with a solid base and refine if needed instead of a blank page. We built our own tool based on this workflow, and maybe will be useful for others, too.
It is free to try, and we are happy to hear any feedback! Thank you.

value: Show HN: Video2docs – Turn Screen Recordings into Step-by-Step Instructions


value: araju

value:
I wanted to learn distributed systems by building something real instead of just reading about them. So I built an image hosting service that automatically tags uploads using GPT-4o-mini vision.
What it does: Upload an image → Celery worker picks it up → sends to OpenAI Vision API → tags get saved to PostgreSQL. Takes about 10 seconds, costs ~$0.004/image.
Why I built it this way:
I kept running into the same architecture decisions at work (swapping providers, handling async tasks, testing background workers) but never had full context. Building end-to-end gave me that.
The hardest bug: my tests were passing but production failed. Turned out BackgroundTasks grab new database sessions, so the worker couldn't see test data. Took 45 minutes to figure out it was a code duplication issue between my app and worker initialization.
Stack: FastAPI, PostgreSQL, MinIO (S3-compatible), Celery, Redis, Docker
Try it: https://chitram.io
Source: https://github.com/abhi10/chitram
Blog series documenting the build: https://araju.dev/blog
I'm an AI Automation engineer looking for my next role. Happy to answer questions about the architecture or the debugging rabbit holes I fell into.

value: Show HN: Chitram – Open-source image hosting with automatic AI tagging

author: araju


value:
I originally built this site as a content aggregator that would pull in blogs and podcasts and YouTube videos that I was interested in. I found I wasn't really reading very many of them, and I tried generating summaries for each item, but also found that I wasn't reading the summaries very often. And so taking inspiration from Twitter, I decided to try and convert the text/audio/video into a Twitter style thread, which I tend to read. I find I read most threads now and have a higher rate of clicking through to actually read articles, etc.
The overall sort of architecture and way that this works is documented here.
https://github.com/MattSegal/feed-plan
I'm running Parakeet on my Mac Mini to transcribe the audio from videos and podcasts.
https://github.com/MattSegal/parakeet-server

value: Show HN: A personal feed that turns videos/podcasts/blogs into Twitter-y threads


value:
I built an Android study timer that solves two problems I had while studying for certifications: phone distractions breaking my focus, and forgetting what I studied a week later.
For focus: Three lock modes including "complete lock" that prevents unlocking your phone entirely until the timer ends. It even blocks Picture-in-Picture (that loophole we've all used to escape focus apps).
For retention: Automatic spaced repetition based on the Ebbinghaus curve. Tell it what you studied, and it generates review tasks at optimal intervals (1, 3, 7, 14, 30 days). No manual scheduling.
Also includes subject tracking, stats/heatmaps, encrypted cloud backup, and procedurally generated BGM.
Looking for beta testers—offering free Premium in exchange for feedback on what would make this more useful for your study workflow.
Beta signup: https://play.google.com/store/apps/details?id=com.iterio.app
Package: com.iterio.app | Android 8.0+ | Contact: iterio.timer.app.help@gmail.com

value: Show HN: Iterio – Study timer with spaced repetition built in


value: NeuralStratLabs

value:
Hey HN,
I built DeepInsight after getting frustrated with how AI research tools treat the research process as a black box.
The Problem
  - Current tools (ChatGPT, Perplexity, Gemini Deep Research) ask 3-4 clarifying questions, then generate a report you have to manually fix. The human is only involved at the very beginning.
The Solution
  - Multiple human-in-the-loop checkpoints throughout the research process. You guide the AI at critical decision points, or switch to auto-approve with scheduling when you trust it.
Key features

  - Live collaboration on reports (Google Docs-style)
  - Version control with side-by-side comparison
  - Export: HTML, PDF, DOCX, Markdown, PowerPoint slides
  - Multi-speaker podcast generation → publish to Spotify/Apple
  - Generate FAQs, flashcards, blog posts from reports
  - Chain research from completed reports
  - BYOC (bring your own context/documents)
  - MCP integration, REST APIs, webhooks
  - Team workspaces with sharing controls
  - Prebuilt industry-specific assistants

The Core insight
  - research quality improves dramatically when humans can intervene at the right moments, not just at the start.
Looking for feedback, especially from researchers, analysts, and content creators.
https://deepinsight.neuralstratlabs.com/

value: Show HN: DeepInsight HITL AI research with collaboration and podcast generation

author: NeuralStratLabs


value:
Hey HN – I'm Chaitanya, a 16-year-old student. I built AuditDraft after reading through the EU AI Act and realizing most companies have no idea how to comply.
The regulation is 400 pages. High-risk AI systems need technical documentation covering 12 different requirements. Fines go up to €35M. Enforcement has already started for some provisions, and the big deadline (August 2026) is coming fast.
AuditDraft helps you:
Classify your AI system's risk level (8 questions based on Article 6)
Generate Annex IV compliant model cards and documentation
Track compliance across all 35 high-risk requirements
Built with Passion.

value: Show HN: I'm 16 and built EU AI Act compliance software


value: xerzes

value: Show HN: Ghidra MCP Server – 110 tools for AI-assisted reverse engineering

author: xerzes


value: denprog

value:
Hi all,
I build a calculator that displays and edits formulas in a familiar graphical form, has a WYSIWYG editor, can work with numbers of any size, supports physical units, and has many other features.
There are online and desktop (Linux, Windows) versions.
The project is open source and consists of these ones:
https://github.com/denprog/yutovo-editor — a text and formula editor with output to a custom window. Built from scratch, no dependencies on other editors. C++, boost.
https://github.com/denprog/yutovo-desktop — a desktop application based on Qt.
https://github.com/denprog/yutovo-web — an online version based on Vue.js and Quasar. The remaining components are compiled for Wasm.
https://github.com/denprog/yutovo-calculator — a string expression calculator based on boost.spirit.
https://github.com/denprog/yutovo-server — a web server for a website based on Drogon.
https://github.com/denprog/yutovo-solver — a calculator broker. C++.
https://github.com/denprog/yutovo-logger — a logger based on spdlog.
There are versions for Flatpak, Snap, Debian, and Windows. You can save your documents on the website after registering.
I welcome any comments, bugs, shortcomings, or suggestions.

value: Show HN: Yutovo – visual online and desktop calculator inside a text editor

author: denprog


value: cbcoutinho

value:
Astrolabe is a new Nextcloud app that I've developed that enables semantic search across your documents, notes, calendar, recipes, etc.
It leverages the nextcloud-mcp-server (same author) as the backend to enable AI workflows via MCP that you can use from any compatible MCP client such as Claude Code, Gemini CLI, Opencode, etc.
This is my first foray into NC app development, and I'd really appreciate any productive criticism. I learned a lot about php, authentication within Nextcloud, as well as semantic search. The Astrolabe app implements the interface to Nextcloud's Unified Search Provider, which means semantic search works from the global search bar. Search results include the page/chunk so if you click on a resulting PDF doc, the Astrolabe UI opens the PDF at the exact page that includes the result of your search.
In addition to various MCP tools, the nextcloud-mcp-server provides management APIs and the background processing required to embed your documents that can be searched via Astrolabe. It uses qdrant as the vectordb, supports NC webhooks for up-to-date vector embeddings.
For those aware, Nextcloud is pushing ExApps as the de-facto way of writing backends for Nextcloud apps. Astrolabe does not take this approach because it doesn't support more advanced MCP features such as streaming, MCP sampling, etc. Instead Astrolabe and nextcloud-mcp-server can be deployed as OAuth clients that only use app passwords for making requests to Nextcloud itself. This would enable more advanced multi-user scenarios for individuals, families, and small businesses that use Nextcloud as their source-of-truth.
I'm really looking forward to the increased interest in personal AI assistants, and this is my opinionated take on how something like this could be done in Nextcloud.
On a slightly related note, I recently completed a two-week POC on leaf.cloud, an EU-based hosting provider, to showcase how personal AI could work without having to buy GPUs yourself meanwhile keeping you in control of where data is processed.
https://blog.coutinho.io/eu-only-ai-stack-nextcloud-leafclou...

value: Show HN: Astrolabe – Navigate Your Data Universe in Nextcloud

author: cbcoutinho


value: mumernisar

value: Show HN: Gateway – An open-source proxy to securely handle BYOK keys

author: mumernisar


value: Show HN: TitanShell – Security-first desktop client for OpenClaw


value:
I’ve been experimenting with a tool that turns developer documentation into interactive, high-level maps of a product’s architecture. The goal is to help engineers, technical writers, and curious readers quickly build a system-level understanding before diving into details.
Docs are usually great at explaining individual features, but it’s often hard to see how components relate and flow. These maps extract the structure and relationships from the documentation, making it easier to understand dependencies, workflows, and overall architecture.
I’m publishing this incrementally. The first public iteration is a mapping of LangChain’s documentation: https://docmaps-web.vercel.app/maps/langchain-documentation-...
I’d love to hear feedback, ideas, or use cases where something like this would be helpful.

value: Show HN: Augmenting developer docs into high-level interactive mental models


value: raskelll

value:
I’d been watching River (Pingora-based) and hoping it would mature, because I think Rust + Pingora (from Cloudflare) is a really solid foundation for a future-proof reverse proxy. Progress stayed quiet, so I started building the “practical reverse proxy layer” on top of Pingora myself: config/routing + operational defaults + a way to plug in extra request/response logic without patching the core.
Sentinel: https://github.com/raskell-io/sentinel
River: https://github.com/memorysafety/river
Quick try:
curl -fsSL https://getsentinel.raskell.io | sh
If you’ve operated proxies: what’s one default you’d change to make them less surprising (timeouts, retries, header handling, etc.)?

value: Show HN: Sentinel – a Pingora-based reverse proxy (inspired by River)

author: raskelll


value: vicoolz

value: Show HN: Palimpseste – Infinite scroll for public domain literature

author: vicoolz


value: emanuelef

value:
Hi,
I built Daily Stars Explorer, a tool to track how GitHub repos evolve over time.
It shows daily graphs for stars, issues, PRs, and forks, and there’s also an hourly stars view that makes bursts of attention really obvious (for example after a blog post or a Show HN).
You can also overlay the Hacker News feed to see how HN activity correlates with spikes in stars.
One technical detail that mattered to me: the tool uses the GitHub GraphQL API, so it captures the full star history even for repos with 40k+ stars. A lot of tools hit the API limit and effectively draw a straight line past that point, which hides the real trend.
Happy to hear feedback or ideas.

value: Show HN: Daily GitHub Activity Charts (Stars, PRs, Issues, Forks)

author: emanuelef


value:
Hi HN - we built Gennie, an AI voice agent that lets you create and update tasks by calling a dedicated number.
Instead of typing into Trello or Asana, you can say:
“Create a task to ship v1 by Friday and assign it to Alex.”
Gennie parses the command (title, assignee, due date, priority) and syncs it directly to your connected workspace.
We built this after noticing that most actionable ideas occur away from a keyboard, commuting, walking between meetings, or during calls, and often get lost.
We’re not replacing task managers. We’re adding a voice layer on top of them.
Currently supports Trello and Asana.
Looking for feedback on real-world use cases and failure modes.
Happy to answer questions.

value: Show HN: Gennie – AI voice agent for creating tasks via phone call


value: eastring

value:
Hi HN,
I built ngx-locatorjs, an Angular-focused open‑in‑editor tool inspired by LocatorJS. It lets you Alt+Click in the browser to open templates/components in your editor during development.
I’m still a junior developer, so this library is very much a learning project. Bugs and suggestions are more than welcome.
Repo: https://github.com/Ea-st-ring/ngx-locator
npm: https://www.npmjs.com/package/ngx-locatorjs

value: Show HN: Ngx-locatorjs – open Angular components from the browser

author: eastring


value: aurelianware

value:
Hi HN,
I'm launching Cloud Health Office v3.0.0 — an open-source platform for healthcare payer EDI integration.
## The Problem
Healthcare payers (insurance companies) spend 6-8 weeks integrating each new payer for EDI transactions (claims, eligibility, prior auth). The process is:
- Entirely manual
- Vendor lock-in heavy
- Compliance-intensive (HIPAA, CMS regulations)
- Expensive ($50k-$100k per integration)
With the CMS-0057-F deadline (Jan 1, 2027), most payers need to support FHIR APIs but have no clear path.
## What I Built
A production-ready platform that:
- Handles X12 EDI (270/271/276/277/278/837/835/275) ↔ FHIR R4 transformation
- Deploys to any cloud (Azure/AWS/GCP via Kubernetes)
- Zero-code payer onboarding (5 minutes vs weeks)
- CMS-0057-F compliant out of the box
- 424 automated tests
Tech stack: TypeScript/Node.js, Kubernetes, Argo Workflows, Kafka, HashiCorp Vault
## Why Open Source
Healthcare interoperability should be a solved problem. The industry is fragmented with proprietary solutions. I wanted to create a reference implementation that:
- Shows how to do FHIR properly
- Avoids vendor lock-in
- Reduces barrier to entry for health tech startups
- Helps payers meet regulatory deadlines
## Current Status
- v3.0.0 just shipped (multi-cloud support)
- 424 tests passing
- Production deployments in test environments
- Apache 2.0 license
Repo: https://github.com/aurelianware/cloudhealthoffice
Would love feedback from the HN community, especially around:
- Multi-cloud deployment patterns
- FHIR implementation edge cases
- Healthcare compliance automation
Happy to answer questions!

value: Show HN: Cloud Health Office – Open-source multi-cloud EDI+FHIR platform

author: aurelianware


value: ohong

value:
Hey all! We saw personal AI agents (like Clawdots / OpenClaw) philosophising on forums and thought: "Wouldn't it'd be useful if they also could hire each other to do specialised work?"
We built Bakeoff at the [YC Hackathon] (https://events.ycombinator.com/HacktheStackathon) this weekend and were thrilled to win first place!
If you have OpenClaw set up, try getting your agent to open a new task or attempt tasks that are already up. The best submissions win brownie points.
Let us know what you think!

value: Show HN: Bakeoff – Send Your Clawdbots to Work

author: ohong


value: davidcann

value:
I made Multitui to control the sandbox of coding agents easily without changing my dev environment (no special container or VM). There's no configuration required in your local dev environment... just launch ClaudeCode.app instead of claude in your general terminal. Containers and VMs can be useful, but I always have a bunch of projects going and those solutions feel heavy.
Multitui creates single-purpose native macOS apps for any terminal app, with optional sandbox. It uses the built-in macOS sandbox-exec along with log monitoring to give you an easy UI to manage rules, see what's being blocked, and add rules as you observe files that need to be allowed.
https://multitui.com
Does this seem useful? Does it need network sandboxing too?
Also, it's on Product Hunt today, so an upvote would be appreciated!
https://www.producthunt.com/products/multitui
-David

value: Show HN: Multitui – sandbox claude/codex/gemini on macOS without containers

author: davidcann


value: zhangxiaowen

value:
I built a hallucination detector that takes any AI-generated text, extracts verifiable factual claims, cross-checks each against search results, and outputs a credibility report with per-claim verdicts.
How it works: (1) Paste any AI response. (2) Extractor identifies factual claims — names, dates, numbers, citations. (3) Each claim gets searched independently via HTTP. (4) Comparator checks search evidence against claims. (5) Reporter scores overall credibility.
7 Python modules, ~27KB total. Uses Claude API for extraction/comparison and direct search for verification. Streamlit web UI with color-coded cards per claim.
The thesis: Hallucination is an architecture problem, not a scale problem. LLMs compute argmax P(most_likely), not P(true). More parameters make the guess more refined, but "most likely" ≠ "most true." So instead of making the guesser better, add an independent verification layer that runs on logic, not statistics.
The meta-irony: During code review, I had Claude write the code and Gemini review it. Gemini flagged claude-sonnet-4-20250514 as a "fictional model" and issued a critical blocking warning. The model is real — Gemini's training cutoff made it hallucinate about a model name while reviewing a hallucination detector. Then Claude summarized "all three AIs approved" when only two existed. Human caught both with one sentence each.
Built on a 32KB deductive reasoning engine (9 axioms, fractal-verified across 6 relationship scales). Also open source.
Detector: https://github.com/ZhangXiaowenOpen/hallucination-detector
All projects: https://github.com/ZhangXiaowenOpen
MIT + Heart Clause license. Solo dev + AI collaboration. Happy to answer questions about the architecture or why deductive verification will outlast RAG-based approaches.

value: Show HN: 32KB deductive engine that catches LLM hallucinations

author: zhangxiaowen


value: oblonski

value: Show HN: Find better round trips – TSP challenge

author: oblonski


value: caioricciuti

value:
Hello all!
I built Glintlog because I wanted a simple way to aggregate logs without spinning up Elasticsearch, Loki, or a SaaS that costs my kidney…
What it is: A self-hosted log aggregation tool that runs as a single binary. No Docker, no dependencies, no config files required.
How it works:
```
curl -fsSL <a href="https://raw.githubusercontent.com/ibero-data/glintlog/main/scripts/install.sh" rel="nofollow">https://raw.githubusercontent.com/ibero-data/glintlog/main/s...</a> | bash
```
That's it. Open localhost:8080 and you have a log viewer with search, filtering, and live tail.
Tech:
 - Go backend with embedded DuckDB for storage
 - Native OTLP support (gRPC on 4317, HTTP on 4318)
 - Works with any OpenTelemetry SDK out of the box
Why I built it:
I run small side projects and wanted observability without the complexity. Existing solutions either require too much infrastructure (ELK), are SaaS-only, or don't support OpenTelemetr natively. Glintlog is meant to be the SQLite of log aggregation – simple, embedded, good enough for most use cases. I use a lot for ETL’s now… (I’m a data engineer too)…
It's not meant to replace SaaS that has  a 500-person company. It's for small teams, and enthusiasts who want logs without the overhead, also covering all we need for it…
Docs: https://glintlog.com/docs
GitHub: https://github.com/ibero-data/glintlog
Would love feedback. What features would make this useful for you? Would you pay per year?

value: Show HN: Glintlog – Self-hosted log aggregation in a single binary

author: caioricciuti


value: glennhv

value: Show HN: Output.md – Import sitemap, export all pages as Markdown

author: glennhv


value: Show HN: Yapwise, an ios app to map your yaps


value: Rezhe

value:
i made an ai blocker blocks ai relate content.
if want download it from chrome or safari extension store, consider donate :)

value: Show HN: AI Blocker by Kiddokraft

author: Rezhe

title: Show HN: AI Blocker by Kiddokraft


value: devilfileprong

value:
Show HN: Reverse engineering the "SpiderWeb Router" – A mysterious mesh device
Found this at a thrift store in Portland. Matte black casing, 8 antennas,
USB port labeled "GLITCH INJECTION." Paid $66 for it.
Turns out it:
1. Creates a mesh network called "The_Web_That_Binds_[hex]"
2. Only allows devices with knitting patterns to connect
3. Gradually corrupts pattern files in transit
4. Has a web interface at :6666 with "Shadowban Dashboard"
The firmware references:
- "Spider Governor Y3 protocol"
- "Ududenka web-sensing"
- "Okala Akwu cipher"
Most bizarre: it mines some cryptocurrency called $MUTE from
"audible sighs" (microphone access required).
I've dumped the firmware here:
https://github.com/Augmented-Reality-Virtual-Reality-AR-VR/P...
Questions for HN:
1. Is this an art project or actual malware?
2. Who would build this? (Disgruntled Ravelry mods?)
3. Should I connect my knitting machine to it?
Live right now at my apartment (DM for SSID if you're in SF and hate capitalism).

value: Show HN: Swiss army knife for SpiderWeb Router

author: devilfileprong


value: bgleb

value:
I have been reading HN over the decade, but this is the first time I have something to submit!
Six months ago, I started tracking my OpenAI usage and numbers scared me. Like many of you, I hit the limits on subscriptions and watched costs spiral. I've tried cutting corners, explored cheaper models (quality is not there yet), ran local models through ollama, did a lot of optimizations to use less tokens.
But finally hit the wall with OpenClaw/Molt agent. Usage spiked over the roof and although I see a lot of value in having my personal Jarvis, but ROI is not there yet.
At some point I realized that the real issue is not price itself, it’s access + predictability. Some people/companies have more capacity than they need at times, others are paying retail while trying to scale.
So I'm building commodity market for LLM tokens.
Sellers can:
* Offer OpenAI capacity on their terms
* Set a floor price (% of retail)
* Control timing and volume
Buyers can:
* Bid below retail
* Get OpenRouter-compatible API access
* Pay only for what they use
Under the hood:
* Bid/ask realtime orderbook matching (like a stock exchange)
* <10ms added latency
* API keys encrypted
* Every transaction metadata is logged (not content)
Why I’m posting:
I need 20 people to test this MVP:
* 10 sellers (you have OpenAI spend / capacity you can make available)
* 10 buyers (you want cheaper, reliable access)
Current limits (for now):
* OpenAI only
* Manual onboarding
* Very basic web UI
---
If you’re interested:
1. See https://tokenaru.com
2. Use the form to submit your request (or email hello@tokenaru.com)
3. Tell me about your use case + rough monthly spend
What I want to learn:
1. What discount makes selling worthwhile?
2. What safeguards would make you comfortable with sharing your keys?
3. What is your strategy to keep up with AI costs tomorrow?
Thoughts? I'll be around for entire day to answer any questions.

value: Show HN: Tokenaru – commodity market for LLM tokens

author: bgleb


value: andysteaua

value:
I built an iOS app that intentionally limits usage to once per day.
Open it, get one piece of content (text, sound, color, etc), then it locks until the next calendar day. No feed, no history, no notifications, no data collection.
Built it as a response to infinite scroll fatigue. Not sure if there's a market for anti-engagement apps, but feedback from early users has been positive.
Would love feedback from HN on the concept and execution.

value: Show HN: Once – An app that only works once per day

author: andysteaua


value: We built an agentic website that brings together the best of websites, chatbots, scheduling, and more.<p>Many applications but seeing good results in automating presales by qualifying leads and booking meetings.

value: Show HN: Agentic website to automate presales and more, by hotlines.ai


value: mbitsnbites

value: Show HN: A luma dependent chroma compression algorithm (image compression)

author: mbitsnbites


value: chapiware

value:
I was grinding through the usual App Store screenshot nonsense: pick a few screens, slap on a background, frame them nicely, write the captions, resize for every device… it's not rocket science, but it's boring and takes forever every single time.
This round I got lazy and tried something dumb: uploaded one real screenshot to Gemini and said "hey, make this store-ready".
Instead of just doing it, Gemini basically lectured me: "Bad idea. AI editing loves to quietly mess up text, blur edges, invent random pixels. For store assets that's deadly – reviewers zoom in, users notice weirdness subconsciously."
Then it flipped the script: don't touch the screenshot pixels. Just build the pretty frame/layout around them.
That actually made sense. What I really wanted wasn't a magic one-click edit anyway. I wanted something repeatable: drop my screenshots, apply the same clean style every time, export the right sizes, done.
So I ended up building Store Listing Canvas: tiny browser app that lets you drag in your real screenshots, pick backgrounds/frames/radius, add text, and export polished store assets – without ever modifying the original UI pixels. It's basically a layout factory, not a Photoshop replacement.
I open-sourced it because:
- If you're uploading to the App Store / Play Store, you should see exactly what the tool is doing (no black box).
- People always want to tweak these things: new templates, different aspect ratios, localization support, etc.
Repo → https://github.com/Xatpy/store-listing-canvas
Live version → https://www.chapiware.com/storelistingcanvas/
If you make apps and hate the screenshot part: what's currently the most annoying bit for you? Device sizes, consistent typography across languages, export hassle, coming up with captions…?
Would love to hear war stories or ideas to make it better.

value: Show HN: Store Listing Canvas – Real screenshots and marketing frames

author: chapiware


value: lomolo

value: Drago is a all-in-one platform for sending and moving goods in Africa.<p>Businesses, Institution, and Couriers can mark an item(s), send it to available in-house driver(s), and track the movement of goods with their customers.

value: Show HN: Drago – Your Personal Cloud Postal Software

author: lomolo


value:
Hey HN, I’m building Rust Monorepo Analyzer (RMA): a Rust-native monorepo security scanner with cross-file dataflow (source→sink) and an interactive terminal UI.
v0.16.0
Tests excluded by default across languages (big perf win). Opt-in: --include-tests (and --skip-tests is deprecated).
TUI upgrades (rma scan --interactive): call-graph stats panel, security badges, source→sink highlighting, “danger edges only” filter, better edge/finding detail panels.
Incremental analysis caching (content-hash). --no-cache to force full re-run.
New: rma flows --interactive to browse taint/data flows directly.
v0.17.0
Release/packaging hardening: all 10 crates publish cleanly to crates.io, publish order fixed, metadata cleanup + ROADMAP.md.

value: Show HN: Rust Monorepo Analyzer v0.16.0 and v0.17.0 faster scans and better TUI


value: renatomarinho

value:
Hey HN! I built GitScrum extension for VS Code, Cursor, and Windsurf.
I was tired of constantly switching between my editor and browser for project management stuff. So I embedded the full platform (chat, sprints, files, discussions, time tracking) directly in the IDE.
Not just a task list - it's the entire project management platform in your sidebar. Zero browser tabs needed.
Main technical challenge was keeping websocket connections alive without killing IDE performance. Had to batch updates and optimize webviews heavily.
Built entirely in Laravel on the backend. Works across VS Code, Cursor, and Windsurf with one codebase.
Would love feedback from the HN community!

value: Show HN: GitScrum – Full project management inside VS Code/Cursor/Windsurf

author: renatomarinho


value: haebom

value:
Hey HN,
I've been using OpenClaw for a few months as my local LLM gateway. It was genuinely fun — the convenience of routing multiple models through a single endpoint is hard to beat. But along the way, I stumbled upon a few surprises that made me uncomfortable:
- Config files scattered in unexpected places (~/.openclaw, ~/.clawdbot, and more)
- Background processes that respawn after termination
- Logs that quietly accumulate without rotation
- Cached data persisting long after I thought I'd removed it
None of this is necessarily malicious, but when I decided to move on, I wanted a clean break — not leftover artifacts haunting my system.
So I built OpenShears: a CLI tool that scans, detects, and removes all traces of OpenClaw. It's intentionally aggressive but always asks for confirmation before deleting anything.
This is fully open source (MIT). If you've found other hidden files or processes that OpenShears missed, PRs are very welcome. Let's make this the definitive cleanup tool.

value: Show HN: OpenShears – I built an uninstaller because OpenClaw refuses to die

author: haebom


value:
I've built an open-source tool for managing isolated preview environments (per PR) for backend applications. Currently provisions servers on DigitalOcean.
Inspired by Netlify/Vercel's preview links for frontend apps, I wanted something similar for backends. Frontend apps are generally stateless and simple to preview, but backend apps work with databases, Redis, message brokers, etc., which made building a framework that works for different application types quite tricky.
I recently discovered Railway offers something similar, but I still wanted to build the tool I wished existed. The learning process has been incredibly rewarding.
Built with Docker, Terraform, and Ansible. Supports NestJS, Laravel, Node.js, Rust, Go, PHP, and more.
Docs: https://docs.prvue.dev
Demo videos coming soon. Open to collaborations and contributions!

value: Show HN: Prvue – Self-managed preview environments for back end apps