value: mobsterino

value:
Hey everyone,
I built DashAI after realizing that in my day-to-day work, we were spending weeks building dashboards in SQL or BI tools that most people barely looked at afterward.
It got me thinking - what if instead of static dashboards, you could just ask your data a question and get an instant answer - with charts and insights - like talking to a teammate who understands your business?
That became DashAI.
You upload a CSV (or connect a data source), ask questions in plain English, and DashAI generates visualizations, summaries, and trends automatically.
It’s not meant for developers or data scientists - it’s for founders, operations teams, and analysts who want to understand their data without writing queries or managing dashboards.
I’d love honest feedback from this community - especially around:
onboarding experience
how valuable it feels after the first insight
whether the “AI analyst” concept is clear or too abstract
You can try it here: get-dashai dot com

value: Show HN: DashAI – Turn CSVs into instant insights with an AI business analyst

author: mobsterino


value: psyentist

value:
I started working on this when I realized what's wrong with tools like FullStory. I work at a B2C iGaming company in product management. We use FullStory and it has been very helpful for watching session recordings to analyze customer behavior, but also for session replays during bug investigations.
However, there are a couple of problems with it. It's very expensive and very heavy because it captures all DOM changes, so it slows down the experience of the end user. For these reasons you are forced to do heavy sampling, for example record only 10% of the sessions. Apart from that, you need to spend a lot of time watching session replays, and sometimes you cannot find the session you are interested in as it might not be included in the recorded sample.
This was basically the trigger for the idea. I started working on building my own tool. The idea was to make it as simple and lightweight as possible, and focus on clarity rather than adding a lot of bloat.
Also worth mentioning, I have noticed that FullStory and other tools recently started adding AI session summary features, which means there is clearly a need. However, they cannot really do visitor-level summaries across sessions or generate broader insights, because due to the heavy script overhead you end up sampling only a small percentage of traffic. Technically you could record all sessions, but it would be extremely expensive and would slow down the experience for everyone. The difference with my approach is that because the tracker is lightweight, you can record all sessions and still generate visitor summaries and insights across the full dataset, at a much lower cost.
So the idea is simple: capture signals from user browsing, such as pageviews, clicks, scrolling, and metadata from the request headers. Record all these events in a session. Then schedule a job every X minutes to send the events to an LLM and get a summary of the session. Then move a level up and generate a visitor profile summary across all sessions of that visitor. Basically it's like a living memory layer of your customers. Finally, use the session summaries and visitor profile summaries as input and let the LLM identify patterns and generate insights, things you might not know about how your visitors behave, things you can act upon.
The first decision was what to use for recording customer behavior. Initially I tried to use rrweb, but I noticed that it slows things down a lot as well. So I ended up building my own tracker that captures just enough signals for generating a summary, but at the same time keeps it super lightweight. For example, on each pageview I record a snapshot of the DOM to give context to the LLM about what the visitor is browsing, but I'm not recording all DOM changes like FullStory.
The next thing was how to generate visitor summaries and insights. Should I send all raw events or just session summaries and visitor summaries? I ended up sending only the summaries as I was happy with the output, and this way I keep it much more cost effective in terms of LLM input tokens.
So far I've tested the tool myself by injecting the script with a Chrome extension and browsing around various websites. The summaries I see so far make a lot of sense. Now I'm looking to test it in the wild with data from real visitors, so I'm looking for people who are happy to embed it in their website and see how valuable the summaries and insights are. Of course I will collect feedback and improve the tool.
On the landing page you can click on Explore Live Demo and you will get an idea of how the tool works.
Thanks.

value: Show HN: I built a lightweight AI tool to analyze visitor behavior

author: psyentist


value: Show HN: A tool to properly observe your LLM's context window


value:
Hi HN,
I realized there is a lot of duplicate effort in managing both git and Linear issues.
So made a simple CLI that feels like git, but actually modifies the Linear Issues as well.
I have 3 use cases right now:
1. lit switch "description of issue"
- Runs a search through Linear for issues matching the description
- If multiple hits, will ask to disambiguate
- Assigns issue to you, marks as in progress
git checkout the branch name (creates it if it doesn't exist)
2. lit commit "commit message/issue comment"
- Figures out correct issue based on branch
- leaves a comment on the issue
- git commit -m
3. lit checkout "Issue Title" -d "Description of Issue" -t f
- Parses arguments: title, description (optional), issye type [bug, feature, improvement] (optional)
- Creates new Linear Issue
- Generates the Linear automation friendly branch name (exactly how Linear does it in the UI)
- Does git checkout -b LinearbranchName
Give it a go and let me know what you think! Also happy to publish to brew if there is enough interest.
Happy Building!

value: Show HN: Lit – Linear and Git CLI in One


value: mayankd

value:
Started this because configuring Fabric8 for EKS was driving me crazy. Building a client that auto-detects your environment (IAM roles, profiles, local configs) so you don't have to wire it all up manually.
Still pretty early and building for EKS right now. Long way to go, but putting it out there early to see if others have hit the same problems or want to help shape where this goes.

value: Show HN: Building a Cloud Native Kubernetes Java Client

author: mayankd


value:
Erpa is an intelligent browser extension that transforms how you interact with web content. Powered by Chrome's Prompt API and advanced semantic search, Erpa understands page content and responds to your voice and text commands through an AI agent.
Check out -
Landing page: https://ahnopologetic.github.io/erpa/
Github repo: https://github.com/ahnopologetic/erpa
Demo video: https://www.youtube.com/watch?v=B4b-CDFzBYk

value: Show HN: Erpa – 100% on-device agentic browser extension for visually impaired


value: andrewperkins

value:
So I built Health Care Compare!
I built a way to compare different plans to estimate your yearly total based on your premium, and other medical visits/costs.
Every year it seems like I have to do this all in a spreadsheet, so I thought I would use AI to help make it a web app.
All data stays local in your browser—no server, no tracking, only 1 cookie (to not show the disclaimer for a week after you clicked it). You can export/import your data as JSON. There’s also an AI-powered plan import: upload your Summary of Benefits and Coverage (SBC) into an LLM with the provided prompt to convert it to JSON to import.
Feel free to audit the calculations and make a pull request with any fixes :)

value: Show HN: Health Insurance sucks!

author: andrewperkins

title: Show HN: Health Insurance sucks!


value: ravikantsaini

value:
I built a full backend-as-a-service platform — solo, in TypeScript — to fix what I hated about Supabase and Appwrite.
The Problem
- Supabase: Too rigid. One schema model. No flexibility.
- Appwrite: Too loose. No RLS. Security is manual.
The Solution: 3 Schema Types
| Type       | Use Case                          | Security |
|------------|-----------------------------------|----------|
| `Document` | Rapid prototyping (Appwrite-style) | Manual   |
| `Managed`  | Secure apps (auto RLS + permissions) | *Secure by default* |
| `Unmanaged`| Full SQL power (raw Postgres)     | None     |
### Killer Features
- *APIs better than PostgREST*: Join tables *without FKs*, filter by nested columns
- *Dashboard* (like Supabase Studio) – full CRUD, RLS editor, file browser
- *Type-safe SDK* – zero config, full autocomplete
- *Bun runtime* – faster than Node.js
- *Self-host in 2 minutes* with Docker
```bash
git clone <a href="https://github.com/Nuvix-Tech/nuvix" rel="nofollow">https://github.com/Nuvix-Tech/nuvix</a>
cd nuvix && docker compose up -d
```

value: Show HN: Nuvix – Open-source Supabase and Appwrite with 3 schema types, auto RLS

author: ravikantsaini


value: devarshishimpi

value:
I built a productivity chrome extension, this weekend. Introducing, AITab - Your AI-powered New Tab experience.
Always found the default new tab page a bit boring, so I decided to build my own AI-powered dashboard to make it more beautiful, personal, and productive.
Check it out and let me know what you think!

value: Show HN: AITab – Your AI-Powered New Tab Experience. (Chrome Extension)

author: devarshishimpi


value: kinottohw

value:
I’m building SafeDocs-AI, an AI tool to help teams check internal documents for GDPR compliance and spot sensitive info before it accidentally leaks out.
The workflow is simple: you connect your Dropbox, Google Drive, OneDrive, Dropbox accounts, then scan documents individually or in bulk. The AI analyzes each document and adds inline comments for lines that might contain sensitive or non-compliant data, with suggestions for corrections. There’s also a reporting page that summarizes the types of issues across all scanned documents.
We’ve been testing entirely with synthetic/fake data.
If you want to see it in action, here’s a short demo video showing the tool workflow (all fake data): https://www.safedocs-ai.com/video/demo.mp4
I’m mostly looking for feedback from this community:
- Would a tool like this actually help teams in their workflow?
- Any obvious privacy/security pitfalls I might be missing scanning across multiple platforms?
- Ideas for making the AI’s annotations helpful without overwhelming users?
Any thoughts, feature ideas, or general feedback would be hugely appreciated. I’m trying to figure out whether this would be genuinely useful for compliance teams before building more.
For those curious to try it yourself: https://www.safedocs-ai.app/login

value: Show HN: AI tool to scan internal docs for GDPR violations before audits

author: kinottohw


value: jaequery

value:
I built Ever.chat because I miss the early internet, when you could jump into a random chatroom and instantly meet people who shared your interests.
Ever.chat brings that back, reimagined for today. No accounts, no invites, no servers, just type a hashtag and you’re in.
Examples: #startups, #ai, #general.
Why:
Discord and Slack made chat too closed. IRC was too technical. I wanted the simplicity of “/join #something” — but in one click.
Would love your thoughts, especially from folks who remember IRC, or have ideas on moderation + scaling open chatrooms.
https://ever.chat

value: Show HN: Ever.chat – Instant hashtag chatrooms, like IRC for 2025

author: jaequery


value: hudishkin

value:
Hey HN, I built this for my own workflow: too much time lost copying text from Notes/Slack/etc. to ChatGPT/Claude and back. Wanted a simple way to query LLMs without leaving the app.
Promptix is a small Mac app that triggers on a hotkey for any selected text:
- Translate
- Fix grammar
- Rewrite/improve
- Summarize
- Text as prompt
- Custom prompts (e.g., "Convert bug report to PR description")
Key features:
- Works in any app: browsers, IDEs, terminals, etc.
- Bring your own key: OpenAI, Anthropic, or any OpenAI-compatible (including local like Ollama). No limits or costs from me.
- Runs locally on your Mac: full privacy, no data leaves (only selected text).
- 5 defaults prompts + unlimited customs.
Feedback or ideas welcome. What prompts would you customize?

value: Show HN: Promptix – send selected text to any LLM from Mac apps with one hotkey

author: hudishkin


value: Show HN: Bypassing face recognition using Fawkes – Now with web interface


value: mkasanm

