value: benjaminsanborn

value: My co-workers frequently slack me asking me why the DB is slow. Rather than get back to my desk, I can tell them at glance if there's a lot of contention, large VACUUM tasks or replication backups. Interested in any and all feedback!

value: Show HN: Psq, iOS Postgres Monitoring

author: benjaminsanborn

title: Show HN: Psq, iOS Postgres Monitoring


value: jbrockwork

value:
When making big financial decisions, I found myself making a brand new, hyper-specific, spreadsheets and redoing a lot of math every time, since I’d forgotten how my old spreadsheets worked. So I abstracted the common features that went into all my decisions and put them in a single web app (not a spreadsheet, but it sort of looks like one).
At a high level, finances (or at least mine) can be broken down into assets, liabilities, incomes and expenses (including taxes). The app puts all of those in a single dashboard and charts how your assets, liabilities, and net worth grow or shrink over time. I know there are a ton of tools in the personal finance space, but I think what makes mine different is that (a) it’s just about prediction, not tracking, (b) it’s designed to be viewed on a single page, and (c) it’s not meant to answer “can I afford something?”, but “what will happen if I do this?”.
The simplicity is partly born of necessity — this is my first solo project — but also intentional. I’ve found that high-impact financial decisions often become clearer when you focus on how they affect net worth far into the future, rather than on short-term optimization.
My roadmap includes multiple tabbed scenarios, project-based grouping of items, point-in-time snapshots (to compare past predictions with reality), and a chatbot that can game out scenarios with you.
I’d really appreciate any feedback, especially on whether this level of abstraction feels useful, and on user experience. Also, opinions on whether when you come back days later it should show the numbers you put in or the expected values for the current date.
As a side note, in the pre-populated example linked I have incomes and expenses flow directly to and from the investment account. This is simpler than including transfers between cash and investments (which also isn’t even supported). Does this feel unintuitive? Is there a more natural way to model this?

value: Show HN: A simple tool for modeling long-term financial decisions

author: jbrockwork


value: eamag

value: Show HN: Bluesky AI profiles map (Leiden clustering and Laplacian centrality)

author: eamag


value: nullchan

value: Show HN: Sast+LLM Security Scanner that filters false positives and fixes issues

author: nullchan


value: boxerbk

value: We are building a remote desktop for workstations. It's for Windows only today. Our focus is on supporting the most demanding 3D and CAD software with 444 color, 120+ FPS, multi-screen connections and more. We built our own UDP based networking protocol, desktop capture, encoding, decoding, and rendering to squeeze the latency from the connection. There's a lot more for us to do, but this is a start, and we hope to get some early feedback from HN as we continue to build key features, like USB passthrough, HDR video, collaboration, and more.

value: Show HN: Phaze – A Remote Desktop for Workstations

author: boxerbk


value:
I actually just built this stitch-mcp because I needed it for my own workflow. It has a bunch of tools that help a lot, and I made it to use on any MCP-supported platform.
It's open source here if you want to try it: https://github.com/Kargatharaakash/stitch-mcp
If you use it and find it helpful, please give it a star !

value: Show HN: Stitch-MCP, a universal MCP server for Google Stitch


value: Beefin

value:
I’ve built hardware projects for years, and the gap between “I want X” and “parts ordered, files ready to print” always took weeks.
Modo compresses that. Describe what you want (e.g. “a portable CO2 monitor with a display and buzzer”) and it generates:
- A bill of materials with real components (MPNs, not hallucinated parts)
- A printable enclosure generated from actual part dimensions
- Wiring diagrams, firmware boilerplate, and assembly instructions
- Design validation (power budget, pin conflicts, mechanical fit)
Everything streams in real time as each phase completes.
The key idea is constraining the system to a curated component database so it can’t invent parts, then using datasheet dimensions to drive enclosure geometry.
You can try it without signing up: https://modo.is
Curious what people here would try building, and where this breaks down.

value: Show HN: Describe hardware, get a buildable prototype

author: Beefin


value: ratulrahman

value:
I built Sharpie over the weekend to solve a problem I had: testing and sharing AI prompts without screenshots or paying for API calls.
It's a self-hosted playground that runs entirely in Docker:
- Local LLM inference (Qwen2.5 3B via Ollama)
- Share prompts with URLs locally
- Fork and remix prompts
- Zero API costs
- Markdown rendering with syntax highlighting
Everything is local - your prompts never leave your machine. One docker-compose up command and you're running.
This is my first real open source project, so feedback is very welcome!

value: Show HN: Sharpie – Self-hostable AI prompt playground

author: ratulrahman