value:
We just released our Prompt Station extension for AI chatbot automation.
https://winbuzzer.com/2025/10/21/release-prompt-station-brin...
It can handle very large libraries of prompts/chains/text snippets and offers automation of ChatGPT, Gemini, AI Studio, Claude, Grok, Mistral. We will be adding Openrouter soon and also more advanced features.
Besides the supported AI providers, it can be used with all websites via quick pasting into chat bars or any other input field.
We have focused on ease of use, offering many trigger options like context menu actions, browser bookmarks, hotkeys, and a top bar.
The extension works particularly well for running long prompt chains, offering stop sequences, manual input prompts (for additional context) , and manual/paste/auto modes. A JSON import/export manager, advanced search and tags are also integrated.
Please let us know what you think and how we can improve it further, especially for advanced prompt engineering. This is just the initial release and more features/improvements are already in the pipeline.

value: Show HN: AI Prompt Automation Extension for ChatGPT, Gemini, Claude, AI Studio

author: mkasanm


value: Show HN: Domaining Like It's 1999

title: Show HN: Domaining Like It's 1999


value: andrepd

value:
I've been following the development of posit arithmetic on and off for the past 2 years or so. A couple months ago I decided to try my hand at writing a software implementation.
For those who don't know, posit arithmetic is a new(ish) floating point format that offers _several_ advantages over IEEE floats, in particular at lower precisions. It generally has better precision and simpler design, and offers the quire, a way to compute dot products very fast and with no rounding errors (much can be said about its often surprising uses); this makes it suitable for HPC, neural networks, etc. I have some links to references in the README, if you're interested in learning more. I find it really interesting!
This crate aims to be a fully complete and correct standard-compliant implementation. Even though it's WIP, it already has a decent chunk of functionality: you can define types with arbitrary size and exponent size, convert to/from ints/floats, do + - × ÷, use the quire, etc. The main thing missing are elementary functions (exp, log, sin, etc.).
It's also very very fast, according to my benchmarks probably the fastest free implementation atm! If anyone knows of a faster one please get in touch, I'd love to add it to the benchmark suite.
Correctness is extensively tested too, exhaustively where possible, and with proptest where not.
Finally, the code is well-documented, including the internal algorithms, which might possibly make it (I hope!) a useful learning tool.
Thanks for reading!

value: Show HN: Fast-posit, sw implementation of posit arithmetic in Rust

author: andrepd


value: marcinem

value:
I built my first macOS app to automatically open csv, xls files in Google Sheets.
I work as marketing, revops person and often have to combine data from different platforms for reporting purposes.
Google made the import flow super broken with too many clicks in between. So I built a simple solution that saves me some time.
Sharing it here, you can test it out for free. No subscription bullshit, one time payment to get unlimited usage if you like it.
Happy double clicking!

value: Show HN: I made CSV files double-click to open in Google Sheets instead of Excel

author: marcinem


value:
Hi HN,
I built a duplicate file finder for my brother who's a photography enthusiast and constantly runs out of storage constantly due to resizing a lot of photos and having a lot of duplicates around.
Notes:
- Incremental hashing: Instead of loading entire files into memory, I hash files in chunks. Files with identical sizes get grouped and progressively hashed until they diverge or
match completely.
- Perceptual hashing: For images, I use perceptual hashing (pHash) that generates a fingerprint based on visual content rather than bytes. Similar images have similar hashes.
- BK-Tree indexing: To efficiently search for similar hashes, I implemented a BK-tree that organizes hashes by Hamming distance. This lets me query "find all images within distance
N" without comparing against every single hash.
- Configurable similarity: Users can adjust the Hamming distance threshold (1-15) to control how strict the matching should be.
- Added macOS Services integration so you can right-click any folder in Finder and select "Scan for Duplicates"
The app has a free trial (10 scans / 7 days, whichever is earlier) and then requires a license. I'm using Dodo Payments for licensing.
I'd love feedback from the community, especially on:
- Performance optimizations I might have missed
- Better UX patterns for the results view
- Edge cases in the similarity detection
- More feature suggestions
REQUIREMENTS: macOS 26.0.1 (Tahoe) and Apple Silicon Macs
Happy to answer questions about the implementation or architecture!

value: Show HN: DedupX – Duplicate file finder with perceptual image matching for macOS


value: gavb

value: Show HN: Plainwind – Translate TailwindCSS to Plain English in VS Code

author: gavb


value: benrobo

value: Show HN: I made an app which helps you never forget what you browse

author: benrobo


value: Djihad

value: Show HN: A tool that turns any RSS feed into unique, AI-written articles [video]

author: Djihad


value: dioptre

value:
We built what we're calling "operational spreadsheets" – spreadsheets that can actually execute actions across external systems, not just calculate and display data.
The core idea: spreadsheets have been passive tools for 40 years. You put data in, formulas process it, you export it, manually move it somewhere else, repeat. We added bidirectional API integration with natural language commands, so the spreadsheet itself can send emails, update databases, orchestrate workflows across services – autonomously.
Think of it as the evolution from VisiCalc → Excel → Google Sheets (multi-user) → Sourcetable (operational). The spreadsheet stops being just a calculation layer and becomes an execution layer.
How it works:

  - Natural language commands: "send emails to column A using data from column B" executes across connected email APIs
  - Three integration modes: pre-built connectors (Google Ads, Shopify, Stripe, Postgres), generative connectors (AI writes the integration code in real-time for any API, Database or MCP), and a credential vault
  - Full audit trail in cells – every action logs back to the spreadsheet
  - Excel-compatible (formulas, A1 notation, etc.)

Technical stack:

  - Python/FastAPI backend with Ray for distributed execution
  - React frontend with DuckDB WASM for client-side analytics
  - Apache Arrow for data interchange
  - LiteLLM for multi-model AI (OpenAI, Anthropic, Groq, Custom Models Based on Granite 4)

Example use case:
Instead of manually exporting Shopify orders, importing to Excel, calculating reorder quantities, and emailing suppliers, the operational spreadsheet monitors Shopify, detects inventory changes, calculates reorders, and submits purchase orders to suppliers automatically. The spreadsheet becomes the workflow engine, not just documentation.
We're live at https://sourcetable.com/superagents
Blog post on the email automation example: https://blog.sourcetable.com/email-from-a-spreadsheet/
Happy to answer technical questions. We know HN will have strong opinions on whether this is the right abstraction layer for automation vs. traditional workflow tools or code.
Key decisions we made that HN will likely debate:

  1. Spreadsheet as the orchestration layer (vs. Zapier/n8n/Airflow)
  2. Natural language commands (vs. formula DSL or Python)
  3. Generative connectors that write integration code on-demand (quality varies by API docs)
  4. Excel compatibility as a constraint (limits some interactions but keeps it accessible)

Founded by Eoin McMillan and Andrew Grosser. Backed by Preston-Werner Ventures (Tom Preston-Werner from GitHub), Long Journey, Bee Partners, NextView.

value: Show HN: Sourcetable – Operational spreadsheets that can read/write to any API

author: dioptre


value: cochlear

value:
As a fun, Halloween-y exercise, I've taken a break from some of the other hand-tracking-based WebAudio instruments I'm working on to make something simple and easy:  A MediaPipe + WebAudio theremin-like instrument you can play with in your browser.
What's a Theremin?
https://en.wikipedia.org/wiki/Theremin
MediaPipe Hand-Tracking Docs:
https://mediapipe.readthedocs.io/en/latest/solutions/hands.h...
Messy Source Code:
https://github.com/JohnVinyard/web-components/blob/main/comp...

value: Show HN: Theremin with MediaPipe and WebAudio

author: cochlear


value: A prototype of editor-agnostic real-time collaboration over Language Server Protocol

value: Show HN: Real-Time Collaboration over LSP


value: vednig

value: Show HN: DoShare Personal Cloud

author: vednig

title: Show HN: DoShare Personal Cloud


value: Show HN: Halo – Vision Headphones

title: Show HN: Halo – Vision Headphones


value: benbojangles

value: Something i'm working on as I really enjoy airsoft and having some thing like this in a darkened indoor maze arena would be cool!

value: Show HN: GhostDot – Airsoft Smart Red Dot HUD

author: benbojangles


value: iliasabs

value:
Hey HN, I’m Ilias, 19, from Paris.
I built Ellipticc Drive, an open-source cloud drive with true end-to-end encryption and post-quantum security, designed to be Dropbox-like in UX but with zero access to your data, even by the host.
What’s unique:
Free 10GB for every user, forever.
Open-source frontend (audit or self-host if you want)
Tech stack:
Frontend: Next.js
Crypto: WebCrypto (hashing) + Noble (core primitives)
Encryption: XChaCha20-Poly1305 (file chunks)
Key wrapping: Kyber (ML-KEM768)
Signing: Ed25519 + Dilithium2 (ML-DSA65)
Key derivation: Argon2id → Master Key → encrypts all keypairs & CEKs
Try it live: https://ellipticc.com
Frontend source: https://github.com/ellipticc/drive-frontend
Would love feedback from devs and security folks — particularly on encryption flow, architecture, or UX.
I’ll be around to answer every technical question in the comments!

value: Show HN: Ellipticc Drive – open-source cloud drive with E2E and PQ encryption

author: iliasabs


value: kfeeney

value:
We built a SIP user agent that registers to any PBX just like a soft-phone and streams audio to OpenAI’s real-time API.
No SIP trunking, call forwarding or unintegrated voice systems. Leilani behaves like a normal extension… because it’s just a normal SIP extension.
How it works
- Implements bog standard SIP over TCP to connect just like a normal desk phone or spftphone.
- Streams RTP (mu-law) bidirectionally to OpenAI’s realtime API
- Handles function calls for external actions (webhooks)
Use cases
- After-hours auto-attendant
- Voicemail/intent capture with structured output
- Internal system lookup (CRM, scheduling, ticket creation, etc.) via function calls
- Replaces IVR’s with natural conversation
Why?
Most AI voice systems expect you to hand over call routing, use their SIP trunk, or are an entirely separate voice stack all together. Every company (nearly) already has a SIP PBX, so we thought operating as a normal SIP extension was the simplest integration point.
Tech Stack
- The backend is built in asynchronous Rust.
- We connect to the realtime API using websockets rather than SIP trunking or WebRTC
- Hosted on a simple AWS EC2 instance
Limitations / gotchas
- Currently only supports SIP over TCP, we have TLS support coming soon
- There are some NAT traversal assumptions (we behave like a softphone)
- Latency depends on PBX and model RTT and audio frame sizes (currently seeing ~300ms across most deployments)
- You still need your own OpenAI key. Could be a positive or negative, depends how you look at it :)
Link
https://leilani.dev

value: Show HN: Leilani – SIP client that streams call audio to the OpenAI Realtime API

author: kfeeney


value:
I was sick of being bad at UI, so I built a tool to preview my mesh gradients on actual components before using them on my website.
The tool has several export options, several components, and potentially infinite combinations of gradients to test on components.
I'm still bad at UI though