value:
Gitmore (https://gitmore.io) – natural language queries across GitHub, GitLab, and Bitbucket.
Instead of filtering PRs, scanning commit logs, or asking engineers for updates:
- "What shipped last week?" - "Who's been working on the API?" - "Which PRs have been open longest?" - "Summarize this month's releases"
Plain English in, plain English out.
How it works:
Connect your repos via OAuth. We register webhooks. Every event gets normalized into a structured schema – commit message, PR description, author, timestamp, files changed.
The AI queries structured data, not raw text. PR descriptions and titles carry context that individual commits often miss.
Automated reports:
Don't want to ask? Schedule it.
Weekly or monthly summaries delivered to Slack or email. Forward to stakeholders or let it run on autopilot.
Other features: - Slack bot: Ask from where you already work - Public changelog: yourcompany.gitmore.io/changelog - Contributor leaderboard
Security:
Metadata only. We store commit messages, PR titles, descriptions, timestamps, authors.
We never access source code, diffs, or file contents.
- Token encryption: Fernet (HMAC-SHA256 + AES-128-CBC) - Webhook verification: HMAC-SHA256 - 2FA support
Verify yourself: check webhook settings after connecting.
Free for 1 repo: https://gitmore.io

value: Show HN: Founders can now chat with their Git history


value: aamatte

value: Use Claude Agent SDK, EB2 and Kapso to run Claude Code from WhatsApp.

value: Show HN: Run Claude Code from WhatsApp

author: aamatte

title: Show HN: Run Claude Code from WhatsApp


value:
pgedge-docloader is an open-source tool for converting documents into Markdown, and loading them into PostgreSQL with extracted metadata.
Our docloader strips out unimportant content such as additional markup and image tags so that chunking can be as efficient as possible. This helps avoid unnecessary token usage when developing with AI, and also maximizes efficiency of the searches.
Convert from HTML, Markdown, reStructuredText, and SGML/DocBook.

value: Show HN: Open-source tool for converting docs into .md and loading into Postgres


value: Nativeline

value:
Hey HN I'm Kane, I built Nativeline.
I got tired of AI tools that output React Native or web wrappers when I wanted a real iOS app. So I built something that generates actual Swift/SwiftUI code.
You describe your app, build through conversation, and everything — database, TestFlight, capabilities, is handled in one place. Full Xcode project lives on your Mac. No lock-in.
Swift-only on purpose. No cross-platform. I'd rather do one thing well.
Made a promo code for HN: use "HN" for 150 free Bits — enough to get an app started.
https://nativeline.ai
Happy to answer questions about the tech, the approach, or why I made certain decisions.

value: Show HN: NativeLine – Build native iOS apps through conversation (Swift only)

author: Nativeline


value: hkdeman

value:
We built a terminal database client that lets you connect to multiple databases and interact with them through a TUI. It’s open source (Apache 2.0).
Motivation:
My cofounder and I were tired of switching between pgAdmin-style GUIs and the psql CLI. Some tasks are faster in a UI, others in a terminal. So we built a TUI inspired by k9s that tries to cover both.
Features:
* Visual WHERE condition builder (column / operator / value via dropdowns)
* Natural language → SQL via AI (explicit consent required); supports OpenAI, Anthropic, Ollama (more planned)
* Schema-aware autocomplete for tables and columns
* Grid-based table browser with keyboard navigation
* Built-in MCP server (we use it with Claude Code locally and want to add it to the official plugin list)
* Supports all core WhoDB databases: Postgres, MySQL, MariaDB, SQLite, MongoDB, Redis, ClickHouse, Elasticsearch
Performance:
* Startup: <300ms
* Query execution: ~50–200ms overhead vs raw SQL (mostly rendering)
* Binary size: ~50MB (OS/arch dependent)
Tradeoffs:
1. Optimized for interactive exploration, not bulk operations. Pagination exists but very large tables can be painful.
2. TUI complexity: Bubble Tea is powerful but harder to debug than a simple CLI. Errors are shown with copy-pasteable GitHub issue text.
3. AI requires setup: Ollama locally or env vars (WHODB_OPENAI_API_KEY, WHODB_ANTHROPIC_API_KEY).
4. Keyboard shortcuts may not feel intuitive to everyone—feedback welcome.
Known limitations:
1. Syntax highlighting is basic and sometimes wrong.
2. Large result sets can feel sluggish when scrolling, even with pagination.
3. Connections are file-based (~/.whodb-cli/config.yaml). Passwords/secrets are stored in the system keyring.
This tool was built primarily for ourselves as software developers. It’s not meant for heavy analytics or DBA-style power tooling, but we plan to keep improving it and make it more enterprise-ready.
CLI README with usage examples:
[https://github.com/clidey/whodb/blob/main/cli/README.md](https://github.com/clidey/whodb/blob/main/cli/README.md)
Open questions:
1. Is the MCP server actually useful to others?
2. Is a simple yes/no AI consent sufficient, or is there a better/compliant approach?
3. Is tab-based view switching intuitive, or would vim-style :commands be better?
4. How should this fit into existing workflows instead of feeling “extra”?
Try it:
npm i -g @clidey/whodb-cli
whodb-cli
Supports macOS, Windows, and Linux (arm64/x64, plus armv7 without AI). We’ll add Homebrew and go install support. Binaries are also attached to releases: https://github.com/clidey/whodb/releases/tag/0.89.0

value: Show HN: WhoDB CLI – Terminal database client (Golang) with local AI support

author: hkdeman


value:
Demo of LOCAL Browser agent (powered by Web GPU Liquid LFM & Alibaba Qwen models) opening the All in Podcast on Youtube running as a chrome extension.
Source: https://github.com/RunanywhereAI/on-device-browser-agent
Post: https://www.reddit.com/r/LocalLLaMA/comments/1qh10q9/comment...
Geting in the support for web sdk soon, meanwhile have full support for mobile sdks : https://github.com/RunanywhereAI/runanywhere-sdks

value: Show HN: On-device browser agent (Qwen) running locally in Chrome


value: akiselev

value: Show HN: LLM-friendly debugger-CLI using the Debug Adapter Protocol

author: akiselev


value: aljaljic

value:
Hi HN!
I built SumGit, a tool that analyzes your Git history and highlights the meaningful milestones in a way that’s readable and shareable with teammates, on socials, or with your community.
Core features:
Connect GitHub repos (read-only access) and pick what to analyze.
AI milestone detection — the system finds the biggest moments automatically.
Timeline view — get a chronological summary of important commits.
Storybook & shareable highlights — create engaging narrative summaries you can post anywhere.
Recap summaries with stats, languages, and project highlights.
Check out a live sample story here:
 https://sumgit.com/story/dmTSdAFqJqbI
Would love feedback on what you’d want in a Git storytelling tool!

value: Show HN: SumGit – Turn your commits into stories

author: aljaljic


value:
Hi HN, I’m building Kuzco, a Swift SDK for running AI models locally on Apple devices (iPhone, iPad, Mac, Vision Pro). The goal is to make “offline + private AI” feel like a normal dependency you can drop into a SwiftUI/UIKit app, without standing up servers or paying per-token API fees.
What it does
- Text generation with token streaming (chat style UX)
- Vision AI (analyze images locally)
- Image generation via Stable Diffusion
- Model manager to download and manage on-device models
Developer experience
- create a session with a model
- stream tokens as they generate
- optionally get a full response
(There’s a code snippet on the homepage showing the exact flow.)
Why I’m posting
I’d love feedback from iOS devs (and anyone shipping on-device inference) on:
- What would make this a “must use” SDK for you
- What models you’d want supported first (small, fast, good-enough vs bigger, slower, better)
- What your biggest pain is today: performance, model downloads, UX, memory, app size, safety, etc.
If you want updates / early access when it’s ready to share broadly, there’s a waitlist on the site (no credit card).
https://kuzco.co/waitlist

value: Show HN: Kuzco – On-Device AI SDK for iOS (LLMs, Vision and Stable Diffusion)


value: NadavBenItzhak

value:
Agentic coding is getting a lot of attention, but most explanations stay abstract or stop at demos.
This is a short, hands-on course on building with coding agents: how to structure agent loops, when autonomy helps vs hurts, how tools and memory are actually used, and where things tend to break in real projects.
The course focuses on:
* Practical agent loop patterns (plan → act → reflect and variants)
* Tool use, context management, and guardrails
* Common failure modes (hallucinations, drift, runaway autonomy)
* Tradeoffs between control, reliability, and speed
It’s aimed at engineers who want to go beyond toy examples and actually ship things with coding agents. Not a framework, not a product — just structured lessons based on real-world patterns.
Feedback and critiques welcome, especially from people already building agents in production.

value: Show HN: Agentic coding – a practical guide to building with coding agents

author: NadavBenItzhak


value: abdibrokhim

value: Show HN: AI Vibe Coding Hackathon $500k+ in prizes

author: abdibrokhim


value: andrewqu

value: Show HN: Agent Skills Leaderboard

author: andrewqu

title: Show HN: Agent Skills Leaderboard


value: svenmalvik

value: Show HN: I'd love feedback on my Markdown-to-LinkedIn Carousel webapp (desktop)

author: svenmalvik


value: julianpeters

value:
I run a few apps (AI Singer App, Pawtograph, TravelFeed). Support emails were eating 3+ hours of my day.
Tried Zendesk. Spent 2 hours configuring triggers before I could reply to a single email. The $25/month turned into $298/month for my setup. Closed the tab.
So I built something for myself:
- Tickets left, conversation right (that's the whole UI)
- AI suggestions trained on your replies, not generic stuff
- Knowledge base that grows as you answer questions
- 5 min setup
Left out on purpose: SLAs, workforce management, skills-based routing, phone/chat. If you need those, this isn't for you.
The goal isn't "Zendesk for small teams". It's the anti-Zendesk — do 5 things well instead of 50 things adequately.
Stack: Next.js, Prisma, PostgreSQL, AWS SES.
$9/mo (1 project), $29/mo (5 projects + teammate), $99/mo (20 projects + 10 teammates)
Code ANTIDESK = 20% off forever (ends Jan 31)
https://elkdesk.com
I built this for myself. If you're in the same situation, you can use it too.
Happy to answer questions about the build or product decisions.

value: Show HN: ElkDesk – I rage-quit Zendesk and built my own

author: julianpeters


value: justinde

value: Show HN: WP-CLI and Abilities API for Wordfence

author: justinde


value: StackBuilders

value: Show HN: Automating Type Safety for Mission-Critical Industrial Systems

author: StackBuilders


value: deichrenner

value:
I've been bitten too often by outdated documentation when I joined projects and I wanted to start learning Rust.
This is the early stage outcome of a git-hook based tool which tries to match recent code changes with the existing documentation and alerts you to newly introduced discrepancies. It has a TUI and works with all OpenAI compatible APIs.

value: Show HN: Driftcheck – Pre-push hook that catches doc/code drift with LLMs

author: deichrenner


value: ltononro

value: Show HN: Install "original" ralph and even schedule to run when quota available

author: ltononro


value:
I bought a VPS for less than $4, yet it was large enough to host multiple of my silly projects. I needed something simple and clean to deploy all of them on the same machine with SSL. No clutter, no BS. So I created it:

    uv tool install docklift
    # Create a Dockerfile
    docklift init  # Provide host info and domain
    docklift deploy

That's it. It installs Docker and Docker Compose on your VPS, uploads the source code, generates `docker-compose.yml` file for the project including Caddy configuration with SSL, builds and runs the Docker container. You only need to have Dockerfile.

value: Show HN: Docklift – Probably the cheapest and fastest way to deploy web apps


value: dmytrove

value:
Hi HN,
I have been working on RAPS (Rust Autodesk Platform Services CLI), an open-source tool designed to replace the fragile scripting usually required to automate CAD workflows in the cloud.
If you have ever worked with Autodesk APIs (formerly Forge), you know the pain of using the official Node.js or Python SDKs in CI/CD pipelines. You often end up with massive node_modules folders, dependency conflicts, and boilerplate code just to handle OAuth tokens or poll for job completion.
We built RAPS in Rust to provide a single-binary, zero-dependency solution that is safe by default for enterprise automation.
Key Technical Features:
- Zero-Dependency: Statically linked binary. No need to install Python, pip, Node, or npm on your build agents.
- Async/Polling Abstraction: Most CAD translation jobs are asynchronous. RAPS includes a wait flag that handles the polling loop and rate limits (HTTP 429) automatically, turning complex async logic into a single synchronous command.
- Resumable Uploads: Automatically handles chunking and parallel uploads for multi-gigabyte Revit and DWG files.
- CI/CD Ready: Maps API states to POSIX exit codes for reliable pipeline control in tools like GitHub Actions.
AI and Model Context Protocol (MCP):
Perhaps most interestingly, RAPS is now an MCP Server. It supports Anthropic's open standard, allowing LLMs to natively see and touch the Autodesk ecosystem. Instead of writing scripts, you can use an agent to find all Revit files in a specific bucket older than 30 days and archive them.
The goal is to bridge the gap between raw API endpoints and the operational needs of modern DevOps, moving from imperative scripting to declarative infrastructure.
Would love to hear your thoughts on using Rust for API wrappers or how you are handling large-file operations in CI/CD.
Repo: https://github.com/dmytro-yemelianov/raps
Docs: https://rapscli.xyz

value: Show HN: Raps – Rust CLI for Autodesk Platform Services (0ms Deps, MCP Support)

author: dmytrove


value: Show HN: OpenHiggs – Chain ComfyUI workflows with approvals and load balancing


value: hthegoat

value:
Most surf apps use one forecast model. When it's wrong, you're wrong. I built Howzit to pull from three models (NOAA WaveWatch III, ECMWF, Open-Meteo), blend them, and show confidence based on how much they agree.
76 East Coast spots from Maine to Florida. Free, no ads. You can toggle between individual models or see the blend.
Built with Nuxt.js and Supabase. Been working on this for a few months and just launched.
hwztsurf.com

value: Show HN: Free multi-model surf forecast for the East Coast

author: hthegoat


value: Show HN: Parallel Agentic Search on the Twitter Algorithm


value:
I've been compiling papers on Physical AI — the intersection of foundation models and robotics. This covers Vision-Language-Action (VLA) models like RT-2 and π₀, world models (DreamerV3, Genie 2, JEPA), diffusion policies, real-world deployment and latency problems, cross-embodiment transfer, scaling laws, and safety/alignment for robots.
The field has exploded in the past 18 months. We went from "lets try llms on robotics" to having so many dimensions to optimize for. so felt right to maintain a running list of resources.
Organized by: foundations → architectures → action representations → world models → learning paradigms → deployment → applications.
Contributions welcome — especially corrections and missing papers.

value: Show HN: A curated list of academic papers and resources on Physical AI


value: mjmasia

value:
When our daughter was born in December we needed to log diapers, feedings, etc.
We tried a bunch of apps, which were good, but overkill for what we needed.
I spent the last few weeks building Poopyfeed to scratch our own itch – and I'm pretty proud of it.
It's made our lives a lot easier and helped my wife, grandparents, and I stay in sync.
It's very important to my wife and I that this project doesn't require people create an account, and stays completely free. It's a little attempt to put something good and helpful into the world.
I built this using a React Native (Expo) mobile app (iOS only for now) and Elixir + Phoenix backend. I use Phoenix Channels heavily for real-time sync of breastfeeding, pumping, and napping timers (backed by GenServers + a DynamicSupervisor).
This is just a beta build so you have to download it via TestFlight, but I'd love any feedback from the community to make improvements before submitting it to the App Store.
Website: https://develop.poopyfeed.com
TestFlight: https://testflight.apple.com/join/bEpG7zSV

value: Show HN: Poopyfeed – free, private, no account newborn tracking

author: mjmasia


value: dkozyatinskiy

value: Show HN: Free interactive security awareness library

author: dkozyatinskiy


value: renbuilds

value:
Hey HN! I built Date Clue because I kept hearing the same dating stories from friends and family. The endless "what does this text mean?" conversations. The overthinking. Asking five different people for five different opinions.
It reminded me of those magazine quizzes, the ones where you'd answer a few questions and get something like "He's Into You" or "Run." Kind of silly, but also useful for getting out of your own head.
I wanted to make a modern version. Same entertainment value, but with context-aware responses based on your specific situation. Not generic "communication is key" advice.
How it works:
- Pick a situation: Texting patterns, Double text decisions, Red flags, Ghosting, Situationship clarity, or Second date signals
- Answer 5-7 questions about your scenario
- Get an insight with a suggested next step
What's free: Preview mode for 2 categories (no account needed). 1 full insight/day with free sign-in.
Research approach: I read a lot of dating subreddits, advice columns, and relationship psychology content to understand what patterns repeat. The quiz questions and insight logic reflect real scenarios (qualitative research, no training on user data).
Would love feedback on whether the insights feel useful or too generic. It's entertainment (not professional advice), but I tried to make them thoughtful.
Try it: https://dateclue.com

value: Show HN: Date Clue – I built a modern version of magazine dating quizzes

author: renbuilds


value:
The answer is simple: the more "prescriptive" you are with instructions for Claude, the worse your output. The reason is that Claude tries to pattern match - it's been trained on thousands of safe UI    patterns, which is why when you ask for "a modern dashboard" it doesn't really think about the problem space; it just defaults to whatever safe design pattern it can whip up at the time.
I've been working on a Claude Code skill to combat generic UI output, and I tried different approaches like being very detailed with my personal visual style, e.g., the type of alpha values to use for borders, specific token patterns to follow, etc. - and while I got okay-ish output, I realized that most of the visual output looked similar across a range of different instructions, with no diversity in creativity or information architecture.
So I analyzed and broke down the official frontend-design skill to understand how it's able to excel at creative tasks, and what I discovered is that the skill is mostly principle-based and evocative,    which is brilliant when you think about it. It maintains just the right balance to fuel creativity while maintaining structure across different ranges of tasks.
So my approach changed. I decided to build my skill using the same pattern: detailing my design principles but framing them in an evocative way to force Claude to deeply explore the task domain before any visual output (feel free to tear apart my approach, but hey, it works). Since then I've been getting way more thoughtful initial output from Claude rather than it defaulting to the safe UI patterns it was trained on.
My goal for this skill is to complement Anthropic's frontend-design skill. While frontend-design focuses on distinctive, memorable aesthetics for any web UI, interface-design is built for systematic consistency across functional interfaces - dashboards, tooling, web apps - where design decisions need to persist and compound across sessions.

value: Show HN: I figured out how to get consistent UI from Claude Code


value: hpen

value: I am working on building (and have made my first prerelease) for a Digital Audio Workstation with git like branching version control.<p>It's free for local use and paid for cloud syncing or collaboration.

value: Show HN: macOS native DAW with Git branching model

author: hpen


value: TheDever

value: Show HN: Generative UIs for the Web (Experimental)

author: TheDever


value:
Hi HN, I’m building Kuzco, a Swift SDK for running AI models locally on Apple devices (iPhone, iPad, Mac, Vision Pro). The goal is to make “offline + private AI” feel like a normal dependency you can drop into a SwiftUI/UIKit app, without standing up servers or paying per-token API fees.
What it does - Text generation with token streaming (chat style UX) - Vision AI (analyze images locally) - Image generation via Stable Diffusion - Model manager to download and manage on-device models
Developer experience - create a session with a model - stream tokens as they generate - optionally get a full response (There’s a code snippet on the homepage showing the exact flow.)
Why I’m posting I’d love feedback from iOS devs (and anyone shipping on-device inference) on: - What would make this a “must use” SDK for you - What models you’d want supported first (small, fast, good-enough vs bigger, slower, better) - What your biggest pain is today: performance, model downloads, UX, memory, app size, safety, etc.
If you want updates / early access when it’s ready to share broadly, there’s a waitlist on the site (no credit card).
https://kuzco.co/

value: Show HN: On-Device (Offline) AI SDK for iOS (LLMs, Vision and Stable Diffusion)


value: gangelo

value:
Hi Everyone,
I created a mobile app called Accumoo, and I would appreciate it if y'all can have a look, download and give me a favorable review. Lots of blood, sweat, tears and love went into this app, and I hope you LOVE it as much as I do - it's the app I always needed and wanted. Anyhow, I've been a Rails developer and Software Engineer for a long time, and this is my first stab at a mobile app. It's a "habit tracker" app on steroids that's just fun to use - syncs across devices, local-first architecture - and an easter egg game for good measure.
Help a disabled vet out and give it a go.
Thank you in advance.
GA

value: Show HN: I created my first mobile app, could use some support

author: gangelo


value: juanmanueldaza

value: Show HN: Linkedin2md – Convert LinkedIn Exports to Markdown for LLM Analysis

author: juanmanueldaza


value: iaincollins

value:
I’ve been working on MicroState, a city builder prototype written entirely in vanilla JavaScript using the HTML5 2D Canvas API.
My goal was to see how far I could get with a 2.5D isometric style simulation with vanilla JavaScript built very simply and drawn entirely with procedural generation for maps, tiles, roads, trees, buildings, etc.
The most interesting element is probably the terrain model, which allows for fairly arbitrary terrain.
Although some of the generated graphics like trees are cached as sprites, buildings- which are much more intensive to draw - are not cached yet, and many will probably cause your CPU fan to go brrr.
It's not quite a game yet, though it is "playable" and I thought folks might find it fun to try and have suggestions for features and gameplay they'd like to see, both in single player and multiplayer.
I'll be publishing the source on GitHub soon so it's easier to submit and track features and defects (and to clone and fork).
Happy to answer any questions!

value: Show HN: MicroState – JavaScript City Builder

author: iaincollins


value: Greateste

value:
Sales teams don’t have a “lead problem.” They have a time problem.
SDRs spend hours researching. Then they send generic outreach that gets ignored.
Prospecter removes that prospecting trap.
It’s an AI SDR workflow:
create a campaign for a segment
paste a target URL
get qualified leads, fit scoring, and pain-based outreach drafts ready to review and send
We’re in private beta with pilot teams and tightening the product based on results.
If you’ve built or run outbound, I’d value blunt feedback on:
how you define “qualified” and what signals you’d score
what would make you trust automated research plus draft outreach
what you’d need to ship this safely to a team

value: Show HN: Autonomous outbound research and outreach drafts

author: Greateste


value: steffs

value:
I spent hours last month debugging why GitLab CI jobs were stuck "pending" despite having active runners. The issue? Tag mismatches and an offline runner that wasn't obvious in GitLab's UI.
HiveSpace connects to your GitLab instance and shows:
- Why each stuck job isn't running (mismatched tags, offline runners, capacity)
- Runner utilization and queue times at a glance
- Trends to spot degrading performance
Built because GitLab's built-in runner metrics require Ultimate tier + ClickHouse setup, and many teams (including mine) don't have that. Also, even with those, the "why is this specific job stuck?" question isn't answered clearly.
Privacy note: Your GitLab API token is stored locally in your browser (cookie) and never sent to our servers. The dashboard makes API calls directly from your browser to your GitLab instance.
Early beta available. Book a demo at https://calendly.com/hello-hivespace/30min or just try it directly.
Stack: Next.js, GitLab API, TypeScript. Works with GitLab SaaS and self-hosted.

value: Show HN: HiveSpace – GitLab Runner Health Dashboard

author: steffs


value: toheart

value: Show HN: CoCursor – Team collaboration tools for Cursor IDE

author: toheart


value: nemath

value: Show HN: Wearable data and meal pics → a real coach adjusts plan every week

author: nemath


value: Show HN: X Post Analyzer – Score posts using X's open-source algorithm


value: Show HN: A Simple MCP Server That Lets Agents Talk to Users


value: bkls

value:
Give your best guesses on topics from business, tech, politics, law, sports, and more!
Any feedback welcome :) More to come ;)
Use of AI was helpful in generating and verifying questions and answers

value: Show HN: Ballparkguess.com

author: bkls

title: Show HN: Ballparkguess.com


value: coolwulf

value: Show HN: DoceraX – Open "Please wait cannot display this document" PDFs Mac

author: coolwulf


value: SimonDorfman

value:
A fork of Solar System Live that generates animated videos showing planetary
orbits over any date range. Tracks orbital statistics (how many times Earth
was lapped by Mercury/Venus, or lapped outer planets) and overlays dates/ages
on each frame.
Example: Einstein's lifetime (1879-1955) showing 76 years of solar system
evolution. Built with Python + Pillow + ffmpeg, runs locally with Lighttpd.
https://github.com/simondorfman/solar_system_live

value: Show HN: Generate animated solar system timelapse videos for any date range

author: SimonDorfman


value: DannyHeng

value:
Hey HN! We're excited to share Knowbotic, something we built after failing way too many exams despite "studying" for hours.
Our problem: We'd spend entire weekends highlighting textbooks and re-reading notes, then bomb the test on Monday. Turns out we weren't actually learning—just moving our eyes across pages and feeling productive.
What changed everything: We discovered that testing yourself (active recall) is 8x more effective than passive reading. But creating practice questions manually? Soul-crushingly tedious.
So we built Knowbotic. Snap a photo of your textbook page, upload lecture PDFs, or paste any text. The AI reads it and instantly generates practice questions. Then it quizzes you, adapts to what you're struggling with, and uses spaced repetition to cement things in long-term memory.
Works on literally any topic: Medical school anatomy, bar exam prep, learning Mandarin, CFA certifications, high school chemistry, random Wikipedia rabbit holes—if you can study it, Knowbotic can quiz you on it.
It's completely free for learners. No trials, no paywalls, no "unlock premium features" nonsense.
Cool stuff it does:
Generates questions from messy handwritten notes (our handwriting is terrible, still works)
Creates personalized study schedules based on your available time
Builds study communities where you can share quizzes and challenge friends
Tracks exactly which concepts you're weak on instead of wasting time on what you already know
We launched 3 weeks ago and we've already hit 100+ users—all found organically. People are using it for everything from USMLE prep to learning guitar theory, which has been incredibly motivating to see.
We've been using it ourselves and actually retained information for the first time in our lives. Now we want to see if it helps others.
We'd love your brutal feedback: What would make you actually use this? What's missing? How do you currently study new material without falling asleep?
Try it: https://knowbotic.app

value: Show HN: Knowbotic – Upload notes. Get quizzes. Master anything

author: DannyHeng


value: mikesmallhelp

value: Show HN: MCP Chatbot

author: mikesmallhelp

title: Show HN: MCP Chatbot


value: schappim

value: Show HN: Train Core ML models from the command line

author: schappim


value: rnjn

value:
While building observability dashboards, I wanted to get details of metrics I was using, find out how they were emitted, what units, enums etc. And to find a way go to the right documentation.
I got tired looking at 100s of different places - so I built a metric-registry. this registry scans through source code, docs and examples, and identifies metric names and emissions. you can search through 15+ popular sources and 3700+ metrics (1000s more to come). runs every night to refresh. please try out and share feedback on how i can improve it.
contribute here https://github.com/base-14/metric-library

value: Show HN: Metric-Registry

author: rnjn

title: Show HN: Metric-Registry


value: cuteeaglet

value: In the information deluge, LLMs reshape how we curate, write, and publish. This post covers trends, key advantages, and a practical BlackEagleAI loop to curate real articles and sync to Notion.

value: Show HN: LLM-Powered Writing: Trends, Advantages, and Curation to Notion

author: cuteeaglet


value: Dbuild

value: Put back some structure in your autonomous AI workflow to get better results !

value: Show HN: Upgrade from Ralph to Eric for a more autonomous AI

author: Dbuild


value:
Hi HN,
I built a CLI tool that acts as a middleware between me and LLMs. It forces a "Socratic" planning phase before allowing code generation.
The problem: I found "Vibe Coding" (prompting until it works) was making my architecture sloppy.
The solution: A 17-layer validation script and a prompt chain that asks modifying questions (e.g. "How do you handle JWT revocation?") before writing code.
Stack: Python, Local MCP Server.
License: AGPLv3.
Repo: https://github.com/peijun1700/bluemouse

value: Show HN: BlueMouse – open-source, local Socratic firewall for AI coding


value: iammhador

value:
Hi HN,
I built Interview OS to solve my own job hunting chaos after applying to 50+ roles and losing track of applications, interviews, and follow-ups.
Key features:
- Kanban-style pipeline for tracking applications
- Interview round logging with markdown notes
- Email templates with {{placeholders}} that auto-fill company and role details
- Emails sent from your own address using your SMTP
- Community section for sharing real interview questions
The main goal was to keep everything privacy-first and under the user’s control.
Stack:
Next.js 14 (App Router), TypeScript, MongoDB, Prisma, Tailwind CSS, Radix UI
I’d appreciate any technical or product feedback.
What feels missing or over-engineered?

value: Show HN: Interview OS, a privacy-first job tracker

author: iammhador


value: Tomyail

value:
I built Pushover Scheduler because I wanted a simple way to schedule Pushover notifications without managing servers.
What it does:
- Schedule one-time or recurring notifications
- Uses Cloudflare Workers + Durable Objects for reliability
- Built-in AI message generation (Cloudflare Workers AI)
- Self-hosted, zero dependencies on the client side
- Web UI for easy management + REST API
Tech stack: Cloudflare Workers, Durable Objects with SQLite, Hono, React + Tailwind
It's open source: https://github.com/your-username/pushover-scheduler
Deploy to Workers in one click.
I'd love feedback from the HN community. What features would you find useful?

value: Show HN: Pushover Scheduler – Cron jobs made easy with Cloudflare Workers

author: Tomyail


value: OXOYO

value: Flying Bird Wallpaper is a feature-rich desktop wallpaper application that supports multiple wallpaper types including images, videos, rhythm wallpapers, and solid colors, making your desktop unique and vibrant.

value: Show HN: Flying-Bird-Wallpaper – Open-Source Live Wallpaper

author: OXOYO


value: onurkanbkrc

value: Show HN: SKILL.md Hub

author: onurkanbkrc

title: Show HN: SKILL.md Hub


value: kuneosu

value:
If you work on multiple projects, you've probably noticed directories like node_modules, venv, target, and __pycache__ silently eating up tens of GBs of disk space.
dep-clean scans for all dependency/cache directories under a given path and lets you selectively delete them through an interactive checkbox UI.<p># Features<p>- Multi-language support: Auto-detects cache directories for Node.js, Python, Rust, Go, Java, .NET, iOS, and more
- Interactive selection: Pick which directories to delete instead of nuking everything
- Size display: Shows how much space each directory is using
- Safe preview: `--dry-run` option to see what would be deleted<p># Usage
## Install
`npm install -g @kuneosu/dep-clean`<p>## Scan current directory and select what to delete
`dep-clean`<p>## Scan specific path
`dep-clean ~/projects`<p>## Only clean node_modules
`dep-clean --only node_modules`

value: Show HN: CLI tool to clean up dependency directories across all your projects

author: kuneosu


value: I have been using ComfyUI for a while at work and kept running into friction with large node graphs- hard to diff, hard to version, and you never if you will OOM until you start running the graph. I build a backend that let's you define ComfyUI workflows as YAML-defined DAGs instead of UI node spghetti. You can also plugin multiple comfyui backend instances and the code takes care of moving artifacts

value: Show HN: Replacing ComfyUI node graphs with YAML-defined DAGs


value: eladkishon

value: Show HN: Hyve – Parallel isolated workspaces for coding agents, multi-repo dev

author: eladkishon


value: kanodiaayush

value:
When I do real research — reading papers, books, or trying to understand a complex topic — it never happens in one sitting.
I explore a bit, get interrupted, come back days later, ask new questions, find new sources, and gradually build understanding.
Existing AI tools are great at answering questions once, but they reset context every time. Notes tools preserve text, but not understanding — they don’t help me reconnect ideas, revisit sources, or see how my thinking has evolved.
I built Kerns to sit in between.
Kerns is an AI research workspace designed for research that unfolds over time. Each topic lives in a long-lived space where:
• You can ask new questions as they emerge
• Upload PDFs, papers, or documents alongside discovered sources
• Run deep research in parallel, not one query at a time
• Move fluidly between summaries and original source text
• Revisit work weeks later without losing context
Instead of scattering work across chats, documents, and bookmarks, research accumulates in one place and compounds as you return to it.
I’ve been using Kerns myself for things like:
• Reading and synthesizing books and essays
• Comparing technical papers and model releases
• Tracking ongoing policy or industry topics as they evolve
I’d love feedback from anyone who does sustained research — analysts, researchers, founders, students, or serious self-learners.
Thank you!

value: Show HN: Kerns – Research that compounds instead of resetting

author: kanodiaayush


value: zealer

value:
I built a simple tool for encrypting text and files entirely in the browser.<p>- AES-256-GCM encryption with PBKDF2 key derivation (600k iterations by default)
- Supports text and file encryption (up to 256MB)
- Data never leaves your device
- Share encrypted content via QR code or link
- No account, no server storage, no tracking<p>The crypto is handled by the Web Crypto API, and the source is straightforward if anyone wants to take a look. Would love feedback on the UX and any edge cases I might have missed.

value: Show HN: Encrypter.site – Browser-based E2E encryption for text and files

author: zealer


value: lavandar-admin

value:
The best startup ideas come from noticing something everyone else ignores. For me, it was watching a stadium operations manager check five different weather apps before deciding whether to cover the field.
He wasn't looking for a forecast. He was looking for a decision.
That's the gap. Weather data is abundant. Weather intelligence—knowing what to do about the weather—is scarce.
The Problem
Operations teams in aviation, marine, construction, and events spend enormous amounts of time translating atmospheric data into actions. A pilot doesn't need to know the dew point. She needs to know if she can take off. A concert promoter doesn't care about millibars. He needs to know if he should move equipment.
The existing solutions fall into two categories: consumer apps that are too simple, and enterprise systems that cost six figures and take months to implement.
There's no middle ground. No tool that says "here's what you should actually do" in plain language.
What We Built
LAVANDAR converts meteorological data into operational decisions. Not predictions—decisions. The difference matters.
When you load a location, you don't see temperature and humidity. You see: "PROCEED WITH CAUTION: Fog formation likely between 0400-0600. Recommend delaying ground operations until visibility exceeds 800m."
We built industry-specific modules:
Aviation — Go/no-go recommendations based on crosswind limits, visibility minimums, and runway conditions
Marine — Route optimization that factors swell period, not just wave height
Construction — Concrete pour windows, crane operation limits, heat stress indices
Events — Crowd safety thresholds, lightning protocols, evacuation timing
Everything feeds into a unified command center we call STRATA. One screen. Multiple locations. Real-time intelligence.

value: Show HN: I built an enterprise weather intelligence platform with Lovable

author: lavandar-admin


value: Show HN: LLM fine-tuning without infra or ML expertise


value: a website for bee swarm simulator blue hive guide

value: Show HN: BSS Blue Hive Guide

title: Show HN: BSS Blue Hive Guide


value: ersinesen

value:
Kar Beyaz Tüm Renkler is a spectrum album: a single musical idea observed through multiple forms. Each track starts from the same core motif and applies controlled stylistic transformations, producing distinct yet related pieces.
Conceptually, this treats the music as one latent musical structure projected into different musical domains.
A spectrum album is a general compositional approach: a way of exploring how one theme can remain itself while producing many realizations. Kar Beyaz Tüm Renkler is its first application.
The workflow uses structured prompting in Suno for generation, followed by external loudness normalization and AI mastering for consistency across tracks.

value: Show HN: A Spectrum Album – Structuring AI-Generated Music with Suno

author: ersinesen


value: stardeskeris

value:
Hi HN,
I’m one of the devs behind StarDesk, a P2P-first remote desktop we’ve been building for ~1 year.
We started this partly out of frustration: some popular RDP tools haven’t seen meaningful updates in a long time, and long-standing issues are often left unaddressed. As devs, we really dislike software that stagnates once it “works well enough”.
StarDesk is our attempt to do it differently.
What we focus on:
-P2P by default (relay as fallback)
-Low RTT + low jitter > chasing max bitrate
-Encoder / input path tuned for real-time interaction
-Modern E2EE (TLS/DTLS)
UX-wise, setup is intentionally boring:
PC-to-PC connection in ~5 minutes, no special env, no weird network config. This alone saved us a lot of time during daily work.
StarDesk still early, WIP. Feature set is limited, but latency is already solid for real-time use. We plan to keep iterating fast and in public. And hope you can give us some ideas to bulid it stronger.
If you’ve built or used low-latency remote or streaming systems, I’d love to hear your thoughts！

value: Show HN: I made StarDesk, P2P low latency remote desktop built for game and work

author: stardeskeris


value: buesra

value: Show HN: RobyGraph – A graph strategy game to program AI agents in the browser

author: buesra


value: mapyr

value: Show HN: MCP Hangar: K8s operator for managing MCP servers with lazy loading

author: mapyr


value: sebklaey

value:
Fokus: Architektur, IPFS, Emotional AI, Blockchain Memory
Hi HN,
Living Satoshi is an experimental AI system exploring a different design space
for assistants: offline-first interaction, client-side processing, and optional
immutable memory using content-addressed storage and blockchains.
Core ideas:
- Client-side emotional and cognitive pattern modeling (no raw text aggregation)
- Optional immutable memory: messages can be cryptographically hashed and stored
  via IPFS and public blockchains, making past statements verifiable and tamper-resistant
- No wallet required for basic usage
The project explores whether AI systems benefit from accountable memory,
stronger user ownership, and reduced platform dependency.
Tech stack highlights:
- Client-side inference with graceful offline degradation
- Content-addressed storage (IPFS)
- Cryptographic message hashing for verifiable history
- Probabilistic emotional pattern modeling (NHPS)
- Minimal backend, no centralized message logs
I’m mainly looking for technical feedback:
- Is immutable memory useful for AI assistants?
- Where does decentralization meaningfully help or hurt?
- Which parts feel unnecessary or overengineered?
Demo + architecture: livingsatoshi.com

value: Show HN: Living Satoshi – A decentralized AI with on-chain memory

author: sebklaey


value: Show HN: Turn Google Sheets into Website Widgets


value: investorsHeaven

value:
  After getting burned by expensive broken financial APIs, I spent almost a year
  building an AI system that extracts data directly from SEC filings.

  550+ companies so far, 400+ normalized fields, 12 years of history, no missing
  quarters. Industry-specific templates for banks, REITs, insurance.
  Full API access included.

  Free tier available. Happy to answer questions about the extraction approach.

value: Show HN: StockAInsights – Bloomberg-quality financial data from SEC via AI

author: investorsHeaven


value:
Tap water contamination is a pan-India issue, but stays invisible until it becomes a crisis. Here’s my small civic attempt to fix that.
More here: https://www.reddit.com/r/india/comments/1qi1bhg/tap_water_co...

value: Show HN: Citizen Water Signal – A tool to make tap water issues visible (India)


value: maciejgryka

value:
We used our platform to fine-tune a tiny text-to-SQL model using distillation from DeepSeek V3. Repo has instructions for how to replicate this.
This is definitely not the best-performing model like this out there! But I found it surprising we were able to get to this much out of it: stone's throw away from a teacher 1000x the size!
We also ran the same thing using the 4B Qwen and matched the teacher accuracy, though here the difference is merely 100x :)
I find this pretty cool - obviously our distilled models can only do this one task and don't generalize, but that's often exactly what you want when you're building agentic systems.
Happy to answer any questions!