value: Show HN: I built a tool to preview mesh gradients on UI components


value: hnarayanan

value: Show HN: Visualize branch relationships between open PRs in a GitHub repo

author: hnarayanan


value: josharsh

value: Convert Markdown to beautiful PDFs AND extract Markdown from PDFs using local AI. Features 4 themes, VS Code syntax highlighting, and LLaVA vision model. Zero config, privacy-first, completely open source. No cloud, no API costs.

value: Show HN: Md-pdf-md – Bidirectional Markdown<>PDF with local AI vision

author: josharsh


value: twilto

value: Show HN: Bash Script Lightweight Directory Bookmarks for the Terminal

author: twilto


value: wadamczyk

value: Show HN: ekoAcademic – Convert ArXiv papers to interactive podcasts

author: wadamczyk


value:
Socratic ingests sparse, unstructured source documents (docs, code, logs, etc.) and synthesizes them into compact, structured knowledge bases ready to plug into vertical agents.
Backstory: We built Socratic after struggling to compile and maintain domain knowledge when building our own agents. At first, gathering all the relevant context from scattered docs and code to give the agent a coherent understanding was tedious. And once the domain evolved (e.g. changing specs and docs), the process had to be repeated. Socratic started as an experiment to see if this process can be automated.
The Problem: Building effective vertical agents requires high-quality, up-to-date, domain-specific knowledge. This is typically curated manually by domain experts, which is slow, expensive, and creates a bottleneck every time the domain knowledge changes.
The Goal: Socratic aims to automate this process. Given a set of unstructured source documents, Socratic identify key concepts, study them, and synthesize the findings into prompts that can be dropped directly into your LLM agent’s context. This keeps your agent's knowledge up-to-date with minimal overhead.
How it works: Given a set of unstructured domain documents, Socratic runs a lightweight multi-agent pipeline that:
1. Identifies key domain concepts to research.
2. Synthesizes structured knowledge units for each concept.
3. Composes them into prompts directly usable in your vertical agent’s context.
Socratic is open source and still early-stage. We would love your thoughts/feedbacks!
Demo: https://youtu.be/BQv81sjv8Yo?si=r8xKQeFc8oL0QooV
Repo: https://github.com/kevins981/Socratic

value: Show HN: Socratic – Automated Knowledge Synthesis for Vertical LLM Agents


value: jomadu

value:
AI Resource Manager (V3) (FKA AI Rules Manager)
A package manager for AI rules and prompts with semantic versioning and automatic distribution to AI tools.
What is ARM?
ARM is a package manager for AI resources, designed to treat rulesets and promptsets as code dependencies. It introduces semantic versioning, reproducible installs, and straightforward distribution to your AI tools.
Seamlessly connect to Git repositories such as awesome-cursorrules or your team's private collections. Install and manage versioned resources across projects, and keep everything in sync with your source of truth.
Why ARM?
Managing rules and prompts for AI coding assistants like Cursor or Amazon Q is cumbersome:
- Manual duplication: Copying resources disconnects them from updates and the original source
- Hidden breaking changes: Updates may unexpectedly alter your AI's behavior
- Poor scalability: Coordinating resources across multiple projects becomes chaotic
- Incompatible formats: Frequent manual conversions between different tool formats.
ARM solves these problems with a modern package manager approach.
Key Features of ARM
- Consistent, versioned installs using semantic versioning (except for git based registry without semver tags, which gets a little funky)
- Reliable, reproducible environments through manifest and lock files (similar to npm's package.json and package-lock.json)
- Unified resource definitions that compile to formats needed by any AI tool (the audacity! clutches pearls)
- Priority-based rule composition for layering multiple rulesets with clear conflict resolution (your team's standards > internet best practices)
- Flexible registry support for managing resources from Git, GitLab, and Cloudsmith
- Automated update workflow: easily check for updates and apply them across projects (nice)

value: Show HN: AI Resource Manager

author: jomadu

title: Show HN: AI Resource Manager


value: dgl

value: In https://news.ycombinator.com/item?id=45755788 there was mention of an IRC server using gawk, but no code. So I wrote an IRCd in pure bash.

value: Show HN: IRCd in Pure Bash

author: dgl

title: Show HN: IRCd in Pure Bash


value:
We're two developers who got hit twice by LLM cost problems and built LangSpend to fix it.
First: We couldn't figure out which features in our SaaS were expensive to run or which customers were costing us the most.
Made it impossible to price properly or spot runaway costs.
Second: We burned 80% of our $1,000 AWS credits on Claude 4 (AWS Bedrock) in just 2 months while building prototypes of our idea but we had zero visibility into which experiments were eating the budget.
So we built LangSpend — a simple SDK that wraps your LLM calls and tracks costs per customer and per feature.
How it works:
- Wrap your LLM calls and tag them with customer/feature metadata.
- Dashboard shows you who's costing what in real-time
- Currently supports Node.js and Python SDKs
Still early days but solving our problem. Try it out and let me know if it helps you too.
- https://langspend.com
- Docs: https://langspend.com/docs
- Discord: https://discord.gg/Kh9RJ5td

value: Show HN: LangSpend – Track LLM costs by feature and customer (OpenAI/Anthropic)


value: alexlbuild

value: Show HN: I made Cellect – AI agent for spreadsheets

author: alexlbuild


value:
I built DeepShot, a machine learning model that predicts NBA games using rolling statistics, historical performance, and recent momentum — all visualized in a clean, interactive web app.
Unlike simple averages or betting odds, DeepShot uses Exponentially Weighted Moving Averages (EWMA) to capture recent form and momentum, highlighting the key statistical differences between teams so you can see why the model favors one side.
It’s powered by Python, XGBoost, Pandas, Scikit-learn, and NiceGUI, runs locally on any OS, and relies only on free, public data from Basketball Reference.
If you’re into sports analytics, machine learning, or just curious whether an algorithm can outsmart Vegas, check it out and let me know what you think:
 https://github.com/saccofrancesco/deepshot

value: Show HN: DeepShot – NBA game predictor with 70% accuracy using ML and stats


value: dkozyatinskiy

value: Show HN: RansomLeak – Free 3D interactive security awareness training

author: dkozyatinskiy


value: dividedcomet

value: I was running into the problem with opencode where I wanted to try a prompt against 5 different models at once, but didn't want to do the work to manage the worktrees and get things running in each instance. So I built up Kaleidoscope, a way to run multiple agents against a single problem, to make the AI slot machine a little easier to get better results out of.<p>It works best for problems that can be verified by inspecting a running result. It depends on opencode and tmux to do the heavy lifting of agent running and pane management, so it acts as more of the "turbo" for AI to get the result you want or to explore different possibilities.

value: Show HN: Kaleidoscope – A Parallel AI Agent TUI

author: dividedcomet


value: batterylake

value:
Hey everyone,
I built a small Chrome extension that automatically removes em dashes from ChatGPT responses. It uses a few regex rules to guess the appropriate replacement punctuation (usually commas or periods).
Goodbye AI slop!

value: Show HN: I stopped ChatGPT from using em dashes

author: batterylake


value: maxpert

value:
I wanted to see how far you can push AI coding without touching a single line of code. I asked an LLM to build a small to medium scale RabbitMQ alternative that is easy to run and easy to configure. The result is StrangeQ.
What it is
- An AMQP 0.9.1 message broker in Go that RabbitMQ clients can talk to
- Direct, fanout, topic, and headers exchanges
- Persistent and non persistent messages
- In memory or BadgerDB based disk storage
- SASL auth, transactions, Prometheus metrics
Why you might care
- Works with existing Go, Python, and Node AMQP clients with no code changes
- Single binary, minimal flags, or a short JSON config
- Quickstart shows hello world publishes in each language
How I built it with AI
- Scope. Pin to AMQP 0.9.1, RabbitMQ client compatibility, simple config, and metrics
- Protocol skeleton. Frame parsing, handshake, channels, basic flow control, and small state machines for exchanges and queues
- Storage. Start in memory for speed, add Badger for durability with a clean switch via flag or config
- Compatibility tests. Client snippets for Python, Node, and Go to sanity check behavior
- Operability. One command to start, systemd unit, Prometheus on a fixed port, simple logs
- Benchmarks. Microbenchmarks for publishes and declarations, keep only stable results
- Paper cuts. Iterate on auth, transactions, and helpful errors with sane defaults
- Roadmap. Short list in the repo tracks done and next
What still needs work
- Durability tuning
- More torture tests
- Richer metrics and dashboards
- More examples
Try it
- Clone the repo and build
- Start in memory for quick tests
- Or start with Badger for persistence
- Use the client examples to publish right away
Repo
https://github.com/maxpert/strangeq
I would love feedback on client compatibility and real workloads.
AIs used: Qwen (for maybe early 3-4 commits) too many timeouts and errors, so I decided to move to Claude

value: Show HN: I used AI to build StrangeQ, a RabbitMQ compatible message broker

author: maxpert


value: flashgordon

value:
I have been a devoted vim user for almost 3 decades and frankly it has served me well!  Yes I do get tempted to try out the next best thing (though Zed has some serious names so am even more tempted).   But frankly something about staying in the terminal that I am just too used to and dont want to change.   Though I never bothered updating the vimrc often (did 4 "major" updates in those years) I found myself wanting to update my vimrc for vimspector.
This time instead of again trying to understand vimscript and reading the various docs, I let claude code on it and dang it has been a fun journey with a surprising result.   It even helped me organize my vim configs.   Figured Id share it.  Nothing fancy but now atleast I am not afraid of setting up simple vim plugins/macros the way I want without worrying.
Let me know what yall think.  (Yes at some point i should consider the new toys like Zed but looks like I get to put that off for another couple of years now)!!

value: Show HN: A)I updated my vimrc

author: flashgordon

title: Show HN: A)I updated my vimrc


value: etherio

value: Show HN: Quibbler – A critic for your coding agent that learns what you want

author: etherio


value: Show HN: Font Finder – Find and copy fonts from any webpage


value: piratebroadcast

value:
I made this free macOS app and want to see what y'all think:
Simplify your AI assisted coding setup. Write one primary instruction file with 'Agent Smith' then easily export it to your Gemini, Claude, and Codex AI coding assistants.
Simplify your AI-assisted coding setup. Write one master instruction file with Agent Smith, then export it directly to your project root for your Gemini, Claude, and Codex AI coding assistants to read.
Agent Smith lets developers create unified configuration files for all their AI coding tools. Instead of maintaining multiple prompt templates or setup notes, you define a single “Master Instruction” file per project that standardizes your coding environment across assistants.

value: Show HN: Write one primary AI config file; Export it to all AI Coding Assistants

author: piratebroadcast


value: vivekjaiswal