value: Show HN: Distilled 0.6B text-to-SQL model

author: maciejgryka


value: cybercageio-dev

value: Show HN: CyberCage – Control what data reaches AI tools without blocking them

author: cybercageio-dev


value: forketyfork

value: Show HN: Architect: A terminal for running multiple AI coding agents

author: forketyfork


value: cranberryturkey

value: Show HN: The Marketplace for AI-Assisted Professionals

author: cranberryturkey


value: alphatesterguy

value:
I built this while trying to learn Vietnamese. Most flashcard tools make you sign up before letting you do anything. This one doesn't – just paste your text and go. No account, no email, no friction.
Paste any text (job description, study notes, documentation) and get:
- Flashcards with Q&A pairs
- Multiple choice quizzes with explanations
- Bullet-point summaries
Works in 11 languages. Export to PDF, DOCX, JSON, or TXT. Free to use (5 generations/day).
Would love feedback on the output quality – especially from anyone learning languages or prepping for exams/interviews.

value: Show HN: PrepareYourself – Generate flashcards, quizzes, and summaries with AI

author: alphatesterguy


value: labterminal

value:
I built AgentFacts, an open-source SDK that generates cryptographically signed metadata for AI agents. It captures identity, model, tools, constraints, and provenance as a signed artifact you can verify later.
It’s self-hosted and framework-agnostic, with integrations for LangChain and Hugging Face. There’s also an optional Merkle-tree log for tamper-evident evidence trails, so you can verify what an agent did over time.
Repo: https://github.com/agentfacts/agentfacts-py

value: Show HN: AgentFacts – verifiable identity and audit logs for AI agents

author: labterminal


value: ggurgone

value: Show HN: A Docker Sandbox alternative for local AI Agents

author: ggurgone


value: OGsus

value: I used Python Numba to build a high-performance volatility calculator API

value: Show HN: High-performance API for quantifying data stability and drift

author: OGsus


value: musnas

value:
UruFlow is a self-hosted deployment engine designed for teams who prefer terminals over browser dashboards.
Architecture: server + agents communicating over UFP (UruFlow Protocol), a custom binary protocol built for real-time bidirectional streaming.
Why not HTTP: Traditional tools poll for updates. UruFlow pushes. When a deploy triggers, the agent receives the command instantly. Logs stream line-by-line as they execute — not on refresh, not batched, actual real-time.
UFP wire format:
- Header: magic bytes (0x55 0x46) + version + type + payload length
- Body: JSON
- Message types: auth, metrics, commands, health checks
- Persistent TCP connection with TLS support
The server runs a full TUI, The agent handles git operations, Docker builds, and streams output back through UFP.
Technical choices:
- Go, single binary for server and agent
- SQLite for state
- Bubbletea for TUI
Supports Docker Compose, Dockerfile, Makefile builds. GitHub/GitLab webhooks for auto-deploy.
MIT licensed.
https://github.com/urustack/uruflow
Looking for feedback.