value:
Hi HN ,
I’m Vivek Jaiswal, Founder & Technology Strategist at QBits Marketing Research.
We built TruthGuard, an AI-powered validation platform designed to detect synthetic, low-quality, or fraudulent survey responses in large-scale research datasets — a $10B+ issue in global data collection.
TruthGuard runs a multi-stage validation pipeline combining:
LLM-based semantic verification (OpenAI, Anthropic, Azure models)
Vector similarity scoring using Qdrant/Chroma
Anomaly & pattern detection for response duplication
Adaptive thresholding tuned with live dataset feedback
It processes 100K+ responses per day with 99%+ accuracy, cutting operational costs by over 60% for our enterprise clients.
I’d love to get feedback from this community — especially around:
Improving real-time validation at scale
Better approaches for prompt consistency between multiple LLMs
Efficient ways to benchmark accuracy on mixed human + AI datasets
Code architecture and system design overview (non-confidential parts) are here:
 github.com/vivekjaiswal-ai/truthguard
Thanks for reading — open to ideas, critiques, and collaborations!
— Vivek

value: Show HN: TruthGuard – AI System That Detects Invalid Survey Responses

author: vivekjaiswal


value: Yeh I was bored waiting for something to deploy and this is 99% AI well the HTML is the ISM i scraped as chatgpt makes up its own ISM controls I will blind merge any changes submitted as a PR https://github.com/elmobp/ism-quiz happy friday!

value: Show HN: Fun Friday Australia ISM Quiz;)


value: stackws

value:
Reggi.net is an AI-powered domain assistant that helps creators, entrepreneurs, and businesses find and register the perfect domain name in seconds.
Just describe your idea — Reggi understands your concept, tone, and style — then instantly generates creative, brand-ready domain ideas with live availability checks.
Built for startups, agencies, and dreamers alike, Reggi combines AI-driven brainstorming, real-time domain availability, and instant registration under one clean, modern interface.
Domains registered through Reggi default to ns1.reggi.net / ns2.reggi.net, giving every customer a professional landing page and easy access to custom DNS management.
Whether you’re launching your first business or building your tenth brand, Reggi makes naming simple, smart, and fun — all powered by the latest AI technology.

value: Show HN: Reggi.net your AI domain companion

author: stackws


value: josevalerio

value: I made this little logger because logging JSON without escaped strings seemed really unintuitive.<p>I hope you find it useful!

value: Show HN: sjl – Simple JSON Logger for Rust

author: josevalerio


value: owoamier

value:
Hi everyone,
I built NatChecker
 – a free online tool that helps users easily check their network’s NAT type with one click, no login or setup required.
Many gamers and developers who use peer-to-peer (P2P) networking need to know their NAT type — for example, when hosting multiplayer games or running PCDN (peer-to-peer content delivery).
A good NAT type (like Full Cone / NAT1 / NAT2) makes it easier to connect or host, while stricter types (Symmetric / NAT3) can block connections.
The tool runs entirely in your browser using WebRTC and public STUN servers, without collecting any data or requiring an account.
My goal was to make NAT detection simple, private, and instant.
Feedback and suggestions are very welcome — especially if you have ideas to make the detection more accurate or faster!

value: Show HN: NatChecker – free online NAT type detector (no login, one click)

author: owoamier


value: sinharishabh

value:
I’ve been working on this over the past few months after getting frustrated with how fragmented hardware workflows can be - switching between code editors, terminals, and toolchains.
Embedr is an AI-native IDE for Arduino and other hardware ecosystems. It helps you code, build, and flash your projects while integrating tightly with the underlying toolchains like the Arduino CLI. The goal is to make hardware development feel as seamless as modern software IDEs.
A key feature is the Embedr Agent, which works like Claude Code inside the IDE. You can describe what you want to build in natural language, and it assists with code generation, debugging, and project setup directly in your workspace.
Current version includes:
- Arduino CLI integration with board detection and flashing
- Embedr Agent for AI-assisted development
- Built-in terminal and serial monitor
- Extensible plugin system for other toolchains (ESP-IDF, STM32, Raspberry Pi, etc.)
You can try it here: https://embedr.app
Still early, and I’d love to get feedback from folks who work with Arduino or embedded systems - what’s missing, what could be better, or what would make this truly useful day-to-day.

value: Show HN: Embedr – The AI-Native Arduino IDE

author: sinharishabh


value: kangfeibo

value: Show HN: PS2 Emulator – Play your favorite PlayStation 2 games on your computer

author: kangfeibo


value:
We built Sentient to automatically extract themes and sentiment from customer feedback without manual configuration. The system processes documents in sub-second time while maintaining 95% accuracy.
Built with Next.js 14 and FastAPI, using fine-tuned OpenAI models trained on millions of feedback examples. Key features include automatic customer segmentation, multi-format support (PDF, DOCX, CSV), and real-time processing.
The core insight: most tools analyze individual reviews instead of understanding customer journeys and behavioral patterns. Sentient connects feedback sentiment to business outcomes through multi-phase AI analysis.
Technical approach uses theme detection, emotion recognition, and intelligent caching for enterprise-grade performance.
Try it at: https://data-decoder.vercel.app/

value: Show HN: Sentient – AI-powered customer feedback analysis with 95% accuracy


value: setrf