value: Show HN: UruFlow – Terminal-based deployment tool with custom TCP protocol

author: musnas


value: indigodaddy

value: Show HN: Vibebin: Incus/LXC-based platform for self-hosting persistent sandboxes

author: indigodaddy


value: chrislxy

value: Show HN: SenseResponse – Never Miss a Lead Call Again

author: chrislxy


value: hienyimba

value:
Hello HN.
We’ve been working on this browser-based tool for months now. It’s a link graph analysis tool like Maltego. It helps you connect the dots between people, companies, businesses and domains. Currently, it has around 70+ transforms (API data calls). We also automatically clean the data, and make it available for download + plugging into your workflow.
Instead of exporting to an AI chat tool, You can also chat with the forensic data we gather from the transforms and find connections using AI right on the platform.
It was built with Laravel (PHP), JS and Cytoscape.
Doing OSINT-related work? Try it out and let me know what you think.

value: Show HN: Link Graph Analysis Tool for Osint Analysts with 70 Transforms

author: hienyimba


value: ahuth

value:
Hi, I'm posting Daily Done, a web app for sharing project updates with clients - https://dailydone.work.
Give it a try, it's completely free right now.
Concept - make it easy to share updates, and let clients see them without any friction (no signup required for clients). Clients can also react with emoji and comment.
Goals - my day job is making web apps, but I've never shipped a product on my own. With this I wanted to create something that I could actually build, ship, and support end-to-end. So it is pretty simple (maybe too simple?).
Tech stack
- NextJS... don't hate me. Next has an annoying amount of magic, but I really like using it. Let's me use React to generate plain HTML, and sprinkle in client-side JS for interactive bits.
- Sqlite / Turso. Local dev without needing docker is really nice.
- WorkOS authkit, instead of rolling my own auth.
- Polar for billing, although billing isn't currently active.
Challenges
- The classic problem of getting people to try it out.
- Building something completely end-to-end was new for me. For example, setting up the webhooks and coordinating auth and billing isn't hard, but took a bit of thought.
- I can't design.
Learnings
- Maybe don't even build in billing, or possibly even auth, until people are trying it out.

value: Show HN: Share Project Updates with Clients

author: ahuth


value: mesahm

value: Show HN: Safest, Fastest, Easiest, and Most Advanced Python HTTP Client

author: mesahm


value: pelmenibenni

value:
First MVP
Built a social dare board where people pay others to do stupid things.
Would love feedback
https://idareyou.vercel.app/

value: Show HN: I Dare You. Create a Dare. Set a Price. Accept or Reject

author: pelmenibenni


value: elexingyu

value: Show HN: cc-cleaner – A cache cleaner for the AI coding era

author: elexingyu


value: Show HN: SERP and Reader API (from $0.56/1k). No monthly subscriptions


value: sorentwo

value: Show HN: Oban for Python (Job Orchestration Framework)

author: sorentwo


value: naeemnur

value: Show HN: Should I kill my side project?

author: naeemnur

title: Show HN: Should I kill my side project?


value: To be honest, without vibe coding, I never would have built something this frivolous.

value: Show HN: I vibe coded an (unofficial) Board of Peace site


value:
TL;DR:
- C++ compiled to WASM + Web Worker astar
- Custom heuristics
- Non-blocking
- 2–3.5× faster on large grids
- Performs especially well when a path can't be found
- Demo: https://saqib-ali.com/lightspeed-astarjs/

value: Show HN: A WASM A* Library – 2–3.5× Faster Than Alternatives


value: SaltNHash

value: Show HN: KeyleSSH – SSH auth where the private key never exists

author: SaltNHash


value: Show HN: A self-hosted news aggregator with custom tabs and local caching


value: dddimcha

value:
I've been working on an experimental operating system that runs AI inference directly at the kernel level, eliminating the traditional OS overhead between hardware and AI workloads.
The idea: why run an LLM on top of Linux on top of hardware when the AI is the application? EmbodIOS treats inference as a first-class kernel primitive.
Early results:
~10x faster cold boot to inference-ready state
~8x memory reduction vs. Linux + PyTorch stack
Direct hardware access for accelerators without userspace context switches
The OS is minimal by design – no scheduler optimized for multi-user timesharing, no filesystem abstractions you don't need, no legacy compatibility layers. Just what's required to feed tensors to silicon.
Open sourced at: https://github.com/dddimcha/embodiOS
Interested in feedback from anyone working on AI infrastructure, embedded ML, or alternative OS designs. What workloads would benefit most from this approach? What's missing?

value: Show HN: EmbodIOS – AI Operating System with Kernel-Level Inference

author: dddimcha


value: Show HN: A Simple MCP Server That Lets Agents Talk to Users


value: NabilChiheb

value:
Hi HN,
I kept missing warranty deadlines because receipts were scattered. Some on paper, some in email, some as random photos. When something broke, I either couldn’t find the receipt or realized the warranty expired last month.
I built Receiptly Pro to fix that. You snap or upload a receipt, keep it stored in one place, and actually have it when a warranty or return matters. The goal isn’t accounting, it’s not losing money because of forgotten paperwork.
I mainly use it to keep proof of purchase handy and avoid “too late” moments with warranties.
Link: https://receiptlypro.com/
Curious how others handle warranty tracking today, and what’s broken in your current setup.

value: Show HN: Receiptly – keep receipts so you don't miss warranties

author: NabilChiheb


value: joozio

value:
After my Limitless Pendant got banned in the EU, I had 30 days to export 6 months of voice data before deletion. The irony: the device promised "AI
  memory" but couldn't actually use most of it—LLM context windows cap out around 200k tokens, and my transcripts were millions.

  So I built a local workflow with Claude Code to extract actual value: structured knowledge base, meeting summaries, and a CLAUDE.md file (portable
  context for any AI assistant).

  Sharing the prompts so others can do this with their own voice AI exports. Works with Omi, Plaud, or any transcript dump.

value: Show HN: Claude Code prompts to turn voice AI exports to a personal knowledge

author: joozio


value: Show HN: Kitful – AI Blogging Platform

title: Show HN: Kitful – AI Blogging Platform


value: Nya-kundi

value: Show HN: Procjail – Building a process isolator in Go using Linux namespaces

author: Nya-kundi


value: ITProLab

value:
We’ve open-sourced ethbacknode, Go service we built while working on Ethereum payment and backend infrastructure.
What it is
- A backend-facing JSON-RPC 2.0 service that sits between application code and Ethereum nodes
- Handles common infra concerns: address generation, transaction submission, confirmation tracking, basic monitoring
- Intended to be run as a standalone service alongside a local or remote Ethereum node
Why we built it
- Direct JSON-RPC usage from backend services repeatedly led to duplicated logic: retries, nonce handling, tx lifecycle tracking, error normalization
- We wanted a thin, explicit layer that centralizes this logic instead of spreading it across multiple services
Design choices
- Written in Go as a long-running service
- JSON-RPC 2.0 API to stay compatible with existing backend patterns
- Supports IPC for local nodes (preferred for latency and security)
- Event delivery is at-least-once (clients must deduplicate)
- No Docker-first setup (IPC + containers adds operational complexity)
Conscious limitations
- Not a node replacement
- Not an indexer
- Not intended for public or untrusted exposure
- Does not try to abstract all Ethereum complexity away
- Requires backend teams to handle idempotency and state consistency
Where it likely does NOT fit
- Frontend or client-side usage
- High-level dApp frameworks
- Teams looking for fully managed RPC or hosted infrastructure
- Systems that require exactly-once guarantees without client logic
We’re sharing this mainly to get architectural and operational feedback:
- Are the trade-offs reasonable?
- Where would this approach break at scale?
- What obvious edge cases or failure modes are missing?
Repo:
https://github.com/ITProLabDev/ethbacknode
Open to critique — especially from people who’ve operated Ethereum infra in production.

value: Show HN: Ethbacknode – a back end-oriented Ethereum node abstraction (Go)

author: ITProLab


value: asliper

value: Show HN: I built a screenshot beautifier because I hate subscriptions

author: asliper


value:
I built this because I was tired of "utility" apps that demand my email address or location data just to scan an item.

  Lensr is a single-purpose iOS tool:

  1.Open app.

  2.Snap a photo of an object (furniture, tech, shoes).

  3.Get the Amazon match instantly.

  The Tech:

  Built with Expo (React Native).

  Image analysis via OpenAI's Vision API through a Cloudflare Worker proxy - no images are stored.

  No user accounts, no tracking pixels, no data collection.

  Monetization: Totally free and ad-free. I use Amazon affiliate links for the results. If you buy the match, I get a small commission. This keeps the UX clean without selling data.

value: Show HN: Lensr – Visual search for Amazon without the login wall