value:
Hey HN,
I built Hot or Slop (https://hotorslop.com) - a visual Turing test where you swipe through photos and guess if they're AI-generated or real. It's part game, part crowd-sourced research experiment.
After 50 players and ~3,600 guesses, the early data is fascinating:
* Average human accuracy: 65% (barely better than random)
* Top performers hit 85–90% accuracy
* FLUX and Imagen models fool people 80%+ of the time
* Speed matters - rushed guesses drop accuracy ~15%
Every guess feeds a transparent dataset tracking which AI models are hardest to detect and how our collective detection abilities evolve as models improve. Think of it as real-time measurement of the human-AI perception gap.
Tech stack: React 19 + Vite (frontend), Express + SQLite via sql.js (backend), Hugging Face datasets (OpenFake for synthetic images, COCO–Caption2017 for real photos). The game tracks ~15 metadata points per guess (model, prompt length, latency, confidence, etc.) for analysis.
Current challenge: sql.js loads the entire DB into memory, so I'm hitting memory limits at ~3,600 guesses. Planning to migrate to better-sqlite3 or Postgres for scale, but wanted to ship fast and iterate based on usage patterns.
The visual indicators during swipes use gradient overlays (red for AI, green for real) with EB Garamond typography for a clean aesthetic. Simple but effective UX - most people play 50+ rounds in their first session.
Curious to hear:
1. What accuracy do HN folks hit? (I suspect higher than average)
2. Any ideas on detection patterns? Some claim texture/lighting tells, others focus on compositional "tells"
3. Thoughts on scaling the analytics without moving to a full DB service?
Try it: https://hotorslop.com
(Fair warning: weirdly addictive)

value: Show HN: Hot or Slop – Visual Turing test on how well humans detect AI images

author: setrf


value: felipe-pathwave

value:
Hi, I’m Felipe. I've built this tool to manually approve or deny AI actions in real time.
It’s an MCP server connected to a mobile app, available on Android and iOS.
MCP URL: https://mcp.pathwave.io/http-stream
Example prompt:
"please ask confirmation via pathwave using userSid [ADD YOUR USER SID HERE]
ask with message 'do you love me?'
if yes, draw an ascii heart otherwise draw an ascii sad face"
Docs and quickstart: https://web.pathwave.io/docs
Thanks

value: Show HN: Approve your AI agent's actions on the go

author: felipe-pathwave


value: Show HN: Thought Engineering

title: Show HN: Thought Engineering


value:
When my wife and I bought our first home in 2020, it was peak COVID. Our agent actually asked us to waive the home inspection, which was terrifying. I ended up walking through the house myself with a set of handwritten notes: “check if Kitchen outlets are GFI,” “make sure toilet flushes”, “test the bath fan”, etc.
That experience became the seed for Dwellable, a home maintenance and inspection app for homeowners like us who didn’t know where to start (both before and after buying).
The app automatically pulls your property records (square footage, year built, fuel type, etc.) and uses AI to recommend reminders and seasonal maintenance tasks. It’s free right now, built entirely native on iOS and Android.
On the side, I’ve been experimenting with VLMs (vision language models) to analyze photos that users take during inspections, for things like spotting corrosion or damaged caulking.
If you’ve ever felt lost after closing on a house, this might resonate.
Tech stack:
- Backend: Python + gRPC, RabbitMQ
- AI: Perplexity + OpenAI
- iOS: SwiftUI
- Android: Fully compose
Would love feedback!

value: Show HN: Dwellable – The app I built after waiving home inspection during Covid


value: tatefinn

value: Show HN: Pinshell – Wallpaper Previewer Based on Pinterest, Unsplash, Pexels

author: tatefinn


value: MemoV is a traceable memory for vibe coding. memov = prompt + ai plan + codediff. Based on it, we support vibe debugging in context.

value: Show HN: Open Aardvark, vibe debugging in traceable context


value:
If you’re into Roblox tower defense or anime-themed games, Anime Last Stand (ALS) is a must-play—and Anime Last Stand Wiki is your shortcut to mastering it.
Built by real players (500+ hours tested, no AI fluff), it cuts to what fans need:
Daily Verified Codes: Grab active rewards like NewHeights (1000 Rerolls + Title) or SlimeGodly! (100 Rerolls + Pearls) – no expired duds.
Tested Guides: Beginner tips, meta team comps, and deep dives into Update 73 (Godly Rimuru, Halloween Part 2).
Reliable Stats: 40+ unit tier list, 30+ character database (even Godly Rimuru’s 0.03% drop rate), and exact status effect damage.
No fluff—just what you need to crush waves, climb leaderboards, and get rare units. Check it out:https://animelaststand.net/

value: Show HN: Anime Last Stand Wiki – The Go-To for Roblox's Anime TD Hit


value: Panzerschrek

value:
Hello, HN!
Today I want to show my project: a programming language named Ü.
For many years I has been using C++ for coding - both at my job and for hobby projects. C++ is mostly fine for me, since it delivers great performance and powerful abstractions. But C++ had and has many footguns, which make using it sometimes painful. So I thought a better programming language could exist, which can have many advantages of C++ without its downsides. Especially I wanted safety by-default, so that shooting the leg is hard, but without unnecessary overengineering. After a brief search I found no other language fully satisfying my requirements and thus I decided to create one myself.
Developing a new programming language wasn't fast and easy, but after many years of development I have managed to do this and created a language, which satisfies my requirements. I think it's now ready for a wide audience.
Ü is a general-purpose programming language designed to be safe and fast and it achieves these goals. Surprisingly achieving both doesn't require insanely complex language design and compiler implementation. Static typing in combination with clever compile-time analysis and safe/unsafe code separation allow achieving safety. Compilation into machine code (with help of LLVM) provides enough speed. Also Ü just doesn't do much in runtime which could slow-down its performance - most of the safety checks are done in compile-time and destructor-based memory and resources management requires no runtime penalty typical for languages with garbage collection.
Ü isn't just a better C with a couple of bells and whistles. It's pretty feature-reach, much like C++ is. These features include classes, inheritance, type and function templates, lambdas, coroutines, compile-time reflection and possibilities of compile-time code generation.
Ü uses curly braces-style syntax, but it doesn't try to copy all syntax elements of some particular language. There are keywords and syntax elements borrowed from C++, Rust or whatever else. Despite this most syntax rules should be pretty familiar for users of mainstream programming languages.
I have developed and continue developing two compilers for Ü - one written in C++ and another one written in Ü itself (specifically frontends, both use LLVM backend written in C++). Besides that Ü has many other components like its own standard library, a build system, a language server, a tool for C headers conversion, etc.
I believe that the language is ready to be used for writing some real code. Having a self-hosted compiler and many other components written in it should prove this claim to be true. Ü maybe isn't ready for very reliable industrial code doing serious stuff (like OS kernels or banking software), but it should be fine to use it for things like hobby projects.
See examples (https://github.com/Panzerschrek/U-00DC-Sprache/tree/master/s...) to get a general idea what Ü is and how it looks like and feels. Read the documentation (https://panzerschrek.github.io/U-00DC-Sprache-site/docs/en/c...) for more details. If you have some questions about the specific mechanism providing safety, read the corresponding chapter (https://panzerschrek.github.io/U-00DC-Sprache-site/docs/en/r...). If some topic isn't clear for you after reading the documentation, contact me and I can answer your questions.
You may ask, why have I named my language Ü? The answer is simple: I wanted a single-letter name, but all regular Latin letters were already used (https://beza1e1.tuxen.de/one_letter_proglangs.html). So I chose a letter, which belongs to extended Latin alphabet and is pretty common in many natural languages (like German).

value: Show HN: Ü Programming Language

author: Panzerschrek

title: Show HN: Ü Programming Language


value: martintrif

value:
I've been working on a small 2D graphics framework for the web and just put a first prototype online.  It aims to make authoring graphics pipelines easier without hiding how the GPU actually works.
The core idea: you write your renderer as a function that returns a RenderGraph - a graph of resources (textures, buffers, etc) that describes how data flows through the GPU. The engine maps your graph to physical resources on the GPU in an optimised way.
The value proposition: For beginners, it could serve as a gentle onramp into GPU programming. For experienced developers, it could be a fast prototyping tool for experimentation.
I'm curious whether people see potential in a framework like this. I'd be very grateful to hear your thoughts!

value: Show HN: Render-graph-based 2D graphics framework for the web

author: martintrif


value: ihsanf

value:
I know it sounds silly, that's why I really want to find out do people also have such problem and how many.
problem: Before bed, I want to unload my thoughts, bounce back ideas, and talk to AI without screens. Right now I dim my laptop and balance it half-closed so it doesn’t fall. Phones require screens and don’t hear whispers. Headsets are uncomfortable. There’s no calm, screen-free AI experience for nighttime thinking.
solution: screenless cube companion with whispers microphone that you can place beside your pillow/desk, sync with your smartphone, and good speaker. Price at maybe 100$ USD. Are you willing to pay?

value: Show HN: Screenless Companion

author: ihsanf

title: Show HN: Screenless Companion


value: chaboud

value: Show HN: I didn't make a costume, so I had AI do it

author: chaboud


value: danielfulop

value: The rendering is 100% done with the WebCodecs API, so it runs completely on the frontend. I was using WXT as a chrome extension development framework and MediaBunny for a wrapper above WebCodecs and I absolutely recommend both of them. Saved me a ton of time.

value: Show HN: Zumie – a screen recorder Chrome extension with auto-zoom

author: danielfulop


value: omojo

value: Show HN: Forge – Turn ideas into prompts that deliver working MVPs on first try

author: omojo


value: bruinmeister

value:
I've built a tool that performs semantic analysis on Python code to detect inconsistencies between function intent and actual implementation.
What it does:
The tool analyzes your Python functions and identifies cases where:
- Function names/documentation promise one type of operation
- The actual code implementation does something different
- There's a semantic gap between stated purpose and execution
How it works:
1. Parses Python AST to extract function names, docstrings, and implementation logic
2. Uses semantic analysis to map both intent and execution to conceptual spaces
3. Measures the distance between these spaces to flag significant mismatches
4. Generates a report showing which functions have the largest intent-execution gaps
Example findings:
- A function named `calculate_score()` that actually just fetches cached values
- A `validate_input()` function that secretly sends analytics data
- A `update_user_prefs()` function that uses destructive delete/recreate patterns
What else it provides:
Team collaboration benefits:
- Objective metrics for code review discussions
- Clear evidence when renaming functions or refactoring
- Shared vocabulary for discussing code quality beyond "this feels wrong"
Code quality trending:
- Track semantic consistency across versions
- Measure improvement after refactoring efforts
- Identify areas where documentation needs updating
Architectural insights:
- Spot patterns where certain concepts are consistently misrepresented
- Identify modules with high semantic confusion density
- Find where your codebase's actual architecture diverges from intended design
Integration ready:
- Simple CLI output for CI/CD pipelines
- Machine-readable results for custom reporting
- Extensible framework for adding new semantic rules

value: Show HN: Python Code Harmonizer – Semantic analysis for clean maintainable code

author: bruinmeister


value: daviducolo

value: Show HN: A fast, dependency-free traceroute implementation in pure C

author: daviducolo


value: starboat

value: Show HN: Face GPT: AI Face Swap, Analyzer and Analysis

author: starboat


value: emanuilv

value: Show HN: 2 Days Left

author: emanuilv

title: Show HN: 2 Days Left


value: imprisonedmind

value: skuld uses wakatime plus git history and a couple CLI commands in order to update Jira worklogs and status for you.

value: Show HN: I made a CLI tool to update Jira issues

author: imprisonedmind


value: madebydon

value: Build visibility, track momentum, and earn trust — go beyond collecting emails with real-time social proof, referral growth, and prelaunch SEO.

value: Show HN:I am making forms fun again.  "form → insights → conversions."

author: madebydon


value: sideshowb

value: I've been making an experimental browser game on the topic of conspiracy beliefs and how they arise - would love to know what you think :) The underlying model is a belief network, though for the purpose of gameplay not strictly Bayesian. Your goal is to convince the main character the world is ruled by lizards.<p>(Full disclosure: Although I’m only here to test the game, I’m doing so as an academic researcher so have to tell you that I may write a summary of responses, and record clicks, as anyone else testing a game would. I won’t record usernames or quote anyone directly. If you're not ok with that, please say so, otherwise commenting necessarily implies you consent. Full details linked from the title screen.)

value: Show HN: Browser puzzle game, try to convince NPC the world is ruled by lizards

author: sideshowb


value: bwm

value: Show HN: Reusable MCP Playbooks for AI Agents

author: bwm


value: colo-colo

value:
I built an MCP server that lets Claude (and other AI assistants) fetch and summarize tech news.
It aggregates 20+ feeds including Hacker News, GitHub Trending, Techmeme, Reddit /r/technology, and more. When you ask Claude to "fetch latest news", it pulls all articles, extracts key topics, and generates summaries organized by feed.
The server is built with Next.js and uses the xmcp framework. You can run it locally or use the hosted version at https://infomate.online/mcp
Demo: Just ask Claude "fetch latest news" and get summaries like:

  - TypeScript overtook Python on GitHub
  - Reddit Q3 revenue up 68% YoY
  - OpenAI announced Aardvark security researcher
  - SpaceX Moon missions update

Source: https://github.com/agudulin/infomate-mcp

value: Show HN: MCP Server That Brings Hacker News, GitHub, and Reddit to Claude

author: colo-colo


value:
I built Cuiz-AI to generate practice quizzes from PDFs, Word docs, and PowerPoints using AI.
The name is a play on "Quiz" + "Cuis",  a small rodent from Argentina, where I'm from. That's why the logo is a little rodent.
The tricky part: Getting an LLM to generate quality quizzes fast was quite hard. I spent a lot of time testing different models and approaches to get the generation time down from minutes to seconds.
You upload a document, the LLM reads it and generates multiple choice questions with explanations. It also tracks your quiz history and progress.
Would love feedback, especially on use cases I might not have thought of and in the quality of the questions!
https://www.cuiz-ai.com/
thank you!

value: Show HN: I built Cuiz-AI, turns documents into quizzes in seconds


value: Pavlinbg

value: Link to the map: https://sofiamap.vercel.app/

value: Show HN: I Built a Real-Time Transit Map for Sofia Using Open GTFS Data

author: Pavlinbg


value: Show HN: Product analytics with zero instrumentation (using vision models)


value: epistemovault

value: Show HN: Text Generator – online font generator

author: epistemovault


value: kokau

value:
Hi HN
I built a tool to automate the long-form → short-form workflow for video creators.
Features
Highlights detection in long videos
Automatic clipping into short vertical formats
Subtitle automation with motion/modern styling
Optional AI video generation (NanoBanana, Veo-3)
AI voice + image tools for creative content
Target users
YouTubers
Streamers
Podcasters
Short-form editors
Media operators
Link: https://magiclip.io
Feedback appreciated — especially on UX, workflow assumptions, and opportunities to improve. Happy to discuss technical/design decisions.

value: Show HN: Magiclip – AI that turns long videos into short clips

author: kokau


value: Show HN: A simple drag and drop tool to document and label fuse boxes


value:
I build a skype clone, where you can make international calls via browser.
Skype was my go to app for that, but since they shut it down, decided to build my own. Its perfect for calling international customer support, or any other gov numbers.
Its pay-as-you-go - so no subscription charges, very transparent pricing. You can just top up $5 and see pricing in real time during the call.

value: Show HN: I build a cheap Skype Clone

title: Show HN: I build a cheap Skype Clone


value: siegers

value: No-code Automations are visual workflows that automatically extract, process, and save data from websites to your Google Sheets.

value: Show HN: Add to Sheets Chrome Extension for Google Sheets – No Code Automations

author: siegers


value: jochesch

value:
I built an open source tool called TreeHouse for flattening SAP hierarchies (i.e. tree structures) for data warehouse / lakehouse use cases.
This is particularly help when migrating from SAP's data stack (BW, Datasphere, etc. which have prepacked hierarchy models and ETL) to something like Snowflake, where all ETL and data models have to be built from scratch.
GitHub (MIT-licensed): https://github.com/jchesch/sap-hierarchy-flattener

value: Show HN: SAP hierarchy flattener (open source)

author: jochesch


value: SandraBucky

value:
Hi HN!
I believe people here are somewhat familiar with Iroh - the p2p networking library.   It does Hole-punching and make use of QUIC connections between endpoints to enable peer-to-peer connectivity
https://www.iroh.computer
https://news.ycombinator.com/item?id=44379173
https://news.ycombinator.com/item?id=4572755
Easiest way to make use of Iroh is through their in-house file transfer CLI tool called sendme
https://www.iroh.computer/sendme
Sendme uses iroh to establish direct links between devices for data transfer, and iroh-blobs to send and verify your files
Features:
- Free, for files & folders of any size
- No account requirement
- No server component
-  Fast - can saturate a 4Gbps connection.
-  Resumable fetching - Interrupted downloads pick up where they left off.
- Integrity checks - Data is automatically verified for correctness on both send and receive.
What I have built is something that complements sendme, Started with their CLI tool fork, made it into a Tauri desktop application with very simple  but modern UI (yes, I have read https://news.ycombinator.com/item?id=45760878, coincidence I guess)
Altsendme has almost all the features that sendme offers plus it is interoperable with sendme CLI tool.
Thank you.

value: Show HN: AltSendme – Open-source p2p file transfer tool based on Iroh

author: SandraBucky


value: tobilg

value: Show HN: Run SQL queries directly on your website

author: tobilg


value: aurintex

value: Show HN: A Manifesto for a Privacy-First, Open Core AI Wearable (GitHub)

author: aurintex


value: rokontech

value: We automate your guilt away.

value: Show HN: Middlerok – Auto-Writes Tests So You Can Keep Lying About 100% Coverage

author: rokontech

story_text: We automate your guilt away.


value: whitelotusapp

value:
Hey HN
I’m Arun, a 17-year-old developer from India. I built WhiteLotus, a new kind of social platform focused entirely on authentic human connection.
Every user is AI face-verified — so there are no bots, no fake profiles, and only one account per person.
Core Features:
Face-verified signups only — no spam or fake accounts
1-on-1 private chats with approved friends
Photo-based posting — keep it visual and real
“Kingdoms” (Fire, Water, Earth, Air) — social tribes that compete weekly
“Moments” — instant camera-only posts (no uploads, no filters)
My mission is to build a space where people connect authentically, grow social trust, and have fun — without the noise of bots or fake personas.
I built it with Flutter (frontend) and Django (backend).
It’s live on the Play Store: [Play Store link here]
I’d love your feedback on:
How to improve engagement and retention
Any product or UX suggestions
Thoughts on the “real people only” concept
Thanks for reading — I’m trying to learn, iterate, and build something meaningful.
— Arun

value: Show HN: I'm 17, built a face-verified social network to fight fake accounts

author: whitelotusapp


value:
A minimal, clean speech-to-text menu bar application for macOS, consisting of approximately 300 lines of code, utilizes OpenAI's Whisper. Hold the Option key to record and release it to transcribe. The transcribed text is automatically copied to the clipboard. I plan to enhance it with LLM improvements based on an Ollama server. What do you think?
I was inspired by this Raycast Extension:
https://www.raycast.com/finjo/whisper-dictation

value: Show HN: Whisper Menu Bar – a push-to-talk transcription script


value: loopletter-max

value:
Hi, I started building Loopletter, an open-source email marketing platform built
  specifically for independent artists and creators. I've been using this for a while to run marketing campaigns for my own company. But due to the lack of time to update it i've decided to open it up under the MIT license so other people and industries can self-host, extend, or just learn from the codebase.

  What’s inside:
  - Full campaign builder (visual editor, reusable templates, optional Spotify-powered layouts)
  - Audience management tooling (imports, segmentation, consent workflows, list cleanup)
  - Queue-driven sending with AWS SES, BullMQ, and Redis — handles rate limits, retries, and
  deliverability feedback
  - Analytics dashboards with real-time metrics, campaign history, and basic attribution
  - Infrastructure scripts for Supabase, AWS EventBridge/Lambda, and Upstash Redis so you can set
  everything up from scratch

  Tech stack: Next.js, React 19, TypeScript, Tailwind, Clerk for auth, Supabase (Postgres)
  for storage, AWS SES + S3 for mail/asset delivery. The repo has docs, scripts, and a demo data
  sandbox because we know email platforms can be boring to set up without real content.

  Why open-source? Most tools in this space are either huge enterprise SaaS products or
  very marketing/sales oriented. Independent artists have different needs (merch drops, tour
  announcements, limited release windows) and usually lean on social platforms they don’t control.
  Email still converts best for them, but standing up a full stack is painful. We’d love to see
  small labels, agencies, and indie devs fork it, run it for their communities, or contribute
  features.

  I'm especially curious if this has potential to be something bigger.

  Repo link: https://github.com/createdbymax/Loopletter-Open-source-email-marketing-platform
  Production website: https://loopletter.co/

  Happy to answer questions about the project, SES deliverability, or anything else related to
  running email at indie scale. Thanks for taking a look!

value: Show HN: Loopletter: Open-source email marketing platform

author: loopletter-max


value: brgross

value:
Hi HN — Bracket City is the word puzzle game I made earlier this year and (in part thanks to this community, see https://news.ycombinator.com/item?id=43622719) managed to license to the Atlantic in April.
The game has been growing a lot and I wanted to share the latest: a tool that lets anyone make a Bracket City puzzle — specifically a “Bracket Suburb”!
I made this tool to help me construct puzzles, and I’ve been using it every day for months.
After the Atlantic launch, I started to get the occasional inquiry about whether there was a way to make your own puzzle. One guy wanted to make a Bracket City puzzle part of a puzzle hunt he made to propose to his girlfriend (he did it!), and that convinced me it would be fun to make something publicly available.
I got the Atlantic on board with the idea, and we are launching it today with an "example" custom puzzle: a Halloween/horror-themed puzzle by my pal Wyna Liu of NYT Connections fame.
https://suburbs.bracket.city/wyna
And we've got few other fun "celeb" puzzles lined up for later this year.
The thought is that folks can use the builder to make custom puzzles for birthday wishes/event invites/insults/proposals/break ups in addition to “normal” Bracket City puzzles.
I'm also hoping to learn more about the potential of the format – crossword puzzles have benefited so much from the creativity of constructors – I'm hoping bracket puzzles do the same.
The good news is that it’s way easier to construct a bracket puzzle than a crossword. Once you try it, you’ll see why: you have many more degrees of freedom. In a crossword, each added word increases the level of constraint exponentially — every new entry sharply reduces the remaining options for completing the grid. Bracket puzzles are the opposite: as you add clues, you expand the available fodder for new ones.
Anyway, I would love any/all feedback and to try puzzles created by folks here. I’m hoping we will figure out a way to highlight the best community puzzles on the Atlantic soon!
PS and please keep playing the main game / sending me feedback / denouncing me on the subreddit

value: Show HN: Build your own Bracket City puzzle

author: brgross


value: SiliconGen

value: Show HN: Magic Animal Generator – create realistic hybrids of any two animals

author: SiliconGen


value: codelemons

value: Show HN: Fed Market Watch – Live FOMC Odds from CME, Kalshi, and Polymarket

author: codelemons


value:
I built VoiceBrief (https://voicebrief.io) to solve my own problem: 2-hour daily commute during college with no way to study on a crowded train.

  Upload a PDF → Get two audio formats:
  - 10-min summary narration
  - 1+ hour professor-style deep dive

  Plus: real-time text highlighting, bookmarks, AI quizzes with spaced repetition.

  Tech: React/Express/PostgreSQL, OpenAI GPT-4 + TTS-1-HD, Railway hosting.

  Main challenge: TTS costs ~$2-3 per 50-page PDF. Looking for cost optimization strategies.

  Free tier: 3 PDFs. Bootstrapped, ~500 users, no VC funding.

  Would love feedback on pricing ($9.99/mo Pro?) and TTS alternatives!

value: Show HN: VoiceBrief – Turn textbooks into 1-hour audio lectures with AI


value:
I built a browser extension that adds AI code reviews directly to Azure DevOps Pull Request pages. No copying code, no switching tabs.
The problem: I was constantly switching between Azure DevOps and external AI tools for code reviews. Copying code blocks, losing context, breaking flow.
The solution: An extension that adds an "AI Review" button directly on PR pages. It uses Azure DevOps Git APIs to fetch actual code diffs and provides instant reviews right where you're working. Works with both dev.azure.com and visualstudio.com URL formats.
Key features:
- Zero context switching - everything happens in-browser
- Persists during SPA navigation
- Uses Git APIs for accurate code analysis
- Simple setup (just add PAT token)
Demo: https://thinkreview.dev/media/thinkreview-azure-devops-full....
I've been using it for a few weeks and it's saved me significant time. Would love feedback from other Azure DevOps users:
- Does this solve a real problem for you?
- What features would make it more useful?
- Any Azure DevOps-specific quirks I should be aware of?
Available: https://chromewebstore.google.com/detail/thinkreview-ai-code...
More details: https://thinkreview.dev/blog/i-built-an-ai-code-review-tool-...

value: Show HN: AI Code Reviews Directly in Azure DevOps (No Context Switching)


value: SinghCoder

value:
Hey HN - founder here. I'm building Qordinate with a simple (big) idea:
Most AI assistants talk to you. I want one that talks for you - one that can share, negotiate, and coordinate on my behalf with others.
Reality: we're early. Today, Qordinate can:
- send clean pings on your behalf (with your approval)
- collect info/files via tiny forms and track replies
- nudge people politely and close the loop with you
- do basic actions via connectors (Gmail/Calendar/GitHub/Linear/Drive/Slack)
- keep lightweight lists in chat (tasks, contacts, logs)
Why I'm doing this
The real pain isn't knowing what to do, it's getting others to do their part. Coordination is the tax. I want to cut that.
Where I'm unsure
- how far "talks for you" should go before it's annoying or risky
- what approval flow feels safe but not heavy
- which coordination templates (collect docs, pick a time, chase invoices, etc) you'd actually use
Roadmap
- better multi-party scheduling
If you're curious:
- https://qordinate.ai/
I know less than many of you here. Happy to be told what's dumb, missing, or risky.

value: Show HN: Qordinate – AI that talks for you (coordination-first, early build)

author: SinghCoder


value: selmetwa

value:
One thing that always frustrated me as an Arabic learning was how difficult textbooks are to use. You’re constantly flipping to the end to check translations or transliterations, which completely kills your focus.
So I started building an open-source platform that fixes this with interactive parallel texts, you can click or drag over any Arabic word to instantly see its meaning, transliteration, and grammar notes in context. It’s like reading a bilingual book that actually flows.
The platform also includes AI-generated stories and sentences, letting learners practice Arabic in natural, evolving contexts instead of static textbook examples. All content comes with accompanied dialect-specific audio.
Most resources focus only on Modern Standard Arabic, but that’s not what most people actually speak. There’s very little for dialects like Egyptian and Moroccan Arabic. To fill that gap, I leverages custom LLMs trained specifically on Egyptian and Moroccan dialects, since general-purpose models (like ChatGPT) often struggle with dialect-specific content.
If you’re interested in Arabic, dialects, or open-source edtech, I’d love your feedback (and maybe collaborators).

value: Show HN: I'm building an open source platform for studying Arabic

author: selmetwa


value:
Hi HN,
This is something I originally built for my students when I was teaching logic at the University of Buenos Aires (I have now moved to philosophy of science).
I had planned to add some commercial features like paid courses — and even developed a good part of it — but I got caught up in other projects (plus, it didn’t seem particularly profitable), so it’s been sitting idle for a few years.
I figured I'd finally share it to see what reaction I get, if any, and whether there's any interest in me adding that kind of functionality.
PS. TAUT is based on my open-source logics library (https://github.com/ariroffe/logics), which runs in the browser via Pyodide. The site is currently hosted on a $5 VPS, so hopefully it won’t get hugged to death.

value: Show HN: TAUT2 – Mathematical logic exercises in the browser


value: DatMule

value: Show HN: Molecular/Waveform Computing Unification

author: DatMule


value:
In modern document question answering (QA) systems, Optical Character Recognition (OCR) serves an important role by converting PDF pages into text that can be processed by Large Language Models (LLMs). The resulting text can provide contextual input that enables LLMs to perform question answering over document content.
Traditional OCR systems typically use a two-stage process that first detects the layout of a PDF — dividing it into text, tables, and images — and then recognizes and converts these elements into plain text. With the rise of vision-language models (VLMs) (such as Qwen-VL and GPT-4.1), new end-to-end OCR models like DeepSeek-OCR have emerged. These models jointly understand visual and textual information, enabling direct interpretation of PDFs without an explicit layout detection step.
However, this paradigm shift raises an important question:
> If a VLM can already process both the document images and the query to produce an answer directly, do we still need the intermediate OCR step?
We build a practical implementation of a vision-based question-answering system for long documents, without relying on OCR. Specifically, we adopt a reasoning-based retrieval layer and the multimodal GPT-4.1 as the VLM for visual reasoning and answer generation.

value: Show HN: Vision-Based, Vectorless RAG for Long Douments


value: akshaysg

value: I originally made this to occupy time while folks were waiting for their reviews to spin up, but thought it would be fun to release as a game for Halloween!<p>Let me know if I need to make any balance tweaks or fixes, and I'd be happy to do so!

value: Show HN: Code Review Survivors – a roguelike where you merge a 1000-line PR

author: akshaysg


value: amukbils

value: Open-source email validation full stack app tested on production with hundreds of thousands of signups  a month.<p>We were using third party providers for a long time but ultimately decided to switch away because they required tiered pricing and we were always underutilizing. So opening this up to help anyone who wants to host their own version.

value: Show HN: Open-source email JavaScript validation

author: amukbils


value: imilev

value:
Hey all,
Me and my friends building CodeBoarding, an easy way to visualize and understand your codebase.
Cursor 2.0 showed how now you can drag context for your agent directly from the UI, I think this is awesome way to interact with generated code, as you don' really need to understand all details for a vibe coding session.
This is why we've been building CodeBoarding - visualizing your codebase with a diagram so you can quickly understand and navigate the codebase. Now you can just copy a component and paste it as context for your agent so it knows where to work. The analysis agent for the diagram creation is open-source you can find it here: https://github.com/CodeBoarding/CodeBoarding
I would love to hear your opinion on vibe coding for larger projects, how do you navigate the context selection? Further what kind of guardlines are you using, we are thinking of adding guardrail which makes most of the files readonly so your agent (cursor, claude code, etc.) cannot delete/edit them.
Looking forward to chatting with you all,
Ivan

value: Show HN: Building the Cursor UI selector but for back end

author: imilev


value: satuke

value: Show HN: NodeBook – Node.js Notebooks

author: satuke

title: Show HN: NodeBook – Node.js Notebooks


value: Judy-witch

value:
How I Built My Own Tech Radar (BuzzScope): From Data Streams to Daily Insight
As a technology evangelist, I’m always looking for better ways to keep up with what’s happening in tech.
So I built a small system — BuzzScope, my personal tech radar.
It currently has 3 key functions:
1⃣ Historical Insight:
Search any keyword, and BuzzScope finds the most popular posts and active contributors from multiple platforms (Hacker News, Reddit, YouTube, and even selected Discord servers).
Behind the scenes, historical data from HN and Discord are archived in Parquet format, which allows columnar access and faster queries across millions of records. Reddit and YouTube, on the other hand, are fetched on demand for real-time trending results.
2⃣ Daily Pulse:
It automatically gathers trending posts from the past 24 hours (based on thresholds) and sends them to my inbox — quick and actionable.
3⃣ AI Analysis & Re-distribution:
Then, multiple LLM agents collaboratively analyze the results to detect short-term trends and even generate tailored repost content for different platforms.
Each agent works in parallel rounds — seeing global context but only refining its own results — until the network “converges.”
The outcome?
I now get a living snapshot of the tech landscape every morning

value: Show HN: BuzzScope – A Tech Radar for Engineers [video]

author: Judy-witch


value: lewq

value:
Hey HN! I've been building a system to run multiple AI coding agents in parallel, each in their own GPU-accelerated sandbox.
The problem I kept running into: when you're working with AI assistants on real projects, you want them doing multiple things at once (refactoring module A, implementing feature B, writing tests for C), but coordinating all that is a mess. You lose track of what's happening, agents step on each other, and you end up babysitting instead of building.
So I built HADES - think of it as a desktop environment for each agent, running on GPU-accelerated VDI backends. You write high-level specs, spin up multiple agents in isolated environments, and they each work on their own branch with their own MCP tools and RAG sources.
The demo shows me creating two Snake games simultaneously (Python and Rust versions), then jumping into one with Moonlight streaming to pair-program with the agent in real-time. The latency is wild - sub-20ms, feels completely local.
Each agent writes out structured spec files as it works, so you get this 30,000-foot view of everything happening in parallel. When they're done, they make PRs that humans review and merge.
Built this on top of our HPC infrastructure (we normally deploy ML workloads on Slurm clusters for supercomputing customers). Turns out the same tech that schedules thousands of GPU jobs is pretty good at orchestrating AI agents.
Currently running private beta. Also shout-out to the folks in our Discord who've already got this running on macOS - that's not even something I've tested yet!
Tech stack: Slurm, NVIDIA Container Toolkit, Wayland screencopy, Moonlight protocol, Docker/Harbor.
Would love feedback, especially from folks doing multi-agent development or running dev environments at scale.

value: Show HN: GPU-accelerated sandboxes for running AI coding agents in parallel [video]

author: lewq


value: zaidtashman

value:
I’ve built Aurca.ai, a web app to help people betting on prediction markets spot mispricing opportunities. It analyzes contracts using statistical models and machine learning by evaluating odds (from data) and uncover where the market might be off. I’ve been tinkering with this for a while, combining my love for data science and financial markets, and it’s finally ready for others to try.
You can jump in and check it out at aurca.ai/dashboard—no signup needed to play around with the core features. Just pick a prediction market contract (it supports Kalshi for now, with more to be added later), and it’ll show you the model results. My approach uses historical data, probabilistic models, and machine learning to predict events and evaluate their occurrence probability and compare that with the market price.
It’s early days, so expect rough edges—I’m here for feedback! What works? What’s confusing? Any features you’d want? I’ll be around to answer questions and tweak things based on what you think.
P.S. All Models are trained using Bayesian methods, and the tool used to train is Numpyro on JAX.

value: Show HN: Aurca AI – Find Mispriced Event Contracts on Prediction Markets

author: zaidtashman


value: kazga

value: Show HN: Grampax, a "torch.autocast"-style interface for mixed precision in JAX

author: kazga


value: octalide

value:
Hey guys. Mach is a pet project of mine that I've been designing and implementing for the better part of two years now.
It's a C-like systems programming languages that takes inspiration from and attempts to combine the best parts of languages like C, Rust, Zig, and Golang in particular.
Modern systems programming languages focus so much on "features" like fancy memory management, large amounts of syntax sugar for less typing, unique type systems, fancy interop, and more that just gets in the way. Mach is an attempt to bring all that back down to earth.
In practice, Mach should feel like writing C with a few extra nice-to-haves.
The project is in a very alpha stage, but does have a fully operational bootstrap compiler implementation as well as a full (scrappy at best) language documentation. I'm looking right now to involve people that would like to contribute or nitpick the project. It's not perfect -- far from it, but the philosophy is sound.
Take a look and let me know what you think, or, better yet, join the discord and tell me what you hate about it there. Mach is at the phase right now where what it needs is heavy scrutiny and criticism to lock it down into a distinct forward path. If you can provide that, please do!

value: Show HN: Mach, a new systems language that focuses on being simple and explicit

author: octalide


value: jeremysizle

value: Show HN: DocSend Alternative for B2B Sales

author: jeremysizle


value:
Hi HN!
I’ve been working on Sebastian.run
 — an AI tool that lets you build mobile apps by simply describing them in natural language.
Think of it as “vibe coding” — you type:
“Build me a recipe app with favorites, search, and pastel colors.”
...and in seconds, it generates the full app (frontend + backend + logic).
My goal is to make mobile app creation as intuitive as talking to a designer — no code, no templates, just clear intent.
Why I built it:
I got tired of the friction in no-code tools. They made building faster, but not simpler. So I built an AI-native alternative.
How it works:
You type a prompt describing your idea
The AI generates the full structure and UI
You preview instantly in your browser
It’s still in early beta, and I’d love your feedback — especially from developers, designers, and founders who’ve tried no-code tools before.
Try it here: https://sebastian.run
Also wrote a short piece about the concept of “vibe coding” here:
https://medium.com/@tonprofil/why-i-stopped-coding-and-start...
Would love to hear your thoughts — what feels promising, what feels missing?
Thanks!

value: Show HN: Sebastian.run – Build mobile apps from prompts using AI


value: hpen

value: I created a consultancy that specializes in flat fee MVPs, AI MVP, iOS apps, web apps.<p>resilientapps.com

value: Show HN: Flat Fee MVPs for 1000 dollars

author: hpen

title: Show HN: Flat Fee MVPs for 1000 dollars


value: cliftonk

value: Show HN: rstructor, Pydantic+instructor for Rust

author: cliftonk


value: deanandreakis

value: Show HN: Buy/Sell Electric Vehicles

author: deanandreakis

title: Show HN: Buy/Sell Electric Vehicles


value: This is a free, no signup desktop app that uses the clis like claude code, codex, gemini that are there in your system. It is less than 25mb for mac, linux, windows.  Reason to start this: I had seen plenty of youtube videos where there "Cursor for marketers" or twitter threads on how to use claude code for managers or non-technical people in general. So I set out to make an editor that is preview first and that supports pptx, docx, csv, xlsx, markdown -- view, edit, and also interact with AI. And pdf, image, video with preview support. I wanted this to be one place for managers or people who work with multiple different file types. This is just the first alpha version of the product. Hope to get some feedback and thoughts so I could improve the product.

value: Show HN: Cursor for files like word, ppt, CSV using existing CLIs(codex, Claude)


value: Show HN: Free listing your AI tool

title: Show HN: Free listing your AI tool


value: dragonkhoi

value: Hi HN. We made a little site where you can draw and browse art that has been moderated by advanced AI. We think multimodal LLMs unlock new safe areas for the consumer internet. Please give it a try and let us know how we can improve our model. Our hope is to build a connective internet with new safeguards.

value: Show HN: Pen Island – Clean Drawings via AI

author: dragonkhoi


value: jamescampbell

value: Start as a VC with $250,000 and invest in 20 different startups over 10 years (120 turns). Make strategic decisions, diversify your portfolio, and try to find the next unicorn! Will you become a Legendary Investor or lose it all?

value: Show HN: Unicorn – Text-Based VC Investment Adventure

author: jamescampbell


value: aaronpierron

value: Show HN: A chess middlegame trainer so I can stop blundering

author: aaronpierron


value:
HN Pulse is a minimal desktop app that sits in your menu bar and notifies you when Hacker News stories cross a custom threshold or match your keywords.
No RSS, no browser tab — just quiet, relevant updates.
Built with Electron and JavaScript.
Open source (MIT): https://github.com/acapilleri/hn-pulse
Download (macOS Universal build):
https://github.com/acapilleri/hn-pulse/releases/download/v1....
Feedback and ideas welcome!

value: Show HN: HN Pulse – stay updated on Hacker News from your menu bar


value: jldd

value: Show HN: B2B Virtual Deal Rooms

author: jldd

title: Show HN: B2B Virtual Deal Rooms


value: Show HN: I launched an agentic platform to schedule social media posts with MCP


value: devodii

value:
I built Paykit because I got tired of reading a new API doc every time I needed to integrate payments.
Stripe, Paddle, PayPal, Polar, they all have slightly different models, webhooks, and dashboards. It’s annoying if you ship a lot of small projects or handle payments across multiple platforms.
Paykit gives you:
 • One SDK that works with all of them.
 • One dashboard for revenue, customers, and webhooks.
 • A clean REST API so you can build your own UI if you want.
 • Works with shadcn/ui out of the box, feel free to check the docs for copy-paste code snippets to handle full payment integration in minutes.
Coming in V2: invoice builder, MRR screenshot tool (so you can flex your growth), and hosted billing portals for platforms that don’t have one.
It’s still early, but live here: https://usepaykit.dev
Would love feedback, especially from other devs who’ve felt this pain integrating multiple payment platforms.

value: Show HN: I'm tired of reading five different API docs just to accept payments

author: devodii


value: metroan

value: Hi everyone     I have been experimenting with a simple idea. What if the first five minutes of your day decided the rest?  I built First5Minutes, a small web app that helps you start strong. You choose one meaningful mission for the day and complete it with quick photo, video or text proof.  I created it to fix my own habit of overplanning and not starting. The focus is on doing one real thing each day, not maintaining long to do lists.  Key features: • One mission per day for focus   • Quick proof capture with photo, video or text   • Optional partner verification for accountability   • Streaks based on proof, not checkmarks    Try it here → https://first5minutes.app   No install or sign up wall. Just start a mission.  I would love your feedback on: • Is this level of simplicity helpful or limiting   • What part made or failed to make you feel you actually did something   • Any friction in completing your first mission  Built with Next.js, Supabase and Clerk.  Thanks for checking it out. I appreciate your time and thoughts.

value: Show HN: First5Minutes, Your first 5 minutes decide your day

author: metroan


value: emmanuelodii

value: Show HN: Paykit – one SDK for Stripe, PayPal, Paddle (stop reading 5 API docs)

author: emmanuelodii


value: kyrylo

value: This project is inspired by 37signals’ ONCE idea. I replicated the whole process and have already sold a few copies (the testimonials are real).

value: Show HN: I built a self-hosted error tracker in Rails

author: kyrylo


value: Made this game some years ago after wordle blew up and it has steadily (and very slowly!) been gathering some returning players. Guess the artist, if you’re wrong you see more of the painting. Round 2 is year, round 3 is art style.

value: Show HN: Artle - a daily art guessing game


value: sdfswerew

value:
Hi HN! I built RepoPulse (repopulse.live), an AI-powered analytics dashboard for GitHub repositories. It offers real-time monitoring, AI-driven insights, performance metrics, code quality analysis, and a quick start with your own GitHub token.
GitHub repo: https://github.com/Mxs8513/repopulse
I'd love to hear your feedback and suggestions!

value: Show HN: RepoPulse – AI-powered GitHub analytics dashboard

author: sdfswerew


value: mtrip-guide

value:
We’ve developed an AI-powered feature for our travel software that automatically builds structured itineraries from raw booking confirmations.
Travel agencies and tour operators often receive dozens of emails from multiple suppliers — each with different formats. Our AI model parses these confirmations, detects flights, hotels, activities, and creates a clean digital itinerary with day-by-day structure, ready to share with travelers via mobile, web, or PDF.
It’s built on AWS Lambda, OpenAI Responses API, and multi-step function calling with custom JSON schemas. We had to overcome challenges like handling inconsistent data formats, time zones, and merging multi-source bookings without duplication.

value: Show HN: AI that builds travel itineraries from booking confirmations

author: mtrip-guide


value: martinoV

value:
Hey HN,
I'm Martino and I built Showcase to solve a problem my team kept hitting: we'd have these incredibly useful ChatGPT conversations with tons of context built up, but there was no good way to bring teammates in without copying/pasting everything or starting over.
What makes it different:
Real-time collaboration - Multiple people can chat with AI simultaneously, seeing each other's prompts and responses live
180+ models - Compare responses across Claude, GPT-4, Gemini, and others in the same conversation
Rich media support - Upload videos, audio files, PDFs, spreadsheets, code, even entire websites as context
Generate content - Create podcasts, images, and videos directly in the chat
Voice responses - Models can respond with audio instead of text
The core insight: AI conversations shouldn't be isolated. When you're debugging code, researching a topic, or drafting something, it's way more productive when your whole team can jump into the same context thread.
We're using it internally for everything from technical documentation to customer research analysis. The ability to throw a 40-minute video into the chat and have the whole team ask questions about it has been surprisingly powerful.
Would love to hear what you think. What workflows would benefit from collaborative AI chat in your work?

value: Show HN: Showcase – Real-time collaborative AI chat with 180 models

author: martinoV


value: Show HN: Historian – A simple shell history tool


value: nicojuhari

value: Save bookmarks with context. Search quickly. Access everywhere. + the chrome extension is coming soon.

value: Show HN: I Built Bookmarks Manager Online

author: nicojuhari


value: louisjoejordan

value: I built a 24h Halloween radio stream hosted by Dr. Eleven, using ElevenLabs and HLS for delivery. Excited for you to hear it + open to any feedback.

value: Show HN: 24-hour Halloween radio station hosted by Dr. Eleven

author: louisjoejordan


value: donnikitos

value:
Over the past months, I’ve been working on somethings scary  - bringing modern frontend tooling (Vite, HMR, modular builds) into traditional PHP projects.
This resulted in (currently) three small open-source projects:
- A NPM package for Vite: https://www.npmjs.com/package/vite-plugin-php
- A Packagist package: https://packagist.org/packages/nititech/html-components
- And an additonal NPM package to transpaile those components: https://www.npmjs.com/package/vite-plugin-php-components
The goal is to make PHP feel modern again: fast rebuilds, componentized UI, and zero JS lock-in.
It’s early but already usable — feedback, ideas, and contributions welcome.
Here is a starter repo to play around with: https://github.com/nititech/modern-php-vite-starter

value: Show HN: Modern PHP development with Vite, it's ecosystem and PHP components

author: donnikitos


value: rpunkfu

value: Durbat is a Rust procedural macro that enables writing Rust using Black Speech keywords, identifiers, and module paths. It maps Black Speech constructs to their Rust equivalents while remaining fully interoperable with standard Rust.

value: Show HN: Durbat – Write Rust Code Using Black Speech

author: rpunkfu


value: shashanktomar

value:
I went down the rabbit hole on a side project and ended up building this: Strange Attractors(https://blog.shashanktomar.com/posts/strange-attractors). It’s built with three.js.
Working on it reminded me of the little "maths for fun" exercises I used to do while learning programming in early days. Just trying things out, getting fascinated and geeky, and being surprised by the results. I spent way too much time on this, but it was extreme fun.
My favorite part: someone pointed me to the Simone Attractor on Threads. It is a 2D attractor and I asked GPT to extrapolate it to 3D, not sure if it’s mathematically correct, but it’s the coolest by far. I have left all the params configurable, so give it a try. I called it Simone (Maybe).
If you like math-art experiments, check it out. Would love feedback, especially from folks who know more about the math side.

value: Show HN: Strange Attractors

author: shashanktomar

title: Show HN: Strange Attractors


value: yeargun

value:
I've built a web based pdf/docx/pptx editor and a format .ldf
When compared to pdf, it's:
- Fully editable, collaborative
- Faster
- Smaller in size
- Fully streaming (you only load the pages you view/about to view)
- Most importantly its not IRREVERSIBLE. Meaning, you dont need to do llamaindex or use pdf parsers. Its some protobuf schemes
- Fully HTML ally
- Might take less resources (greener)
- AI native.
I am planning to make it like canva+. And its also for education.
Please do register and upload some pdf/pptx/docx
at page https://learny.academy/doc
if you dont want to 'google sign in'. username:ppl pw:12345
I am gradualy making it more stable. For very very text heavy pdfs, texts go a little corrupted. Its better for slide like pdfs

value: Show HN: LDF - PDF's successor. Editable, and is just better

author: yeargun


value: spacefarers

value:
So I discovered Wispr Flow a bit ago, and it has been quite game changing in how I vibe code or just generally interact with AI. However there are a few fundamental drawbacks I didn't appreciate:
- All your data is sent to the cloud (you certainly want your company's approval before using)
- $12/mo subscription?? (why does everything have to be subscription nowadays)
So I created a FOSS alternative that works basically just as well at in my fundamental usecase: getting Claude Code or some other AI to understand what I want. For that we don't need massive cloud infrastructure or precise formatting, just one that gets the ideas right.
Comes Transcrybe:
- Free and Open Source
- You choose your own model (currenly between Whisper Tiny, Base, and Small)
- Instant Dictation <1s even for long sentences
- Zero data uploads eliminates privacy concerns (all recordings are deleted post dictation)
Of course it certainly doesn't format or recognize obscure language as well as a well-funded startup solution like Wispr Flow, but in my testing it is basically just as good in many usecases.
Check it out: https://github.com/spacefarers/Transcrybe
I am building on the shoulders of giants thanks to the incredibly fast C++ framework provided by whisper.cpp!

value: Show HN: Local Push-to-Transcribe

author: spacefarers

title: Show HN: Local Push-to-Transcribe