value:
Hi HN,
I’m the creator of nanobananaapi.dev. I built this because I was frustrated with how most image generation APIs handle text—it’s often garbled or contextually disconnected from the rest of the image, especially when dealing with multilingual layouts like Chinese and English mixed together.
Technical Highlights:
Infrastructure: The entire API is built on Cloudflare Workers. I'm using waitUntil to handle asynchronous tasks like telemetry and image post-processing without blocking the initial response, which keeps the TTFB (Time to First Byte) low even under load.
Text Precision: Instead of just relying on the base diffusion model, I’ve implemented a custom pipeline that optimizes the attention maps specifically for text-heavy areas. This ensures that the generated text remains legible and sharp, even in 4K outputs.
Consistency: For developers building brand-centric apps, I added support for up to 14 reference images. This uses a weighted fusion approach to maintain character or product consistency across multiple generations.
The "Why": There are many wrappers out there, but my goal was to provide a "developer-first" experience: no complex tiered subscriptions, just a simple pay-as-you-go REST API that integrates into a modern Next.js or Go stack in minutes.
Current Limitations: It’s not perfect. Highly complex cursive fonts still struggle occasionally, and I’m currently working on improving the outpainting latency.
I’d love to hear your thoughts on the API design or the output quality. I'll be around all day to answer any technical questions!

value: Show HN: Nano Banana API – High-fidelity image API with precise text rendering


value:
I built an open-source tool that surfaces Celery inspection data directly inside Django admin.
The motivation was avoiding a separate Flower process and keeping operational context where Django teams already work. It uses swappable backends that support django-celery-results or even the celery inspect API directly for live communication with workers
Feedback is welcome, especially from teams running Django + Celery in production.
This is the third in a series of projects that bring observability to the Django admin. You can check out the others as well:
dj-redis-panel: https://github.com/yassi/dj-redis-panel
dj-cache-panel: https://github.com/yassi/dj-cache-panel

value: Show HN: Celery observability inside Django admin (no Flower, no extra process)


value:
Hey HN! Solo dev here.
I spent a year building this because I learn best when knowledge stacks visually. Traditional trivia is forgettable—this uses collecting psychology to make it stick.
How it works:
- Answer questions correctly → unlock illustrated cards
- Use cards you've collected as hints for harder questions
- Knowledge builds on itself, like learning should
Right now: 2 fully playable demos (AI History, Streaming Wars) + 14 more albums in progress.
Background: I'm a robotics engineer turned neuropsychologist. This merges what I know about learning retention with gamification mechanics.
16 albums planned:
AI • Streaming Wars • NFL • K-Pop • Marvel vs DC • U.S. Presidents • National Parks • eSports • Fast Food History • Blockbuster Cinema • Revolutionary Inventions • Books That Changed the World • Urban Mysteries • Women in Sports • American Painting • Music Journey
2,733 cards total. Building 5-8 cards/day.
Try the AI demo: https://tradingpicturecards.com/aia/
Feedback very welcome. What would make you actually use this?

value: Show HN: Trading cards for learning – 16 albums, 2.7k cards, learn by collecting


value: bianheshan

value:
Hi HN,
I'm Heshan, founder of X-Pilot. We're building an AI Video Generator for online courses and educational content. Unlike most text-to-video generator that render videos directly from models (which often produce random stock footage unrelated to the actual content), we take a code-first approach: generate editable code layers, let users verify/refine them, then render to video.
The Problem We're Solving
Most AI video generators treat "education" and "marketing" the same—they optimize for "looks good" rather than "logically accurate." When you feed a technical tutorial or course script into a generic video AI, you get:
- Random B-roll that doesn't match the concept being explained
- Incorrect visualizations (e.g., showing a "for loop" diagram when explaining recursion)
- No way to systematically fix errors without regenerating everything
For educators, corporate trainers, and knowledge creators, accuracy matters more than aesthetics. A single incorrect diagram can break a learner's mental model.
Our Approach: Code as the Intermediate Layer
Instead of text → video blackbox, we do:
Text/PDF/Doc → Structured Code (Remotion + Visual Box Engine) → Editable Preview → Final Render
Tech Stack
- Agent orchestration: LangGraph (with Gemini 2.5 Flash for planning, reasoning, and content structuring)
- Video Code generation model: Gemini3.0 for Remotion Code & Veo 3  (for generative footage where needed)
- Code-based rendering: Remotion (React-based video framework)
- Knowledge visualization engine: Our own "Visual Box Engine"—a library of parameterized educational animation components (flowcharts, comparisons, step-by-step sequences, system diagrams, etc.)
- Voice synthesis: Fish Audio (for natural narration)
- Rendering: Google Cloud (distributed video rendering using chrome headless)
- Code execution sandbox: E2B (for safe, isolated code execution during generation and preview， but we will update to our own sandbox， because e2b offen time out，and low performance for bundle and render)
Why Remotion + Custom Components？
We chose Remotion because:
1. Editability: Every visual element is React code. Users (or our AI agents) can modify text, swap components, adjust timing—without touching raw video files.
2. Reproducibility: Same input → same output. No model randomness in final render.
3. Composability: We built a "Visual Box" library—reusable animation patterns for education (e.g., "cause-and-effect flow," "comparison table," "hierarchical breakdown"). These aren't generic motion graphics; they're designed around pedagogical principles.
The trade-off: We sacrifice some "cinematic quality" for logical accuracy and user control. Right now, output can feel closer to "animated slides" than "documentary footage"—which is actually our biggest unsolved challenge (more on that below).
What We're Struggling With (and Planning to Fix)
1. Code Error Rate
Generating Remotion code via LLMs is powerful but error-prone.
2. Limited Asset Handling
Right now, if a user wants to insert a custom image/GIF/video mid-generation, they need to upload → we process → regenerate. This breaks flow.
3. The "PPT Feel" Problem
This is the hardest one. Because we prioritize structure and editability, our videos can feel like "animated PowerPoint" rather than "produced content."
We're experimenting with:
- Hybrid rendering: Use generative video (Veo) for transitions/B-roll, but keep Visual Boxes for core explanations
- Cinematic presets: Camera movements, depth effects, color grading—applied as composable layers
- Motion design constraints: Teaching our agent to follow motion design principles (easing curves, visual hierarchy, pacing)
Honest question for HN: Has anyone solved this trade-off between "programmatically editable" and "cinematic quality"? I'd love to hear how others have approached it (especially in contexts where correctness > vibes).

value: Show HN: X-Pilot – Code-Driven AI Video Generator for Online Courses

author: bianheshan


value:
tl;dr - typing /login in claude code in a docker container will do auth in your host's browser :)
My team and I develop almost exclusively in dev containers. If you initiate an oauth2 auth from inside the dev container (for claude, azure cli, etc) you either (a) have some annoying copy and pasting to do or (b) you are using VS Code which magically makes it work with your host browser.
This utility makes the VS Code magic into a standalone utility so you don't need to be using VS Code but still get automatic proxying of your oauth2 requests to your hosts browser.
The basic idea (which is what VS Code does under the hood I believe) is to set up a server<->client relationship between host<->container that grabs your container-based cli tools browser open request, forwards out to the host, does oauth, forwards it back into the container.
We've been using it for a while and it works great. Thought I'd share.

value: Show HN: Oauth2-forwarder – web oauth2 for dev containers


value: Beefin

value:
I built a browser-based tool to visualize Google Location History after they moved
Timeline data to on-device storage, making it harder to view your own data.
Demo: https://ethan.dev/utilities/location-history-visualizer
Key features:
• 100% client-side – your data never leaves your browser
• Supports new location-history.json format (from Google Maps app export)
• Also works with older Google Takeout formats (Records.json, Semantic Location History)
• Interactive map with Leaflet.js, customizable styling, PNG export
• No signup, no analytics, no tracking
Technical details:
- Uses Leaflet for mapping, dom-to-image for exports
- Parses multiple Google Timeline formats (they've changed it 3 times)
- Handles the new "geo:lat,lng" coordinate format
- Date range filtering, fullscreen mode, style customization
Why I built this:
Google's Timeline migration to on-device storage broke web access. You can export
from the Maps app (Settings → Location → Export Timeline data) but there's no easy
way to visualize it. This tool runs entirely in your browser with zero server
interaction.
The code handles visit objects (places you stayed) and activity objects (routes
between locations), showing semantic labels like "Home" and confidence scores.
Open to feedback on the parser logic – Google's format isn't well documented.

value: Show HN: Client-side Google Location History visualizer

author: Beefin


value: qantesm

value: Show HN: NanoDate – smallest date library (0.78KB) using native Intl API

author: qantesm


value: aqny

value:
Launched Bricolaje today
Bricolaje is a desktop application that uses AI to suggest terminal commands, helping you stay productive while reducing the friction that often comes with command-line workflows.
It pairs with a companion CLI tool, bj, so you can request suggestions directly from the terminal you’re already using—and keep a clean record of what was proposed and what worked.

value: Show HN: Bricolaje – Inteligent Terminal Assistant

author: aqny


value: viralcode

value: Show HN: Vib-OS, vibecoded a operating system

author: viralcode


value: hollowlimb

value: We use optical illusion-style puzzles to reflect the characters’ psychology.

value: Show HN: I built a narrative game about running a thrift shop

author: hollowlimb


value: threadyx

value: Show HN: Threadyx – BYOK multi-agent AI coding platform

author: threadyx


value: tgalal

value:
Lately I've seen several projects for templating and executing prompts. However
they all go along the lines of

  $ executor prompt_file_or_name

which didn't exactly fit my "taste".
I figured one could use the same trick like busybox, where you can
detect if your binary is being executed via a different name (symlink). The
symlink name is treated as the promptname, and arguments are generated from a
schema defined in the prompt template.
So now instead of:

  # Using https://github.com/chr15m/runprompt
  echo '{"words": 300, "text": "some long text"}' | ./runprompt summarize.prompt
  # Or using https://github.com/simonw/llm
  echo "some long text" | llm -t summarize -p words 300

You get:

  echo "some long text" | summarize --words 300

And of course with documented arguments and so on:

  summarize --help

  Usage: summarize [OPTIONS] --words <words> --text <text>

  Prompt inputs:
        --words <words>  Maximum number of words
        --text <text>    The text to summarize, defaults to stdin

That was the starting point, then things escalated and suddenly there is load
balancing, caching, execution via shebang and other (IMO) neat features :).
Happy to get feedback and ideas.
Github: https://github.com/tgalal/promptcmd/
Documentation: https://docs.promptcmd.sh/
Examples: https://promptcmd.sh/lib/

value: Show HN: GenAI Prompts as "Native" Programs

author: tgalal


value: dreampixel

value: XFolder is a modern file manager designed specifically for macOS. It integrates core features such as multi-pane views, a smart directory tree, and multi-tab management, aiming to provide a more efficient and flexible file browsing experience than Finder.

value: Show HN: XFolder – a fast macOS file manager with multi-pane views

author: dreampixel


value:
Hi, HN - I'm launching powerapply.ai .
My husband and I both have full-time jobs. He studied CS and founded a small VC backed company. I’m the head of growth at a healthtech startup. Building small products is our little escape.
Recently, he started coding again after years of barely doing it (mostly using Claude, Cursor, Lovable). After a few false starts, we found an idea we both wanted to explore, and that’s how Power Apply was born.
Late last year I was on a walk with a friend who happened to be job hunting. She was venting about how messy the process is: filling out the same forms over and over, keeping multiple CV versions updated, writing cover letters that sound like you really want that job (having bills to pay isn't apparently persuasive enough). That night I went on reddit and found hundreds of the same complaints. I also tried a few products that aim to fix it, but found them all a bit sloppy (and expensive).
Today, Power Apply does three things:
- parses a master CV and generates a tailored version for any role, using the job description to decide what to emphasize and how to phrase it;
- auto-fills job applications via a chrome extension (with review/edit before submitting);
- tracks the entire job search in one place (saved, applied, interviewing, rejected)
It’s free.
I'm planning to document the journey from 0 to 100 users publicly, mostly to keep myself accountable (i have some ideas i'm curious to test and share). I’ve posted on HN before - mostly full time job related stuff - and the feedback was always really helpful (and blunt).
If you’re job hunting (or applying casually), I’d really appreciate your honest critique - on the product or the problem. What would be helpful that’s currently missing? If you try it, what sucks?

value: Show HN: We built Power Apply at night to survive the 9 to 5


value: aninibread

value:
Hi HN! I built Ghibli Search, a semantic search engine for Studio Ghibli movie scenes (e.g. Spirited Away, My Neighbor Totoro, Howl's Moving Castle, etc.).
Describe a dreamscape like "flying through clouds at sunset" or upload an image, and it finds visually similar scenes from the films.
Live demo: https://ghibli-search.anini.workers.dev/
Full Cloudflare stack: Workers, AI Search, R2, Workers AI
Open source: https://github.com/aninibread/ghibli-search
Would love feedback on the search quality and any ideas for improvements!

value: Show HN: Semantic search engine for Studio Ghibli movie

author: aninibread


value: fainpul

value:
The data of your page is stored in the URL shortener's database.
Visit https://tinyurl.com/mrpas5dc to see how it works.
The full URL, if you don't trust the short URL:
<a href="https://mdview.io/#mdv=N4IgbiBcCMA0IBMCGAXJUTADrhzWOAtgnjgMQAEAYgE4CmdFKAFjQPYDuSXAnhR3QBGAByQBzRszYBnFAEsAdmKxYFKhWUoAJThTkp+bGgGtp69dAB0FAKrTJKFMOmQA9K+Jg5dDpbltXJjYKAGN6VEYeNgBXGgpRCVgKaOlFMQpCJBMETgUmOgAPFGsAFWZGELYFFDpqvWkKWSM6BD08lkYbACUAGSSOZjkQ5lCkPME6SsJGMDoaPgAbKrFLc1UAJms7RjG+bp7GqRoahTnGua8QxhRgsLoIiiQM5oyx8SEFzt6KADMjQ6yaWsAGU2NNzjRLnQGkgFksOBQotEgslhMgakxykwshIDPtHj8anEOr8kCEUP1BsNXsZoXoDMIZKlBJ8US19JjGAkdoSziocMJoiy5NJBkp+SBVqp1JoKABhJCzVBmaWqfGfJQseoUBZyQj6FrWACSKAA5A0EHIfj85rUDII+IJ2Bx7DRrHKqqkEGcWCLHhRmGTjI8FK0cgpTQYUowOX84rtfUo9IRGccxsUcAQQB1pqQQLqxMwUJmBfR7MWoDgciEzCAs39qsC5AAvOh4aAAdizutOWjockLFZgli7OB7dAA6nIECw8B2AGwABiz4W9NCoVSHOGkY1rK9qa4AsnNMtO8CgaNE6PvQ3MehECufL9eq3qjZUFLXID9YfYs9WADkkFzSsQGiap9E+BBLGIHAAF8QDgoA" rel="nofollow">https://mdview.io/#mdv=N4IgbiBcCMA0IBMCGAXJUTADrhzWOAtgnjgMQ...

value: Show HN: Abuse URL shorteners to host throwaway webpages

author: fainpul


value: metawake

value: Show HN: RAG chunk size "best practices" failed on legal text – I benchmarked it

author: metawake


value: netmute

value:
Hi HN,
I built a small macOS/Linux CLI tool called dol (dark or light).
Why? Modern operating systems can automatically switch between dark and light mode. However, many CLI tools assume a fixed dark or light background unless told otherwise. This is an attempt to make that less painful.
The output is intentionally minimal; it just prints `dark` or `light`. This allows you to construct command lines with it.
Examples:
`fzf --color=$(dol)`
`difft --background $(dol) file1 file2`
This is the first release (0.1.1). Feedback is very welcome.
Repo: https://github.com/netmute/dol

value: Show HN: dol – Detect dark/light mode on the CLI

author: netmute


value: sgasser

value: Show HN: PasteGuard – Use OpenAI and Claude without exposing your secrets

author: sgasser


value: Show HN: Margin – Local-first podcast insights using Apple Foundation Models


value: ovelv

value: Generate consistent virtual personas with unique facial features for content creation, brand marketing, and social media.

value: Show HN: Create Highly Realistic AI Virtual Characters

author: ovelv


value: deltadarkly

value: Show HN: Opensource AIchatbot stack (agent-memory-frontend) one click deployment

author: deltadarkly


value: ofabioroma

value:
Hey HN! I'm Fabio and I built UltraContext, a simple context API for AI agents with automatic versioning.
After two years building AI agents in production, I experienced firsthand how frustrating it is to manage context at scale. Storing messages, iterating system prompts, debugging behavior and multi-agent patterns—all while keeping track of everything without breaking anything. It was driving me insane.
So I built UltraContext. The mental model is git for context:
- Updates and deletes automatically create versions (history is never lost)
- Replay state at any point
The API is 5 methods:

  uc.create()   // new context (can fork from existing)
  uc.append()   // add message
  uc.get()      // retrieve by version, timestamp, or index
  uc.update()   // edit message → creates version
  uc.delete()   // remove message → creates version

Messages are schema-free. Store conversation history, tool calls, system prompts—whatever shape you need. Pass it straight to your LLM using any framework you'd like.
What it's for:
- Persisting conversation state across sessions
- Debugging agent behavior (rewind to decision point)
- Forking contexts to test different flows
- Audit trails without building audit infrastructure
- Multi-agent and sub-agent patterns
What it's NOT:
- Not a memory/RAG system (no semantic search)
- Not a vector database
- Not an Orchestration/LLM framework
UltraContext handles versioning, branching, history. You get time-travel with one line.
Docs: https://ultracontext.ai/docs
Early access: https://ultracontext.ai
Would love feedback! Especially from anyone who's rolled their own context engineering and can tell me what I'm missing.

value: Show HN: UltraContext – A simple context API for AI agents with auto-versioning

author: ofabioroma


value: englishcat

value:
Hi HN,
A few weeks ago, I shared the first version of Lingoku here [1]. The community gave me some critical feedback: you wanted more privacy, local model support.
I listened. Today’s update addresses the top requests from that discussion:

   1. No Login/Registration: You can now install the extension and use all features immediately. No account needed.

   2. Bring Your Own Key (BYOK): I've decoupled the AI. You are no longer locked into a default provider.

   3. Local & Global Model Support: We now support 8 providers:

      - Ollama (for local privacy)
      - DeepSeek (great logic/price performance)
      - OpenAI / Claude / Gemini / OpenRouter
      - Doubao / Kimi

The tool focuses on contextual word injection and vocabulary explanations by AI while you read or watch content.
Try it here: https://lingoku.ai/en/learn-japanese
[1] Previous discussion: https://news.ycombinator.com/item?id=46296863
Happy to answer any questions!

value: Show HN: Lingoku – Learn Japanese with DeepSeek/Ollama (Updated)

author: englishcat


value: huntergemmer

value:
Creator here. I built ChartGPU because I kept hitting the same wall: charting libraries that claim to be "fast" but choke past 100K data points.
The core insight: Canvas2D is fundamentally CPU-bound. Even WebGL chart libraries still do most computation on the CPU. So I moved everything to the GPU via WebGPU:
- LTTB downsampling runs as a compute shader
- Hit-testing for tooltips/hover is GPU-accelerated
- Rendering uses instanced draws (one draw call per series)
The result: 1M points at 60fps with smooth zoom/pan.
Live demo: https://chartgpu.github.io/ChartGPU/examples/million-points/
Currently supports line, area, bar, scatter, pie, and candlestick charts. MIT licensed, available on npm: `npm install chartgpu`
Happy to answer questions about WebGPU internals or architecture decisions.

value: Show HN: ChartGPU – WebGPU-powered charting library (1M points at 60fps)

author: huntergemmer


value:
Hi HN, I’m experimenting with a small Python library called PicoFlow for building
LLM agent workflows using a lightweight DSL.
I’ve been using tools like LangChain and CrewAI, and wanted to explore a simpler,
more function-oriented way to compose agent logic, closer to normal Python control
flow and async functions.
PicoFlow focuses on:
- composing async functions with operators
- minimal core and few concepts to learn
- explicit data flow through a shared context
- easy embedding into existing services
A typical flow looks like:

  flow = plan >> retrieve >> answer
  await flow(ctx)

Patterns like looping and fork/merge are also expressed as operators rather than
separate graph or config layers.
This is still early and very much a learning project. I’d really appreciate any
feedback on the DSL design, missing primitives, or whether this style feels useful
for real agent workloads.
Repo: https://github.com/the-picoflow/picoflow

value: Show HN: PicoFlow – a tiny DSL-style Python library for LLM agent workflows


value: sweave

value:
Hi HN,
Most productivity tools assume you already know what to do. I kept getting stuck before that point.
Everpath is an experiment in planning goals as paths and roadmaps instead of task lists. You start with a goal written in natural language, and it generates a roadmap you can iterate on:
- reshape it by talking to it (“make this slower”, “focus on fundamentals”)
- view it as a board when executing
- view it as a calendar when committing time
- use a discussion mode that pushes back on unrealistic plans
This is not meant to replace discipline or effort. It’s meant to make starting less mentally expensive.
Curious what resonates and what doesn’t.

value: Show HN: Everpath – Goal planning via natural language roadmaps

author: sweave


value: tuantruong

value:
Hey HN ,
I’ve just pivoted *AISheeter* from a simple formula generator into a full AI Agent. Last year, it was just auto-complete; recently, with the help of Claude Opus, I rewrote it to handle multi-step workflows. Think of it as *Cursor, but for spreadsheets.*
The problem that I often faces: Most existing tools (including Gemini in Sheets) treat every query as an isolated, one-off task. If you want to run complex operations on data, you have to manually prompt every single step. It’s tedious and stateless.
This app, the solution : it is an agent that persists context per spreadsheet with multiple sheets. It allows for chained workflow. I.e. (e.g., "Analyze raw data → Extract signals → Score priority") where the AI remembers the output of step 1 when performing step 2.
*The Stack:*
- *Frontend/Backend:* Next.js 16, Vercel AI SDK
- *Database:* Supabase (for context persistence)
- *Integration:* Google Apps Script
- *Models:* BYOK (OpenAI, Anthropic, Gemini, Groq)
*The  Challenge:* The hardest part was managing the conversation memory without blowing up token costs. We implemented a system that maps conversation threads to specific Spreadsheet IDs, allowing the agent to "recall" previous context without needing to re-ingest the entire sheet history for every request.
*The Good Finding:* I do a lot of context engineering in the backend to handle tokens carefully. I actually found that smaller models like *gpt-5-mini* and *Claude Haiku* can actually handle this level of complexity surprisingly well if the context is structured correctly.
Link to repo: https://github.com/Ai-Quill/ai-sheeter
Download extension : https://aisheeter.com/
I’d love feedback on the architecture—specifically how we’re handling the context window management.
Thanks

value: Show HN: An open source "Cursor for Google Sheets" with conversation memory

author: tuantruong


value: hkh

value:
Hey folks, I’m Hassan, one of the co-founders of Infracost (https://www.infracost.io). Infracost helps engineers see and reduce the cloud cost of each infrastructure change before they merge their code.
The way Infracost works is we gather pricing data from Amazon Web Services, Microsoft Azure and Google Cloud. What we call a ‘Pricing Service’, which now holds around 9 million live price points (!!). Then we map these prices to infrastructure code. Once the mapping is done, it enables us to show the cost impact of a code change before it is merged, directly in GitHub, GitLab etc. Kind of like a checkout-screen for cloud infrastructure.
We’ve been building since 2020 (we were part of YC W21 batch), and iterating on the product, building out a team etc. However, back in 2020 one of our users asked if we can also show the carbon impact alongside costs.
It has been itching my brain since then. The biggest challenge has always been the carbon data. The mapping of carbon data to infrastructure is time consuming, but it is possible since we’ve done it with cloud costs. But we need the raw carbon data first. The discussions that have happened in the last few years finally led me to a company called Greenpixie in the UK. A few of our existing customers were using them already, so I immediately connected with the founder, John.
Greenpixie said they have the data (AHA!!) And their data is verified (ISO-14064 & aligned with the Greenhouse Gas Protocol). As soon as I talked to a few of their customers, I asked my team to see if we can actually finally do this, and build it.
My thinking is this: some engineers will care, and some will not (or maybe some will love it and some will hate it!). For those who care, cost and carbon are actually linked; meaning if you reduce the carbon, you usually reduce the cost of the cloud too. It can act as another motivation factor.
And now, it is here, and I’d love your feedback. Try it out by going to https://dashboard.infracost.io/, create an account, set up with the GitHub app or GitLab app, and send a pull request with Terraform changes (you can use our example terraform file). It will then show you the cost impact alongside the carbon impact, and how you can optimize it.
I’d especially love to hear your feedback on if you think carbon is a big driver for engineers within your teams, or if carbon is a big driver for your company (i.e. is there anything top-down about carbon).
AMA - I’ll be monitoring the thread :)
Thanks

value: Show HN: See the carbon impact of your cloud as you code

author: hkh


value: Upload one image to our AI 3D camera platform and instantly create a complete 3D photo room. Powered by Nano Banana Pro technology, this virtual studio lets you capture products and portraits from unlimited angles—just like a real photography studio, but without the expensive equipment or physical space

value: Show HN: AI 3D Camera:Transform Any Photo into a Professional Photography Studio


value: viiralvx

value: Show HN: I made a roguelike game playable over SSH

author: viiralvx


value: borenstein

value:
I made this for myself, and it seemed like it might be useful to others. I'd love some feedback, both on the threat model and the tool itself. I hope you find it useful!
Backstory: I've been using many agents in parallel as I work on a somewhat ambitious financial analysis tool. I was juggling agents working on epics for the linear solver, the persistence layer, the front-end, and planning for the second-generation solver. I was losing my mind playing whack-a-mole with the permission prompts. YOLO mode felt so tempting. And yet.
Then it occurred to me: what if YOLO mode isn't so bad? Decision fatigue is a thing. If I could cap the blast radius of a confused agent, maybe I could just review once. Wouldn't that be safer?
So that day, while my kids were taking a nap, I decided to see if I could put YOLO-mode Claude inside a sandbox that blocks exfiltration and regulates git access. The result is yolo-cage.
Also: the AI wrote its own containment system from inside the system's own prototype. Which is either very aligned or very meta, depending on how you look at it.

value: Show HN: yolo-cage – AI coding agents that can't exfiltrate secrets

author: borenstein


value: PouyaRZ

value:
Hi HN! I built this in ~2 days over the New Year's break, and it was the most fun I've had coding in a while...
*Why I built it:*
I was tired of generic listicles and recoms from Google Search, ChatGPT/Gemini, and Goodreads. I wanted something where I could say "a cozy mystery for a rainy weekend" or "something like Kafka but less depressing" and get actual niche results.
*How it works:*
- Describe what you're looking for in plain text (or voice) [https://mynextbook.ai/onboarding-books]
- A RAG system, built using Gemini 2.5 Flash Lite + Exa search, finds personalized recommendations
- Metadata is fetched from multiple sources
- ~5-10 seconds from input to recs (5-10X faster with cache)
*Stack:*
- Next.js 14 / TypeScript on Vercel
- Neon (Postgres) + Prisma
- Gemini + Exa Search API
- Built with Cursor + Claude Code, & AntiGravity (happy to discuss which was better for what)
*Try it without signing up:* no sign-up required to explore
*Bonus:* It also recommends movies and TV shows based on your book taste! I've found some binge-worthy stuff through it that I would've never found otherwise.
Still a tiny side project, but I love seeing people actually find useful recoms with it. Would love feedback on rec quality, UX, or features you'd want!

value: Show HN: I built an AI book recommender in 2 days

author: PouyaRZ


value: wesselthart

value:
A small web tool that helps decide what to cook using the ingredients you already have.
It doesn’t generate strict recipes, it offers a direction for a meal, without measurements.
Built as a calm alternative to recipe overload.

value: Show HN: Cooking Compass, decide what to cook with what you have

author: wesselthart


value: arzzen

value: Show HN: Stop screenshotting competitor emails. AI does the analysis

author: arzzen


value: macship

value:
Hi HN,
I’ve spent the last few years consulting on software licensing and entitlement systems. The current state of indie macOS dev is frustrating: you either lose 30% to the Mac App Store or you roll your own licensing implementation that usually gets cracked by a simple bool flip or API mock.
I've been building MacShip to offer a middle ground: a distribution stack that actually protects revenue without the MAS tax.
It handles the security side: I packaged the techniques I use in consulting into a drop-in SDK. It’s not just a server check; it handles offline validation and attempts to prevent common bypasses like binary patching and memory editing. (I know nothing is uncrackable, but this raises the bar significantly).
It handles the boring ops side: I hated the notarytool dance, so I wrote a zero-config GitHub Action that handles signing, notarizing, stapling, DMG creation, and generating your Sparkle feed.
I’m pre-selling v1 (shipping Feb 22).
Link: https://macship.dev

value: Show HN: MacShip – Licensing and distribution SDK/Boilerplate for non-MAS apps

author: macship


value: sovsparrow

value:
Hello HN. I am releasing BELGI, a protocol + reference implementation for deterministic acceptance of LLM-produced artifacts (code/spec/docs).
Premise: LLM outputs are untrusted. BELGI only accepts outputs that can be verified against a locked spec + cross-file invariants, with a default NO-GO posture on unknowns or missing evidence.
Mental model: lock -> verify -> seal. Gates decide GO / NO-GO and produce replayable, tamper-evident artifacts.
I’d love feedback on:
where this fails in real CI pipelines,
missing invariant classes / bypass vectors,
whether default NO-GO is usable at scale (and how you’d stage it).

value: Show HN: Belgi – deterministic acceptance pipeline for LLM outputs

author: sovsparrow


value:
Hey folks — I put together a fork of the Model Context Protocol (MCP) Rust SDK that integrates Web Assembly (WASM) based execution [1].
The goal wasn’t a production-ready framework, just a POC to answer: how hard is it to add WASM to MCP, really? Turns out: not that hard.
I’m skeptical of one-vendor-controls-all MCP tool marketplaces (e.g., Composio/Pipedream). An open, contribution-driven model (think GitHub Actions) feels like a much better fit for Rust + MCP.
WASM brings sandboxing, safer untrusted code execution, and easy binary sharing — and runtimes like WasmEdge [2] make things like DB or network access much more realistic.
Overall, pretty happy with how it turned out. Happy to hear any feedback. Also curious what other Rust folks think about MCP + WASM as a direction.
- [1] https://github.com/ra0x3/mcpkit-rs
- [2] https://wasmedge.org/

value: Show HN: Web Assembly (WASM) + Model Context Protocol (MCP)


value: daviducolo

value: Fastrace v1.0.0 – 20x faster traceroute in C with IPv6, ICMP/TCP modes

value: Show HN: Dependency-free traceroute implementation in pure C

author: daviducolo


value: ChuangLabs

value: Show HN: Shared Device Group – GPU sharing at the Kubernetes scheduler level

author: ChuangLabs


value: lizhang

value:
Whenever my remote team looks for something to play together, there is tons of friction:
* watch a minute long ad
* can't tell who's in yet
* staring at a lobby waiting for someone with a bad connection
* decision paralysis of what to play
Tried to make something that solves this. It's chaotic, it's fast, the games are easy to learn. Don't need to reorganize the lobby every time the group gets tired of one game.
It's all vibe coded, and claude adds new games based on a description (usually 1-shot)
(desktop only, sorry!)

value: Show HN: Game Lobby for Remote Play

author: lizhang

title: Show HN: Game Lobby for Remote Play


value: youngermax

value:
Thought making one of these cluster maps would be interesting. Used Nomic embeddings, HDBSCAN, and UMAP, with Gemma 3 27B (via Ollama) to label the clusters. Looked into the dataset to find the most active posting times, popular domains that were posted, and other trends from this past year
Write-up and other findings: https://lincolnmaxwell.com/p/clustering-hackernews-2025/
Interactive map: https://hackernews-clustered-2025.labs.lincolnmaxwell.com/
Heads up: the map is about ~20mb in size (~7mb transfer over network) - don’t use on a metered connection
AMA!

value: Show HN: Interactive semantic map and analysis of Hacker News stories in 2025

author: youngermax


value: jaylisches

value:
Hi HN,
I built neboo because I realized that my willpower wasn't enough to fight the "infinite scroll" of modern social apps. I’d pick up my phone for a second and lose thirty minutes to a dopamine loop.
Most blockers felt too aggressive or easy to bypass. I wanted a "manual override"—something to wake me up in the moment I’m stuck.
How it works:
) You hit a button, and it forces a 3-second breathing delay. This tiny friction is often enough to break the impulsive reflex.
) Instead of just stopping, it suggests a randomized 30-second micro-habit (stretching, hydrating, looking out a window) to provide a healthier "variable reward".
Privacy: No accounts, no ads, no trackers. Everything is stored locally in your browser's LocalStorage.
It’s a Progressive Web App (PWA) built to be as lightweight and Zen as possible. I use it as an exit sign on my home screen.
I’d love to get your feedback on the UI/UX and hear if you have ideas for more 30-second micro-habits that actually help you reset.
URL: https://neboo.me

value: Show HN: Neboo – A minimalist digital circuit breaker for doomscrolling

author: jaylisches


value: redhotcookerr

value: Show HN: Loomind – Local-first workspace with RAG and eternal memory

author: redhotcookerr