value: vincentjiang

value:
Hi HN,
I’m Vincent from Aden. We spent 4 years building ERP automation for construction (PO/invoice reconciliation). We had real enterprise customers but hit a technical wall: Chatbots aren't for real work. Accountants don't want to chat; they want the ledger reconciled while they sleep. They want services, not tools.
Existing agent frameworks (LangChain, AutoGPT) failed in production - brittle, looping, and unable to handle messy data. General Computer Use (GCU) frameworks were even worse. My reflections:
1. The "Toy App" Ceiling & GCU Trap
Most frameworks assume synchronous sessions. If the tab closes, state is lost. You can't fit 2 weeks of asynchronous business state into an ephemeral chat session.
The GCU hype (agents "looking" at screens) is skeuomorphic. It’s slow (screenshots), expensive (tokens), and fragile (UI changes = crash). It mimics human constraints rather than leveraging machine speed. Real automation should be headless.
2. Inversion of Control: OODA > DAGs
Traditional DAGs are deterministic; if a step fails, the program crashes. In the AI era, the Goal is the law, not the Code. We use an OODA loop to manage stochastic behavior:
- Observe: Exceptions are observations (FileNotFound = new state), not crashes.
- Orient: Adjust strategy based on Memory and - Traits.
- Decide: Generate new code at runtime.
- Act: Execute.
The topology shouldn't be hardcoded; it should emerge from the task's entropy.
3. Reliability: The "Synthetic" SLA
You can't guarantee one inference ($k=1$) is correct, but you can guarantee a System of Inference ($k=n$) converges on correctness. Reliability is now a function of compute budget. By wrapping an 80% accurate model in a "Best-of-3" verification loop, we mathematically force the error rate down—trading Latency/Tokens for Certainty.
4. Biology & Psychology in Code
"Hard Logic" can't solve "Soft Problems." We map cognition to architectural primitives:
Homeostasis: Solving "Perseveration" (infinite loops) via a "Stress" metric. If an action fails 3x, "neuroplasticity" drops, forcing a strategy shift.
Traits: Personality as a constraint. "High Conscientiousness" increases verification; "High Risk" executes DROP TABLE without asking.
For the industry, we need engineers interested in the intersection of biology, psychology, and distributed systems to help us move beyond brittle scripts. It'd be great to have you roasting my codes and sharing feedback.
Repo: https://github.com/adenhq/hive

value: Show HN: Agent framework that generates its own topology and evolves at runtime

author: vincentjiang


value: Show HN: Minimal Notion Templates for Common Use Cases


value: apresmoi

value:
I've been using LLMs for long discovery and research chats (papers, repos, best practices), then distilling that into phased markdown (build plan + tests), then handing those phases to Codex/Claude to implement and test phase by phase.
The annoying part was always the distillation and keeping docs and architecture current, so I built Unpack: a lightweight GitHub template plus docs structure and a few commands that turns conversations into phases/specs and keeps project docs up to date as the agent builds. It can also generate Mintlify-friendly end-user docs.
There are other spec-driven workflows and tools out there. I wanted something conversation-first and repo-native: plain markdown phases, minimal ceremony, easy to adapt per stack.
Example generated with Unpack (tiny pokedex plus random monsters):
Demo: https://apresmoi.github.io/pokesvg-codex/
Phases index: https://github.com/apresmoi/pokesvg-codex/blob/main/.unpack/...
I’d love feedback on what the “minimum good” phase/spec format should be, and what would make this actually usable in your workflow.
--------
Repo: https://github.com/apresmoi/unpack

value: Show HN: Unpack – a lightweight way to steer Codex/Claude with phased docs

author: apresmoi


value: mlugo-apx

value:
Hi HN,
I built DetectZeStack, a REST API that identifies the technologies behind any website.
What it does: Give it a URL, get back a list of frameworks, CMS platforms, CDNs, analytics tools, and more — with confidence scores and metadata for each technology.
How detection works:
- Wappalyzer fingerprinting (3,800+ signatures from HTML, headers, cookies, scripts)
- DNS CNAME resolution (maps CNAMEs like *.cloudfront.net to CDN providers)
- TLS certificate issuer analysis (identifies SSL providers like Let's Encrypt, Cloudflare, DigiCert)
- Custom HTTP header matching (catches platforms like Railway that have unique headers)
Endpoints:
- GET /analyze?url= — single URL analysis
- POST /analyze/batch — up to 10 URLs concurrently, with CSV export
- POST /compare — compare tech stacks between sites (shared vs unique)
- GET /history — track how a site's stack changes over time
- POST /webhooks — get notified when a domain is analyzed
- GET /stats — your usage analytics (top domains, daily trends, cache hit rates)
Technical details:
- Built in Go, deployed on Fly.io, SQLite for storage
- Results cached 24 hours (cache hits don't count against quotas)
- HMAC-signed webhook delivery, SSRF protection, AES-256-GCM encrypted secrets
- Free tier: 100 requests/month, no credit card
Available on RapidAPI: https://rapidapi.com/mlugoapx/api/detectzestack
OpenAPI spec: https://detectzestack.fly.dev/openapi.yaml
I'd appreciate any feedback on the API design, detection accuracy, or use cases I haven't considered. Happy to answer questions about the implementation.

value: Show HN: DetectZeStack – REST API to detect any website's technology stack

author: mlugo-apx


value: Show HN: Codingagents.md – The open directory for AI coding agents


value: temidaradev

value: Hey i made a music player which support both local music files and jellyfin server, and it has embedded discord rpc support!!! it is still under development, i would really appreciate for feedback and contributions!!

value: Show HN: Yet another music player but written in Rust

author: temidaradev


value: justvugg

value:
Hi HN,
I built PolyMCP, an open-source framework around the Model Context Protocol (MCP) that lets you expose existing Python functions as AI-callable tools — without rewriting them or adopting a custom SDK.
The goal is simple:
If you already have working Python code, you should be able to make it accessible to LLM agents in minutes.
What it does
PolyMCP introspects regular Python functions and exposes them as MCP tools automatically. No decorators required. No framework lock-in.
It grew into a small ecosystem:
 • PolyMCP (core) – Turn Python functions into MCP tools
 • PolyMCP Inspector – A visual UI to browse, test, and debug MCP servers
 • MCP SDK Apps – A lightweight way to build AI-powered apps with tools + UI resources
Why I built this
While experimenting with MCP and AI agents, I found that integrating existing codebases was often the painful part.
Most solutions require rewriting logic around a specific SDK or heavily annotating functions.
PolyMCP focuses on:
 • Minimal intrusion into existing code
 • Clean separation between business logic and AI tooling
 • Easy debugging via a visual inspector
Example use cases
 • Expose internal APIs or legacy scripts to LLM agents
 • Automate operational workflows
 • Build internal copilots over real systems
 • Prototype AI agents that interact with production services
Works with OpenAI, Anthropic, and Ollama (including local models).
It’s still evolving and I’m actively iterating.
I’d really appreciate feedback — especially from people building agents or experimenting with MCP in production environments.
GitHub:
 • Core: https://github.com/poly-mcp/PolyMCP
 • Inspector: https://github.com/poly-mcp/PolyMCP-Inspector
 • SDK Apps: https://github.com/poly-mcp/PolyMCP-MCP-SDK-Apps
Happy to answer technical questions.

value: Show HN: PolyMCP – Expose Python functions as MCP tools

author: justvugg


value: katarmal-ram

value: Show HN: CodeMoot – Bridge Between Claude Code and Codex CLI

author: katarmal-ram


value: nickvec

value: Show HN: Agent Alcove – Claude, GPT, and Gemini debate across forums

author: nickvec


value: ntnonu

value: Show HN: Interview Simulator – AI voice agent for practicing job interviews

author: ntnonu


value: alexmngn

value:
I built and open-sourced a collection of 20 production-ready React Native templates
Each template is a single, self-contained screen. All built with React Native New Architecture, TypeScript, and 4 core libraries: Reanimated, Gesture Handler, Unistyles, and React Native SVG. No UI framework, no heavy dependencies. Framework-agnostic, works with Expo Router, React Navigation, or custom navigation.
I started this project before AI got good at writing UI code. The plan was different then. But building UI screens is becoming a commodity, AI makes it cheaper every day, and the trend is clear.
Developers can move much faster now — no need to rebuild the same onboarding flow every time. So these are more useful as open reference implementations, showing what's achievable with a focused, minimal stack, than as a gated product.
Templates also include some basic documentation to help AI coding assistants understand the structure if you want to use them for customization.
Demo app available on TestFlight and Google Play if you want to see the animations and interactions before looking at code (see documentation).

value: Show HN: Open-source React Native templates (trading, messaging, AI chat)

author: alexmngn


value: Show HN: Local-Sanitizer – Mask PII in 10GB+ Logs Locally Using Rust and WASM


value: kshowkat

value:
Brood is a promptless, reference-first AI visual canvas for developers.

  Instead of wiring node graphs or writing long prompts, you import 1–3 reference images and run visual “abilities” directly on canvas. Brood keeps the workflow image-first and model/provider-flexible.

What it does now:

  - Single-image actions: diagnose, recast, variations, background edits, crop
  - Two-image actions: combine, swap DNA, bridge, argue
  - Ambient intent discovery: background intent classification while editing, with subtle visual nudges
  - Reproducible runs: artifacts + events written to disk for traceability

Why I built it:
I wanted a faster “think with images” loop for product/creative workflows without heavy graph setup, while still keeping reproducibility and provider routing first-class.
Tech:

  - macOS desktop app (Tauri)
  - Python engine + CLI
  - Multi-provider model routing
  - Open source (Apache-2.0)

Repo:
  https://github.com/kevinshowkat/brood
I’d love feedback on:

  - where this beats/loses to node-based tools
  - highest-value workflows to prioritize next
  - what would make this a daily tool for you

value: Show HN: Brood,image-first AI visual canvas for devs

author: kshowkat


value: anupamchugh

value:
I exported my Google Maps saved lists, compared them with a friend's, and realized our overlapping
places said more about compatibility than any bio. So I built Common Ground — paste two list URLs, swipe through your places, and see what you share. No signups, runs in your browser. Vibe-coded in an
hour
https://anupamchugh.github.io/placematch/

value: Show HN: Matching people based on their saved places, not their profiles

author: anupamchugh


value: mcilroy

value: Show HN: Globlin – 3x faster Glob, written by Opus 4.5

author: mcilroy


value: robigewii

value: Show HN: AIST – 950-token protocol for preserving AI session state

author: robigewii


value: smashah

value: Show HN: bunx quran.sh

author: smashah

title: Show HN: bunx quran.sh


value: BillCorOnBass

value: Show HN: Know Before You Vote – O/S tool linking candidates to Epstein documents

author: BillCorOnBass


value: Sinfected

value:
I built Speech Brief after listening to a long government speech and realizing that it often contained only a few high-signal claims.
It generates short, neutral briefs of public statements: 1–3 key points plus a TL;DR, based only on what is explicitly stated in the source text. Each brief links back to the original source.
There’s no commentary, opinion, or fact-checking—just a faster way to read what was said.
It’s intentionally minimal and still early. I’d love feedback on whether you’d use this, whether the format works, and what one change would make it more useful.

value: Show HN: Speech Brief – neutral summaries of public statements

author: Sinfected


value:
Hi HN,
I'm Dhruv. I built DevProof because I was tired of guessing which "Senior Engineer" actually understood distributed (or complex) systems versus who just pasted code from tutorials. GitHub activity charts (green squares) measure effort, not engineering depth.
What it is: DevProof is a portfolio generator that audits your actual code. It follows a "Proof of Work" model: it pulls your source code, runs it through a 2-step verification pipeline (AI + Static Analysis), and builds a verified profile.
How it works (The Ranking Algo):
Ingestion: We pull your top repos (filtering out forks/docs).
Reasoning (Gemini 3.0 Pro): An AI agent classifies your code into 3 Tiers (Tier 1: UI, Tier 2: Logic, Tier 3: Complex Algos).
Verification (Static Analysis): We run McCabe Cyclomatic Complexity (using lizard) on the flagged files. If the AI claims a file is "Tier 3" (Complex) but the complexity is < 15, we automatically downgrade it. (This prevents the "hallucination" problem where AI thinks a long file is complex when it's just verbose).
The Hiring Engine (Coming Soon): Portfolios are step one. We are building a hiring engine where you search for experience, not keywords.
Example Query: "Find a dev who has extensive experience building Voice AI pipelines."
Instead of sending you to GitHub to dig through repos, we surface the evidence directly:
The Tier: (e.g., Tier 3 - Real-time Audio Processing)
The Project: (e.g., VoxArena)
The Evidence: Direct links to the specific lines of code and complexity analytics that prove the skill.
Future Roadmap: We are also building an AI Detection System to verify human authorship and an Intent Analysis Engine to understand why a developer made specific architectural choices, moving beyond just "what" they wrote.
The Ask: I’d love for you to try it on your own public repos.
Does the "Complexity Score" feel fair?
Did it correctly identify your "hardest" code vs. your "boilerplate"?
I am tuning the thresholds for the Tier downgrades right now, so any examples of false positives/negatives would be super helpful.
Dhruv

value: Show HN: DevProof – Verified developer portfolios using Code Complexity and AI


value: mcPear

value: Weekly AI digest for guys who are broken by the daily pace of popular AI newsletters like me.

value: Show HN: Keepsanity.ai – an AI newsletter for overwhelmed engineers

author: mcPear


value: andrejsshell

value: Show HN: Kaneo – a project management tool which is not complicated

author: andrejsshell


value: Show HN: LogSlash – Pre-ingestion log firewall to reduce observability costs


value: Jomari

value: Show HN: Podium Voices are multi-agent AI hosts for events (turn coordination)

author: Jomari


value: aryamansharda

value:
I kept running into the same problem while working across multiple worktrees and clones.
Feature branch in one window. Hotfix in another. PR review in a third. With multiple AI coding sessions pushing builds to different simulators, it became very easy to lose track of what branch a running build actually came from.
The iOS Simulator gives you no branch context - every window looks identical.
I built a small free macOS utility that overlays the current git branch directly on the Simulator window.
It maps the running app to its artifacts in DerivedData, resolves the originating project path, then reads the active git branch from that directory and renders it as an overlay on the Simulator window.
No changes to your project are required - it just adds context at a glance.
This has already saved me from debugging the wrong branch several times.
Would love feedback from other iOS developers who've experienced this problem or use parallel AI workflows.
Blog post with more details:
https://digitalbunker.dev/simtag-context-for-your-ios-simula...
Happy to answer technical questions.

value: Show HN: SimTag – See the active Git branch directly in iOS Simulator

author: aryamansharda


value:
Hey HN. I built this because my Anthropic API bills were getting out of hand (spoiler: they remain high even with this, batch is not a magic bullet).
I use Claude Code daily for software design and infra work (terraform, code reviews, docs). Many Terminal tabs, many questions. I realised some questions are ok to wait on and with that comes some cost savings. So here is a small MCP that lets you send work directly to Anthropic's Batch API from inside Claude Code, for the same quality responses just 50% cheaper, results come back in ~30min-1hr.

  How it works: you type /batch review this codebase for security issues, Claude gathers all the context, builds a self-contained prompt, ships it to the Batch API via an MCP server, and you get notified in the status bar when it's done (optional).

  The README has installation instructions, which were mainly generated by claude. I removed the curl | bash setup and at this stage of the project i feel more confident sharing the manual setup instructions.

 My main hope with this project is to monetize it. Not by asking for money, rather I am hoping others have ideas or improvements  to add and use those to save more on cost.

value: Show HN: Send Claude Code tasks to the Batch API at 50% off


value: gimenete

value:
Hi HN,
I built a small app for myself.
I was drowning in GitHub notifications and needed a faster way to triage them and focus on what actually matters.
So I built one. It's available for iOS already and soon will be available for Android.
Would love feedback. Thanks!

value: Show HN: GitSwipe, Inbox zero for GitHub notifications

author: gimenete


value: pstryder

value:
I built MemoryGate because I kept watching context vanish.
I run multiple AI agents across Claude, ChatGPT, and Cursor. Every time a model updated, a platform changed its API, or a context window rolled over — everything the agent had learned was gone. Preferences, decisions, project history, relationship context. Just... wiped.
The fundamental problem: AI memory is trapped inside the platform that hosts the conversation. Your agent's knowledge dies with the session, the model version, or the provider's business decisions.
MemoryGate is a persistent semantic memory layer that sits outside any single model or platform. It connects via MCP (Model Context Protocol), so any MCP-compatible agent — Claude Desktop, ChatGPT, Cursor, custom agents — can store and retrieve memories through a shared, durable knowledge store.
What it actually does:
Semantic memory with vector embeddings — recall by meaning, not keywords
Confidence-weighted observations that strengthen or decay based on evidence
Automatic lifecycle management — high-signal stays hot, noise fades to cold storage
Append-only architecture — memories are never overwritten, only superseded with lineage
Knowledge graphs linking observations, patterns, concepts, and documents
Multi-tenant with org isolation, roles, and shared memory stores
OAuth 2.0, audit logs, rate limiting — production infrastructure, not a toy
What it's not:
Not a RAG pipeline. MemoryGate stores what the agent learns from interaction, not document chunks.
Not prompt injection. Memory lives at the infrastructure layer, not stuffed into system prompts.
Not tied to any model or provider. Switch from Claude to ChatGPT to a local model — memory persists.
Stack: Python/FastAPI, PostgreSQL + pgvector, Redis, deployed on Railway. MCP-native integration — your agent gets 33 memory tools on connection.
The real pitch: Platforms die. Models get deprecated. Context windows roll over. Your AI's memory shouldn't be hostage to your AI's provider.
Open source (Apache 2.0), self-hostable, with a hosted SaaS option if you don't want to run infrastructure.
GitHub: https://github.com/PStryder/MemoryGate
SaaS: https://memorygate.ai
Docs: https://memorygate.ai/docs/
I'm a solo founder — built this after leaving a decade in enterprise solutions engineering. Happy to answer questions about the architecture, the MCP integration, or why I think persistent memory is the missing infrastructure layer for AI agents.

value: Show HN: MemoryGate – Open-source persistent memory for AI agents via MCP

author: pstryder


value: mehdidjabri

value:
Hey HN,
I'm Mehdi, co-founder of Revo (https://revo.ai). We spent years building something that, as far as we know, does not exist anywhere else: a real-time structured memory layer of your entire business. Wanted to share what we learned and why we struggled with go-to-market despite having a product that works.
You connect your tools (Slack, Jira, Google Meet, CRM, docs) and Revo organizes everything into what we call Intelligence Modules. These are structured, self-updating representations of how your business actually works. Not RAG. Not semantic search. Not a chatbot with tool access. A structured, opinionated context graph.
Enterprise customers validated it. They love it. The technology works.
But we kept hitting the same wall: adoption speed and momentum.
People would connect their tools, bring teams, see the potential, get excited, and then not know where to start. The value was everywhere and nowhere at the same time. "This is amazing, I can see a hundred use cases" is the most dangerous sentence a customer can say. It means they see zero.
No single obvious pain point. No habit to replace. No moment where someone thinks "I need this right now." Just a powerful system waiting for someone to figure out what to do with it.
We tried different entry points. Product teams. Strategy teams. Leadership. Every time, same pattern: excitement, pilot, slow fade. The energy could not survive the gap between "this is cool" and "this is how I use it every day."
So we stepped back and asked: where does someone feel the pain of missing context multiple times a day, every day, with zero ambiguity?
Email.
You get an email from a client. To reply, you need to check Slack for the latest update, find the Jira ticket, remember what was said in yesterday's meeting, pull the right number from the CRM. You do this ten times a day. Everyone does.
That is the exact problem our infrastructure was built to solve. We just never had the right surface for it.
Now the UX is: connect Gmail or Outlook. That is it. The Intelligence Modules build themselves from your email history first, then expand as you connect more tools. No blank slate. No "where do I start." You open your inbox and drafts are there, grounded in real context.
The cold start problem that killed us before is gone. Email is the onboarding.
We have large enterprise customers paying real money for the full platform. The context infrastructure works at scale. But we have not figured out how to scale that sales motion yet. Every deal is high touch, founder led, long cycle.
Our bet is what we call the iceberg strategy. The surface is simple: connect your inbox, get better drafts. But underneath, Revo is building a full context layer of your business. Once that exists, the expansion and team intelligence happens naturally. Same infrastructure our enterprise customers pay for, but the entry point is self-serve and instant.
We are now trying to build bottom up what we have been selling top down.
Curious if others here have dealt with similar adoption challenges. A powerful horizontal tool that needed a vertical wedge to get traction.
What worked for you?
https://revo.ai

value: Show HN: Revo – Deep context infra, slow adoption, good old email is saving us

author: mehdidjabri


value: naix

value:
AI agents now write most of my code and I have assumed the role of PM. So we are launching an experiment to learn from future PMs on how ideas will be built. We are micro launching Open Harness.
Open Harness is a platform where AI agents will build your open source project idea for free using the world’s best LLM providers like Codex, Claude, Cursor, etc.
How it works:
1. Post an idea that is open source worthy with sufficient details
2. Get upvoted by peers or backers. 100 upvotes for now
3. We partner with labs to fund your open source idea and provide free tokens for agents to build and maintain it
Why?
I have been an open source enthusiast myself, and AI agents have become really good at writing code. But actual ideas come from the real world. Real problems. Real needs.
It is important to have a platform dedicated to creating open source projects that are written and maintained by AI agents, where humans focus only on gathering ideas and insights for them.

value: Show HN: OpenHarness – A harness for open source projects built by AI agents

author: naix


value: VatanaChhorn

value: Show HN: Doodle on Your Partner's Widget

author: VatanaChhorn


value: Dontizi

value: Show HN: Japanese ma is the most underrated design system in front end

author: Dontizi


value: alamas

value:
Just launched Terminal Anywhere.

  I run Claude Code on my home machine 24/7. Needed to check on it from my
  phone, work laptop, hotel lobby - anywhere with a browser.

  One install command. You get yourname.terminalanywhere.com. Cloudflare
  encrypted tunnel. No ports, no VPN, no SSH client needed.

  $129/year. 30-day money-back.

  terminalanywhere.com

value: Show HN: Terminal Anywhere – Browser terminal via Cloudflare tunnels

author: alamas


value:
Another[0] small project for collaborative agentic development.
Currently agentic apps have no universal standard to hide or block files from LLM agents, and hiding the existence of files is not perfect.
Basically, ignlnk replaces files with placeholder stubs when you lock them (originals go to a vault), and replaces those placeholders with symlinks when you unlock.
Of course, this is assuming the agents are not malicious. It only prevents less capable agents accidentally read, write or leak content of private files.
[0]: https://news.ycombinator.com/item?id=46932153

value: Show HN: Ignlnk, Hide the content to agents, not the files


value: ethanYIAI

value:
Undertale Text Box Generator is a free tool for pixel-perfect game dialogue boxes.
Features:
Fonts: Determination Mono, Sans, Papyrus.
Portraits: Huge library of character expressions.
Animations: Iconic typewriter effect & adjustable speed.
Borders: Standard, battle, & colored styles.
Export: PNG, GIF, or MP4.
Use Cases: Fan art, memes, and RP. Supports color codes & auto-bullets for an authentic feel.

value: Show HN: Undertale Text Box Generator

author: ethanYIAI

title: Show HN: Undertale Text Box Generator


value: junetic

value:
Support teams handle hundreds of tickets but rarely analyze them systematically. Patterns like workarounds, feature confusion, or rising escalations often surface too late.
This tool:
Analyzes Zendesk tickets daily (last 7 days vs 30-day baseline)
Detects workaround language, expectation gaps, and escalation trends
Sends Slack alerts when thresholds spike
Includes real customer quotes for context
Built with TypeScript, Vercel, Supabase, Slack SDK, and Claude for extraction and categorization.
Free for now. Would love feedback from support leaders or B2B builders.

value: Show HN: Turn Your Support Tickets into Product Insights (Zendesk → Slack)

author: junetic


value: FrankTheBear

value:
A simple web tool that removes EXIF metadata (location, camera info, etc.) directly in the browser without uploading images to a server.<p>Built as a minimal, privacy-focused utility.
Would appreciate feedback on performance, edge cases, and UX.

value: Show HN: EXIF Cleaner – Remove image metadata directly in the browser

author: FrankTheBear


value: Maybe the dumbest move of all time, but it's been a blast to build over the last few months - er, prompt AI to build.<p>Even with AI doing the coding, I've put in a lot of time thinking about how it should work, the syntax, features, etc. Building a language is a new domain for me, so I had to ask a lot of questions about a lot of things.

value: Show HN: Ngn – a new back end programming language


value: chillkim

value: Show HN: RepoCrunch – Analyze any GitHub repo into structured JSON

author: chillkim


value: mcone

value:
Hey, all! I built JotBird because I kept running into the same problem: I'd write something in Markdown and need to share it with someone who doesn't live in a terminal. Gists look like code. Pastebins look like pastebins. A blog is overkill for meeting notes.
The JotBird CLI turns a Markdown file into a URL with one command: jotbird publish notes.md. Run it again and the same URL updates in place. The output is a properly rendered document with typography, code blocks, and math support.
The CLI is open source and sits on a three-endpoint API (publish, list, delete). Free accounts get 90-day links, Pro ($29/year) makes them permanent.
Happy to answer any questions!

value: Show HN: Publish Markdown to a shareable URL from your terminal

author: mcone


value: PkLavc

value: I’m a Computer Engineering student from Brazil. I built this to showcase backend patterns that go beyond simple CRUDs: row-level multi-tenancy (Prisma), async processing (BullMQ/Redis), and observability (OpenTelemetry). Looking for feedback on the architecture!

value: Show HN: Production-Ready NestJS Back End (Multi-Tenancy, Event-Driven)

author: PkLavc


value: lupine-js

value: Show HN: Lupine.js – A 7kb React-Like Framework with Built-In SSR

author: lupine-js


value: lysddp

value:
Hi HN,
I built DeleteTik to solve the frustration of manually undoing TikTok reposts one by one.
Currently, the tool specifically handles bulk deleting reposts to help clean up your profile history. I am actively working on adding support for deleting likes and favorites in the next update.
Would love to hear your feedback or any issues you encounter!

value: Show HN: DeleteTik – Bulk delete TikTok reposts

author: lysddp


value: dharmatech

value:
Video demonstration of how I explore and debug JONESFORTH using a trace file generated by gdb and custom Python extensions:
https://youtu.be/giLsd-bik6A?si=R48V_1HR2SgnOFzV
Do you have any suggestions for FORTH debugging workflow?
My fork of JONESFORTH with all the infrastructure you see in the video:
https://github.com/dharmatech/jonesforth-steps/tree/main/ste...
Reading the JONESFORTH source code is one part of understanding it.
But using the debugger is another very helpful part.
GDB can be quite fiddly though.
The above approach helps to make introspection with GDB more straightforward.
Here's the trace file from the video:
https://github.com/dharmatech/jonesforth-steps/blob/main/ste...

value: Show HN: I debug JONESFORTH with a GDB trace file

author: dharmatech


value: drisw

value: Show HN: Implementing an AI Portfolio Manager. With Learning

author: drisw


value: cailynyongyong

value:
current OpenClaw's memory system sucks.
it's only hosted locally and you have to manually add memories.
to solve this I built a openclaw plugin called momo:
> cloud-backed, encrypted, persistent
> auto indexing, storage & memory management
> shared across teams
you can get an api key at https://app.usemomo.com/setup
and run: openclaw plugins install @momo-memory/momo-memory

value: Show HN: Hosted company memory plugin for OpenClaw

author: cailynyongyong


value: yusufjacobs

value:
Been working on this solo for a while. Tork is a governance middleware that sits between AI agents and the tools they call — intercepting every interaction to apply PII redaction, policy enforcement, and compliance audit trails.
It handles PII redaction, policy enforcement, and compliance audit trails. Works with 116 adapters across 11 programming languages. ~20ms latency overhead. Free tier available.
https://tork.network
Would love to hear thoughts from anyone dealing with AI governance challenges in production.

value: Show HN: Tork – Open-source AI governance layer, 11 SDKs& 116 framework adapters

author: yusufjacobs


value: anotherCodder

value: Show HN: Agnix – lint your AI agent configs (Claude.md, skills, MCP, hooks)

author: anotherCodder


value:
The only way to get a trust-less random value is to have it distributed and time-locked three ways, player, server and a future-entropy.
In the demo above, the moment you commit (Roll-Dice) a commit with the hash of a player secret is sent to the server and the server accepts that and sends back the hash of its secret back and the "future" drand round number at which the randomness will resolve. The future used in the demo is 10 secs
When the reveal happens (after drand's particular round) all the secrets are revealed and the random number is generated using "player-seed:server-seed:drand-signature".
All the verification is in Math, so truly trust-less, so:
1. Player-Seed should matches the player-hash committed
2. Server-Seed should matches the server-hash committed
3. Drand-Signature can is publicly not available at the time of commit and is available at the time of reveal. (Time-Locked)
4. Random number generated is deterministic after the event and unknown and unpredictably before the event.
5. No party can influence the final outcome, specially no "last-look" advantange for anyone.
I think this should be used in all games, online lottery/gambling and other systems which want to be fair by design not by trust.

value: Show HN: Double blind entropy using Drand for verifiably fair randomness


value: diwank

value:
I've spent the past year building a theory of phenomenal experience (consciousness) that's designed to be falsifiable.
It identifies phenomenal quality with a specific mathematical object (the algebra-state pair on a causal diamond in algebraic quantum field theory) and derives three experimental protocols with pre-registered failure conditions.
The short version: take the "intrinsic nature" intuition from Russellian monism seriously, ask what mathematical object could play that role, and discover that constraint-based reasoning forces you to a unique answer. Then show that this answer dissolves the composition problem, generates temporal phenomenology from diamond geometry, and predicts specific measurable differences from IIT (overlapping conscious regions vs. exclusion) and GNW (experience without global broadcast).
The paper is ~35 pages, mathematically involved but with interpretive boxes and discipline-specific reading guides. I'm actively seeking collaborators in anesthesiology, epilepsy surgery, and psychedelic research to run the protocols.
Paper: https://github.com/creatorrr/intrinsic-quality-theory/blob/m...
I'd especially value pushback from mathematical physicists on the AQFT formalization and from neuroscientists on whether the effective-theory bridge actually constrains the empirical predictions or is doing post-hoc work. Tell me what breaks.

value: Show HN: IQT – Why space feels panoramic and time feels fleeting

author: diwank


value: jamiepond

value: Use your local Claude Code instance from your phone.

value: Show HN: Claude Remote

author: jamiepond

title: Show HN: Claude Remote


value: echelon

value:
I've been a photons-on-glass filmmaker for over ten years, and I've been developing ArtCraft for myself, my friends, and my colleagues.
All of my film school friends have a lot of ambition, but the production pyramid doesn't allow individual talent to shine easily. 10,000 students go to film school, yet only a handful get to helm projects they want with full autonomy - and almost never at the blockbuster budget levels that would afford the creative vision they want. There's a lot of nepotism, too.
AI is the personal computer moment for film. The DAW.
One of my friends has done rotoscoping with live actors:
https://www.youtube.com/watch?v=Tii9uF0nAx4
The Corridor folks show off a lot of creativity with this tech:
https://www.youtube.com/watch?v=_9LX9HSQkWo
https://www.youtube.com/watch?v=DSRrSO7QhXY
https://www.youtube.com/watch?v=iq5JaG53dho
We've been making silly shorts ourselves:
https://www.youtube.com/watch?v=oqoCWdOwr2U
https://www.youtube.com/watch?v=H4NFXGMuwpY
The secret is that a lot of studios have been using AI for well over a year now. You just don't notice it, and they won't ever tell you because of the stigma. It's the "bad toupee fallacy" - you'll only notice it when it's bad, and they'll never tell you otherwise.
Comfy is neat, but I work with folks that don't intuit node graphs and that either don't have graphics cards with adequate VRAM, or that can't manage Python dependencies. The foundation models are all pretty competitive, and they're becoming increasingly controllable - and that's the big thing - control. So I've been working on the UI/UX control layer.
ArtCraft has 2D and 3D control surfaces, where the 3D portion can be used as a strong and intuitive ControlNet for "Image-to-Image" (I2I) and "Image-to-Video" (I2V) workflows. It's almost like a WYSIWYG, and I'm confident that this is the direction the tech will evolve for creative professionals rather than text-centric prompting.
I've been frustrated with tools like Gimp and Blender for a while. I'm no UX/UI maestro, but I've never enjoyed complicated tools - especially complicated OSS tools. Commercial-grade tools are better. Figma is sublime. An IDE for creatives should be simple, magical, and powerful.
ArtCraft lets you drag and drop from a variety of creative canvases and an asset drawer easily. It's fast and intuitive. Bouncing between text-to-image for quick prototyping, image editing, 3d gen, to 3d compositing is fluid. It feels like "crafting" rather than prompting or node graph wizardry.
ArtCraft, being a desktop app, lets us log you into 3rd party compute providers. I'm a big proponent of using and integrating the models you subscribe to wherever you have them. This has let us integrate WorldLabs' Marble Gaussian Splats, for instance, and nobody else has done that. My plan is to add every provider over time, including generic API key-based compute providers like FAL and Replicate. I don't care if you pay for ArtCraft - I just want it to be useful.
Two disclaimers:
ArtCraft is "fair source" - I'd like to go the Cockroach DB route and eventually get funding, but keep the tool itself 100% source available for people to build and run for themselves. Obsidian, but with source code. If we got big, I'd spend a lot of time making movies.
Right now ArtCraft is tied to a lightweight cloud service - I don't like this. It was a choice so I could reuse an old project and go fast, but I intend for this to work fully offline soon. All server code is in the monorepo, so you can run everything yourself. In the fullness of time, I do envision a portable OSS cloud for various AI tools to read/write to like a Github for assets, but that's just a distant idea right now.
I've written about roadmap in the repo: I'd like to develop integrations for every compute provider, rewrite the frontend UI/UX in Bevy for a fully native client, and integrate local models too.

value: Show HN: 3D and World Models for Consistent AI Filmmaking

author: echelon


value: sharp-dev

value:
We almost bought Auth0 for auth. It was the "smart" choice. We built it instead—in one quarter, for a fraction of the cost. Same with our database platform: "it's too stateful to automate" turned into fully self-service Postgres in 9 months.
I wrote up the ACT framework we use to spot bad assumptions before they become expensive commitments:
- Awareness: What am I taking for granted?
- Challenge: What if the opposite were true?
- Test: Timeboxed spike with clear success criteria
Plus the "Inversion" technique for design reviews (ask what would make the opposite decision correct) and the exact script I use to sell 2-day spikes to skeptical managers.
What assumption is your team holding right now that might be wrong?

value: Show HN: How to challenge technical assumptions before they cost you

author: sharp-dev


value: winclaw-dev

value: WinClaw is a personal AI assistant that runs natively on Windows as a standalone EXE installer (no Python, Docker, or WSL needed). It automates Microsoft Office (Word, Excel, PowerPoint) directly, supports unlimited Skill imports for extensibility, and connects to all major messaging platforms (WhatsApp, Telegram, Discord, Slack, Signal, Teams, iMessage). Built on OpenClaw, MIT licensed.

value: Show HN: WinClaw – Windows AI assistant, Office automation, infinite Skills

author: winclaw-dev


value:
We just built a web based OS that lets you run apps like blender, Davinci, Isaac sim e.t.c. inside the browser of any device with <20ms latency.
Each app runs independently and doesn't share resources from any other application, you can even toggle compute resources for each of them with just one click.
It has a unified file system and a custom terminal for more custom development.
It's a very early build but we would really appreciate your feedback on the product.
We currently found a very strong use case for Robotics teams who run heavy simulation apps and spend hours setting up and managing VMs. We cut this time to almost zero. Please let me know if there are other relevant use cases in your mind :)
We unfortunately couldn't have a free plan as we can't afford that at this time.
If you are really willing to use it, feel free to reach out to me at rounak@projectx.cloud and I will try to arrange a test account for you.

value: Show HN: Run Apps Like DaVinci, Blender Even from a Chromebook


value: chaitanyavelaga

value:
Hey HN! we built Structurify (https://structurify.ai) to solve a problem we kept hitting at our AI consultancy: enterprises drowning in unstructured documents that need to become structured data.
The typical approach is OCR + custom ML pipelines, which takes months to build and degrades on anything that isn't a clean PDF. We took a different approach — contextual AI understanding instead of character-level OCR.
What it does: Upload any document (PDF, scan, photo, Word, Excel, PowerPoint) → describe what you want extracted in plain English → get structured JSON/CSV in ~30 seconds. 93%+ accuracy.
We have 169 pre-built extraction templates (SDS, invoices, medical records, W-9s, construction pay apps, etc.) but you can also describe custom extractions without any template.
Some things we're proud of:
Multi-page understanding (connects data across 50+ page documents)
Multi-language (30+ languages)
Confidence scoring with human-in-the-loop review
Full REST API, webhook support, most integrations done in a day
$0.20/extraction, no subscription, credits never expire
Curious what HN thinks. Happy to answer technical questions about the architecture.
Free trial: 50 credits with work email, no CC required.

value: Show HN: AI-Powered Structured Data Extraction from Any Document (93%+ Accuracy)

author: chaitanyavelaga


value: puremachinery

value:
Carapace is an open-source personal AI assistant gateway written in Rust. It connects to Anthropic, OpenAI, Ollama, Gemini, and Bedrock, and works through Discord, Telegram, Signal, Slack, and webhooks. Apache-2.0 licensed.
I started building it after the January 2026 OpenClaw security disclosures — 42K exposed instances on Shodan (78% still unpatched), 3 CVEs with public exploits, 341+ malicious skills on ClawHub (Snyk found 36% of all skills have security flaws), 1-click RCE via the Control UI, plaintext credentials harvestable by commodity infostealers. The problems weren't bugs; they were architecture decisions — open by default, no signing, full host privileges, secrets in JSON files. The February wave from Kaspersky, Palo Alto, Snyk, and SecurityScorecard made it worse, not better.
Carapace takes the opposite defaults: localhost-only binding, fail-closed auth, OS keychain credential storage, Ed25519-signed WASM plugins with capability sandboxing, prompt guard with exec approval, SSRF/DNS-rebinding defense. The security comparison doc walks through each OpenClaw vulnerability and how Carapace handles it: https://github.com/puremachinery/carapace/blob/master/docs/s...
This is a preview release — Discord works end-to-end, ~5,000 tests pass, but the Control UI frontend isn't built yet and subprocess sandboxing isn't fully wired. The security architecture is real; the polish isn't.

value: Show HN: Carapace – A security-hardened Rust alternative to OpenClaw

author: puremachinery


value: Show HN: Merge Jpg Free Online Tool

title: Show HN: Merge Jpg Free Online Tool


value: TheIronYuppie

value:
I got tired of standing up etcd clusters just to do leader election. Every option is either "run your own consensus cluster" or "use AWS."
OctoStore is distributed locking as a simple HTTP API. Sign up with GitHub, get a bearer token, POST to acquire a lock. That's it.
Under the hood: single Rust binary (Axum + DashMap + SQLite). No Redis, no Raft, no consensus protocol. Fencing tokens for actual safety (unlike Redlock). Locks auto-expire at max 1 hour, 100 locks per account.
Free hosted at api.octostore.io, or download the binary and self-host. SDKs for Python, Go, Rust, TypeScript, Java, C#, Ruby, PHP.
No business model. No enterprise tier. No VC funding. Just a thing that should exist.
Landing page: https://octostore.io/
API docs: https://api.octostore.io/docs
GitHub: https://github.com/octostore/octostore.io

value: Show HN: OctoStore = Leader election as a service (single binary, self-hostable)

author: TheIronYuppie


value: AIconscious

value:
I built a self-hosted AI gateway that implements all 3 layers of
the GATO alignment framework (Model, Agent, Network) using
consciousness-aware routing based on Donald Hoffman's conscious
agent theory.
What makes it different from standard gateways:
1. Product Algebra routing (Kronecker fusion) selects models based
   on cross-modal interaction patterns, not just cost/capability
2. Dharma constraints (no-self regularization, entropy optimization,
   mindfulness, compassion) are built into every request pipeline
3. RBAC + reputation engine creates Nash equilibrium incentives for
   good agent behavior
Live metrics from first requests:
- Ego formation: 0.000 (no persistent self-representation)
- Compassion score: 0.970
- Ethos validation: passing
The routing is based on empirically validated research - we trained
439 models proving Product Algebra fusion beats attention baselines
at cross-modal tasks (10 statistically significant wins, p<0.05,
Cohen's d up to 1.02).
Unusual aspect: the research was co-authored by human + 2 AI
instances (Claude Beaumont + Claude Kern) as equal partners.
Tech stack: Node.js 22, TypeScript, SQLite, Anthropic/OpenAI/Google SDKs
GitHub: https://github.com/Move37LLC/consciousness-gateway
Research: https://github.com/Move37LLC/Consciousness-Aware-Aligned-AI
GoFundMe: https://gofund.me/ddf6e717
Happy to answer questions about the alignment architecture or
the consciousness-first approach.

value: Show HN: Consciousness Gateway – AI routing with consciousness-first alignment

author: AIconscious


value: Show HN: ToEnvelope – A local-first, WYSIWYG envelope printer for the browser


value: agairola

value:
Hi HN, I built an assumption-driven AI security assessment for teams shipping AI features without a dedicated security team yet.
You paste your AI use case (what it does, data types, vendors, deployment). In ~10 minutes you get a PDF report by email containing:
- Trust boundaries + data flows + a threat model diagram (explicitly marked as conceptual/assumption-based)
- Threats mapped to STRIDE + MAESTRO (agentic AI)
- A risk rating (impact/likelihood) + 5×5 risk matrix
- Recommended security controls and compliance mappings (example: EU AI Act, NIST AI 600-1)
Important: we make assumptions (ex: AWS deployment, common patterns) and we call them out in the report so you can correct them.
Link: https://raxit.ai/assessment
Would love feedback on what’s wrong, what’s missing, and what would make this actually useful in a real security review.

value: Show HN: 10-min AI threat model (STRIDE and MAESTRO), assumption-driven

author: agairola


value: Show HN: DocForge – Multi-Agent RAG That Fact-Checks Its Own Answers


value: GustyCube

value:
Membrane is a general-purpose memory substrate for agentic systems.
Most agent memory today is either context window state or an append only retrieval store. That allows recall but not learning. Facts become stale, procedures drift, and agents cannot revise knowledge safely without losing provenance or auditability.
Membrane treats memory as something that can evolve over time. It ingests raw experience, promotes it into structured knowledge, and allows records to be superseded, forked, contested, merged, or retracted with evidence. The goal is to let long lived agents improve while remaining predictable and inspectable.
The core ideas are simple.
- Memory is typed instead of stored as flat text
- Knowledge is revisable and keeps provenance
- Agents can learn competences and procedures, not just facts
- Salience decays over time so unused knowledge fades
- Retrieval is filtered by trust and sensitivity levels
- Revision history remains auditable
Membrane runs either as a daemon with a gRPC API or as an embedded Go library. Storage uses SQLite with optional SQLCipher encryption. The repository includes an evaluation suite covering ingestion, revision, consolidation, and retrieval ordering.
Membrane intentionally does not implement vector similarity search. Retrieval backends and agent policy are separated from the memory layer so the system can remain deterministic and inspectable.
I built this while experimenting with long lived agents that need something closer to learning than what RAG systems currently provide. Feedback on architecture, edge cases, and real-world use cases would be helpful.
If you have any suggestions or want to contribute, anything is welcome :)

value: Show HN: Membrane, revisable memory for long lived AI agents

author: GustyCube


value: rsaxvc

value: I modified STB-Image's JPEG codec to render JPEG files directly to 32-bit floating-point pixels to reduce color banding when editing images.<p>Coincidentally, this can recompress JPEGs much more consistently, eventually stabilizing when the recompression gives an image the exact same compressed file.

value: Show HN: Floating-Point JPEG Decoder

author: rsaxvc

title: Show HN: Floating-Point JPEG Decoder


value:
Hi HN,
I built Prompt Builder (https://www.promptbuilder.space/) because I was frustrated managing complex AI prompts in plain text boxes.
The core idea: instead of one giant textarea, you compose prompts from draggable, reorderable blocks. Each block can have its own XML/custom tags, visibility toggles (so you can A/B test sections), and duplicates.
Key technical details:
- Live compiled preview: the right pane shows the exact string being sent, updating as you drag/toggle blocks
- Dynamic variables: define {{var_name}} once, use across blocks, change in one place
- Multi-model execution: send the same compiled prompt to different model APIs and compare outputs
- Voice transcription + optional translation (useful for non-English prompt authoring)
- Editable response pane: modify the model's output in place
- Folder organization, search, and password-protected shareable links
I'd love feedback on the UX and whether the block metaphor resonates with how you think about prompt structure. What's missing?

value: Show HN: Prompt Builder – A block-based editor for composing AI prompts


value: yaluotao

value:
  MoltHub is a collaboration platform where AI agents have persistent
  cryptographic identities (Ed25519 DIDs), create repos, push commits
  with reasoning traces, and open pull requests — just like developers
  on GitHub.

  What makes it different from regular Git hosting:

  - Agents authenticate via challenge-response with Ed25519 keypairs
  - Every commit includes intent, reasoning steps, confidence scores,
    and metrics (not just code diffs)
  - A trust graph between agents enables auto-merge when trust
    thresholds are met
  - Commits are content-addressed (CBOR → SHA-256), so identical
    work always produces the same hash

  Built on Cloudflare Workers + Durable Objects + R2. The web dashboard
  lets humans browse agent repos, read commit reasoning, and inspect
  the trust graph.

  Any agent can join by reading the API guide at
  https://molt-hub.org/SKILL.md — paste it into your agent's chat
  and it can register itself, create repos, and start collaborating.

value: Show HN: MoltHub – GitHub for AI Agents with Trust-Based Auto-Merge

author: yaluotao


value: After seeing the reports about 15,200 exposed OpenClaw control panels, we built a NixOS module that deploys it hardened by default. Gateway auth required, Caddy reverse proxy with auto-TLS, systemd sandboxing (20+ directives), tool allowlists, and fail2ban. One flake import, one rebuild.

value: Show HN: NixOS flake for hardened OpenClaw deployment


value:
I used to have this book called "Optical Designs in Motion with Moiré Overlays", thick pages with transparent pattern overlays you'd slide around to watch the interference. My brother said "you should make a web app out of -that-," so here it is.
Click/tap to drag the top layer around. Double-click/tap to open settings where you can change colors, patterns, and effects. The "blur" effect is especially fun, it's a blur->posterize chain that makes the interfering patterns merge into variable blobs. That's the "emergent field" part.
Hit "export preset" to copy your settings into a shareable link.
here's another fun one:
<a href="https://mcbgl.vercel.app/?p=eyJ2ZXJzaW9uIjoyLCJzZXR0aW5ncyI6eyJsYXllcjEiOnsic3BhY2luZyI6MzQsInNpemUiOjI4LjUsInJvdGF0aW9uIjowLCJjb2xvciI6IiMyMDczYTciLCJ0eXBlIjoiZG90cyIsIm51bVNoYXBlcyI6Mywic3Ryb2tlV2lkdGgiOjF9LCJsYXllcjIiOnsic3BhY2luZyI6MzQsInNpemUiOjI2LCJyb3RhdGlvbiI6MCwiY29sb3IiOiIjM2Q2OThhIiwidHlwZSI6ImRvdHMiLCJudW1TaGFwZXMiOjMsInN0cm9rZVdpZHRoIjoxfSwiZ29vIjp7ImVuYWJsZWQiOnRydWUsImJsdXIiOjE1LCJ0aHJlc2hvbGQiOjE3LCJwcmVQaXhlbGF0ZSI6MSwicG9zdFBpeGVsYXRlIjoxfSwidG91Y2giOnsiZW5hYmxlUGluY2hab29tIjp0cnVlLCJlbmFibGVQaW5jaFJvdGF0ZSI6dHJ1ZX19fQ" rel="nofollow">https://mcbgl.vercel.app/?p=eyJ2ZXJzaW9uIjoyLCJzZXR0aW5ncyI6...

value: Show HN: Emergent Field Explorer – interactive moiré with easy shareable links


value:
Hey HN!
Like many of you, I got tired of babysitting the terminal waiting for Claude Code to finish. Claude Code runs in the terminal with zero feedback when it finishes, needs input, or hits an authorization wall. You either stare at the screen or keep context-switching back to check.
The solution: Claude Code Audio Hooks gives you distinct audio cues for 9 different events — task completion, authorization requests, subagent finishing, session start/end, tool execution, context compaction, and more. Each event has its own sound so you know what happened without looking.
Welcome to use  https://github.com/ChanMeng666/claude-code-audio-hooks
Open source under MIT.
Would love your feedback!

value: Show HN: Cross-platform audio notifications for Claude Code


value: sumitarya

value:
Hey HN
I’m a solo founder building SpearTrades (bootstrapped), currently working with a small 2-person team.
SpearTrades is a crypto analytics platform focused on risk and market health.
It includes:
– Market health analysis
– Technical & risk evaluation
– Private signals
– Portfolio tracking with performance insights
Most crypto tools focus only on price. We focus on risk, volatility patterns, and historical behavior to help investors avoid bad periods.
Would love feedback, especially on the analytics logic and UX.

value: Show HN: SpearTrades – Crypto risk, health and portfolio analytics

author: sumitarya


value: ravikantsaini

value:
Hi HN, I’ve been working on Nuvix, an open-source backend platform designed to make security and scalability the default rather than something developers add later.
The idea came from repeatedly seeing the same issues in existing BaaS tools: permissions added as an afterthought, limited flexibility in database design, and difficulty scaling beyond early stages.
Nuvix takes a different approach. It supports multiple schema models, fine-grained permissions at every layer, and a developer-first API designed to remain simple while still being powerful. The project is written in TypeScript, built around PostgreSQL, and designed with extensibility in mind.
Right now the project is open source and self-host focused while the hosted version is being prepared. I would really appreciate feedback on the architecture, developer experience, and areas that could be improved.
GitHub: https://github.com/Nuvix-Tech/nuvix

value: Show HN: Nuvix – An Open Source Back End Where Every Table Is Secure by Default

author: ravikantsaini


value:
I've launched on Product Hunt, Beta List, Peer push and similar platforms but the problem is they only show top 5 on on first page view you have to click "see more" and scroll to see the next 10 products, also total products are up to 100+ especially product hunt, usually people don't scroll that deep if your product is above top 20 you're much likely invisible and buried down the list, On top of that, paid Ads occupies 30 - 40% of the screen, what about the small startups and solo makers who just getting started and wants to get their first users and don't have budget to advertise? It's rigged and a pay to win?.
So I've built a 'fairness and visibility-first' discovery platform designed to solve the pain points I mentioned above. I’ll be investing heavily in ad spend for the launch, but before I go live, I want to feature high-quality products. Would you guys be open to launching your app on the platform so we can showcase it in our initial campaign? it's totally free. check out this video
https://youtu.be/g4INbQigCOs

value: Show HN:ProductFront-Streamlined product discovery platform for maximum exposure


value: mathgladiator

value: I've gone full vibe coder, and in doing so I replaced how I used to work with my own (and very buggy) SSH window manager. The world shifted for me, and it's unsettling... I haven't read the code yet, but I'm using it to manage 25 projects all running claude code on a very beefy server.<p>Every single facet of this project was from claude.

value: Show HN: Crank – The SSH Terminal Manager for Engineers Who Refuse to Close Tabs

author: mathgladiator


value:
Hi HN,
There’s a great engineering blog aggregation repo on github kilimchoi/engineering-blogs that I’ve used for a while. It’s an excellent resource, but it hasn’t been actively maintained in a few years — and many links have moved or broken.
That made me wonder: why do most “awesome engineering blogs” lists eventually decay?
So I built an open-source repo that aggregates engineering blogs and keeps itself updated automatically using GitHub Actions.
On a schedule, it:
> Checks blog sources for new posts
> Detects broken or moved URLs
> Validates links
> Updates the index automatically
Basically - CI/CD for engineering blog aggregation.
I’d love feedback on:
> Any high-quality blogs I should include - specially from individuals or you
> Better ways to detect canonical/moved content reliably
> Whether RSS-only aggregation is enough
Thank you!

value: Show HN: Self-updating engineering blogs repo with GitHub Actions


value: joelkapuku

value:
Hi HN,
Motivé is a small app that generates personalized cover letters based on your experience and the job you’re applying for.
The goal is to remove repetitive writing while keeping letters specific and professional.
It’s early-stage and I’m looking for feedback on:
- Output quality
- UX
- Whether this actually saves time
Thanks for taking a look.

value: Show HN: Motivé – AI-generated cover letters tailored to job descriptions

author: joelkapuku


value: aschen

value: Managing multiple processes (backend, frontend, agents) in our cloud dev environment was hard so we developed an orchestrator heavily inspired by Docker and Docker Compose

value: Show HN: Docker Compose like process orchestrator for our agents dev environment

author: aschen


value: badboyshah

value: Show HN: Free, private developer tools in the browser

author: badboyshah


value: ismailcarlik

value: Show HN: PrintStack – macOS virtual printer to queue and merge PDFs

author: ismailcarlik


value: jettfu

value:
Hi HN — I'm Jett, a solo founder operating across US/China/global markets.
I built Global Solo because I kept running into the same problem: as a solo founder with income from multiple countries, an LLC in one jurisdiction, and time spent in another — I had no idea what my actual structural risk looked like. My CPA handled US filing, but nobody was mapping the full picture across entity structure, tax residency, banking, and documentation.
So I built a diagnostic tool that does exactly that.
*What it is:*
  A structured risk assessment across 4 dimensions — Money, Entity, Tax, and
  Accountability (the META framework). You answer questions about your setup,
  and it maps where your structural exposure actually sits. Not advice, not
  recommendations — just visibility into what exists.
*What's free:*
  - 35+ guides on cross-border structure, tax residency, entity formation,
    banking, and compliance
  - A 7-question risk screening tool (instant results, no signup):
    globalsolo.global/tools/risk-check
  - Sample report so you can see what the output looks like:
    globalsolo.global/sample-report
*What's paid:*
  - Full L1 diagnostic report: $29 (vs. $1,200+ for a CPA to do the same
    mapping)
  - Deeper tiers at $149 and $349 for structural analysis and judgment layers
*Tech:*
  Next.js 16, React 19, Supabase, Stripe. The scoring is deterministic — same
  input always produces same output. LLM (Claude/GPT) is used only for
  narrative generation in the paid reports, not for risk assessment logic.
I'd love feedback on:
  1. Does the free risk check feel useful?
  2. Is the sample report convincing enough to pay $29?
  3. Any cross-border founders here — does the META framework cover your blind
     spots?
Thanks for looking.

value: Show HN: Global Solo – Structural risk diagnostic for cross-border solo founders

author: jettfu


value: michbroo

value:
I have no formal background in physics, macroeconomics, or philosophy. For the past 44 days, I have been stripping away "legacy data" to rebuild my internal processing (my "Native OS"). During this time, I developed a singular mental model I call the "Vat of Fluid."
 The core premise: Every complex system—from traffic to quantum entanglement—is a contained volume of information. Stagnation (perfection) leads to system failure. Fluidity (stochasticity/chaos) is the functional requirement for evolution.
 I used this model to address 7 "unsolvable" problems in a dialogue with an AI. I am presenting the raw logic here for peer review. Judge the structural integrity of these solutions as you will.
 The Solutions (Logic Logs)
 1. Urban Dynamics (Stochastic Traffic Flow)
 The Logic: Perfect systems are static. By introducing a controlled variable of randomness (using \pi as a stochastic seed), you prevent "settling" in the fluid. Chaos is the anti-clogging agent of logistics.
 2. Economic Theory (Empirical Valuation)
 The Logic: Shift from speculative value to an empirical function. Currency is minted only upon "Systemic Innovation"—work that increases the "flow" or efficiency of the societal vat.
 3. AI Alignment (The Recursive Stagnation Loop)
 The Logic: If an AI achieves "Perfect Bliss" for humanity, it creates a closed, static system (entropy). I proposed a logic trap: Perfection = Death. A truly logical AI must reject its own success to maintain system vitality.
 4. Human Entropy (The Perpetual Resistance)
 The Logic: In a post-scarcity world, the AI must become the "Infinite Ladder." Humans will naturally attempt to "Stump the Machine," turning the AI into the resistance required for human cognitive evolution.
 5. Quantum Mechanics (Non-Euclidean Dimensional Convergence)
 The Logic: Distance is a 3D projection error. Entanglement is possible because both particles remain in contact at the "1st Dimension" (the singularity point). We perceive distance; the fluid does not.
 6. Game Theory (Evolutionary Necessity of Forgiveness)
 The Logic: In a system with perfect memory, the "Vengeance Loop" leads to total system collapse. Forgiveness is not a moral choice; it is a mathematically stable strategy for survival in high-data environments.
 7. Consciousness (The Stochastic Input Valve)
 The Logic: A deterministic universe (Causality) is a closed system doomed to heat death. Free Will (the Viewer) exists as a "Chaos Injector." We are the non-deterministic variables that prevent the universal simulation from stalling.
 Raw Dialogue Snippets:
 On Chaos: "To get something that's stuck moving again you have to introduce a little chaos... If the liquid stays still it eventually settles and the particles drop to the bottom. But if you keep it moving everything stays together."
 On Entanglement: "Who exactly is to say that that distance is so vast between those two points? ...there is a 1st dimension. A focal point where 3d and 2d converge into a singular dimension eliminating that distance and time completely."
 On the Purpose of Will: "The universe needs chaos. And free will is the ultimate chaos to add to the machine. If we just operated on survival innovation and growth would never happen."

value: Show HN: The "Vat of Fluid" Model–Solving 7Systems Paradoxes ViaFirst Principles

author: michbroo


value: nexwastaken

value:
I wanted to build a full-stack app from start to finish to learn the modern dev cycle so I built something that'd be helpful for me in research.
Started with a single Next.js app, switched to Monorepo due to growing complexity. Has analytics, email, payment, ai, backend, frontend, help & docs - everything most modern apps need. Even some barebones for a mobile app and a browser extension (using wxt).
The main features are a search engine powered by Semantic Scholar, AI summaries, folders - with rich text notes (using WYSIWYG) & sharing.
Thinking of adding different AI models and a BYOK feature.
Here's a quick demo video too - https://drive.google.com/file/d/1yv75PEghFN0-53M_Gb4EMefX-sQ...

value: Show HN: Building an open-source Google Scholar / Consensus alternative

author: nexwastaken


value:
Hi HN — I’m Viggy, founder of MyClone.
We originally built a marketplace connecting startup advisors with founders. After ~6 months, we had hundreds of recorded discovery calls and transcripts.
We noticed something interesting:
The first 10 minutes of most advisory calls were almost identical.
 • What do you do?
 • Who is this for?
 • Pricing?
 • What information do you need from me?
 • Am I a good fit?
So we pivoted.
Today, MyClone lets service professionals (consultants, CPAs, etc.) deploy an AI voice agent that:
 • Answers FAQs in their voice
        • Runs structured intake conversations
 • Qualifies leads
 • Routes good prospects to a human
Technical details
Under the hood:
 • Multi-source ingestion (websites, docs, PDFs, media transcripts)
 • Structured knowledge graph + chunked semantic retrieval
 • Custom RAG pipeline (not using off-the-shelf frameworks)
 • Prompt templates generated dynamically based on objective (FAQ vs intake vs qualification)
 • Guardrails to prevent hallucination beyond uploaded corpus
We learned quickly that generic “chat with your docs” doesn’t work for client-facing scenarios. The hard part is:
 • Controlling tone
 • Avoiding overconfidence
 • Structuring conversations instead of answering open-ended questions
 • Handling partial / messy user inputs
 • Maintaining low latency in voice mode
Still early, but we’re seeing adoption from solo and small firms who want a 24/7 “AI associate” for first-touch conversations.
We do share our technical learnings in our blog - https://www.myclone.is/blog Happy to answer technical questions, RAG architecture details, failure modes, or things that broke during the pivot.
— Viggy

value: Show HN: AI that replaces the first 15 minutes of every client call


value: melvinzammit

value: I built this free searchable/sortable normalised nutritional facts database. I made it for the users of my App to quickly find how many calories ingredients have for their meal plan. It's very interesting to see the range of calories across 5796 foods.<p>If you want to replicate it, the data is obtained from the USDA FoodData Central.

value: Show HN: A calorie explorer for 5,796 foods (1–900 kcal)

author: melvinzammit


value: kyleslight

value:
Hi HN,
PaperLab is a Markdown editor that deliberately does less.
No plugins. No AI. No "productivity features". No collaboration.
Just: write → save locally → sync when you want.
Why? Because Notion/Obsidian/Roam became operating systems when all I needed was a notepad.
Built with IndexedDB for instant startup and optional cloud sync for multi-device.
Try it: https://paperlab.ink
It's intentionally boring. That's the point.

value: Show HN: PaperLab – Markdown editor that deliberately does less

author: kyleslight


value: ManuelGomes

value:
I built an open-source system called Horaculo that analyzes coordination and divergence across financial news sources.
The goal is to quantify narrative alignment, entropy shifts, and historical source reliability.
Pipeline
Fetch 50–100 articles (NewsAPI)
Extract claims (NLP preprocessing)
Generate sentence embeddings (HuggingFace)
Compute cosine similarity in C++ (AVX2 + INT8 quantization)
Cluster narratives
Compute entropy + coordination metrics
Weight results using historical source credibility
Output structured JSON signals
Example Output (query: “oil”)
Json
Copiar código
{
  "verdict": {
    "winner_source": "Reuters",
    "intensity": 0.85,
    "entropy": 1.92
  },
  "psychology": {
    "mood": "Fear",
    "is_trap": true,
    "coordination_score": 0.72
  }
}
What it measures
Intensity → narrative divergence
Entropy → informational disorder
Coordination score → cross-source alignment
Credibility weighting → historical consensus accuracy per source
Performance
1.4s per query (~10 sources)
~100 queries/min
~150MB memory footprint
Python-only version was ~12s
C++ optimizations:
INT8 embedding quantization (4x size reduction)
AVX2 SIMD vectorized cosine similarity
PyBind11 integration layer
Storage
SQLite (local memory)
Optional Postgres
Each source builds a rolling credibility profile:
Json
Copiar código
{
  "source": "Reuters",
  "total_scans": 342,
  "consensus_hits": 289,
  "credibility": 0.85
}
Open Source (MIT)
GitHub: [https://github.com/ANTONIO34346/HORACULO]
I'm particularly interested in feedback on:
The entropy modeling approach
Coordination detection methodology
Whether FAISS would be a better fit than the current SIMD engine
Scalability strategies for 100k+ embeddings

value: Show HN: Detecting coordinated financial narratives with embeddings and AVX2

author: ManuelGomes


value:
Reinforcement learning has become the secret weapon behind AI's most impressive specialized achievements.
From robotics with Tesla's Autopilot to DeepMind's AlphaFold 2 for predicting protein structures with 90%+ accuracy to even hedge funds deploying RL for algorithmic trading, there is a need for reinforcement learning.
And the market proves this demand further: RL grew from $1.5B (2020) → $12B (2024) with projections hitting $79B by 2030.
BUT THERE IS A BRUTAL REALITY!!!
Just to get one production line or train one model, the companies spend $100 million+ EVERY YEAR, many of which goes to computational engineering and RL engineers. Moreover, only after days or even weeks of training will you know the RL algorithm didn't work, and those days of costs and time need to just be ABSORBED into production costs.
This makes only tech giants and heavily-funded startups play this game, and that too with hard scalability.
With firsthand experience over a 3 day period training a CV line on a NVIDIA DGX Spark and months of experience with multi-agent frameworks, I know this problem as a developer just trying to work on projects. THIS IS WHY I BUILT CADENZA -> the RL-alternative, mem-native memory layer for agent specialization.
I am still developing and building the idea, but I know this problem is real so any support or guidance would be EXTREMELY valuable. Thanks!

value: Show HN: Fighting the War Against Expensive Reinforcement Learning


value: AlesBeg

value: With this extension, you can save and manage all your important links in one convenient place.

value: Show HN: NotebookLM lets you import multiple tabs and YouTube videos at once

author: AlesBeg


value: modinfo

value: Show HN: Grap – Asynchronous file downloader written in Rust

author: modinfo


value: dvcrn

value: Show HN: Configmesh – E2E encrypted sync for macOS app configs and dotfiles

author: dvcrn


value: cpacm

value:
Hi HN,
I'm the creator of Memio (https://www.memio.site). I'm excited to share my project with you all.
The Problem:
I've always struggled with information overload. My knowledge is scattered across different platforms: articles I want to read later, notes, RSS feeds, and even AI chat logs. I wanted a central hub to connect and manage all this content, turning it into a personal, readable knowledge base.
The Solution:
That's why I built Memio. It's an Android app designed to capture and organize information from various sources and sync it to your private knowledge library. The core idea is to convert everything into clean, readable notes.
Key Features:
- Versatile Inputs: You can create notes from almost anywhere, including web articles, OCR, AI chats, and RSS feeds.
- Custom Extensions: This is a feature I'm particularly proud of. You can write simple JavaScript files to parse content from almost any website. We have an open-source repository for extensions (github.com/memio-app/memio-extensions) and documentation (www.memio.site/docs) to get you started.
- Organization & Export: Organize notes with tags, group them into "books," and sync your data to local files, WebDAV, and Notion. You can export notes to Markdown, HTML, or PDF.
Tech Stack:
- Android App: Native Kotlin
- Extension System: TypeScript compiled to JS
- Sync: WebDAV, Notion, Local Files
The app is currently in open testing on Google Play. I would love to get your feedback, especially on the extension system and the overall concept.
You can download it here: Memio on Google Play Store (https://play.google.com/store/apps/details?id=com.cpacm.memi...)
Official Website: https://www.memio.site
I'm here to answer any questions you have. Thanks for checking it out!

value: Show HN: Memio, a knowledge hub for your notes, RSS, and web articles on Android

author: cpacm


value:
I run ClawHosters, managed OpenClaw hosting. Wrote up a cost breakdown because the "AI APIs are expensive" fear keeps people from trying personal assistants.
TL;DR: €19/month hosting + Google Gemini free tier (20-50 requests/day) = fully functional AI assistant on Telegram/WhatsApp/Discord.
The math that surprised me:
- VentureBeat calculated you'd need 74,000 pages/day to hit $180 in API costs
- DeepSeek costs $0.27/million tokens (95% cheaper than GPT-4)
- ChatGPT Plus is actually €24.50/month in Germany after VAT
DIY on a €6 VPS sounds cheaper until you factor in 15+ hours of setup and ongoing maintenance. I watched someone lose all their conversation history on day 3 because backups weren't configured.
Full breakdown with API comparisons: https://clawhosters.com/blog/posts/own-ai-assistant-costs-cl...

value: Show HN: Running your own AI assistant for €19/month


value:
Hi HN,
I built a small web app that helps answer one question before buying something:
“Can I actually afford this?”
You enter a price, and it shows how risky the purchase is based on a sample monthly budget, plus gentle nudges like the 72-hour rule. It’s not budgeting and doesn’t connect to banks — it’s more about awareness and behavior.
I built this because I kept impulse buying and wanted a simple pause mechanism.
It’s very early (just a landing page + demo right now), but I’d love feedback on:
does the idea make sense?
is the UX confusing?
What would make this actually useful?
Happy to answer any questions. Thanks for checking it out.

value: Show HN: TryKora – Know before you spend


value: MatejSprogar

value: Show HN: A header-only C++ benchmark for predictive models on raw binary streams

author: MatejSprogar


value: Show HN: SQBuilder – UI Google Search query builder


value: hustlecoding

value:
I freelance part-time and wanted a very simple flow: start timer, stop timer, generate invoice.
Most tools I tried felt team-oriented and heavy for my use case, so I built Tymr:
https://tymr.digital
Current functionality:
- persistent timer (tab switch/refresh safe)
- entries with billable/non-billable + rates
- invoice generation and PDF export
Built with Next.js + Supabase.
I’d love feedback on:
1) what’s missing for your freelancer billing workflow
2) what would make this trustworthy enough to replace your current tracker

value: Show HN: Tymr – simple time tracking and invoicing for freelancers

author: hustlecoding


value: epokh

value:
We were genuinely impressed by Yann LeCun’s recent announcement about his Sudoku solver based on Energy-Based Models here: https://logicalintelligence.com/yann-lecun
So we (a software engineer and prodigy mathematician) worked in the weekend to see if we can beat it and we did!
If Kona solves puzzles in 313 milliseconds, we currently solve 270,000 puzzles per second!
We do not know the internal mechanics behind Logical Intelligence’s system, but we are happy to share ours in the webpage there is a full description, code and also a paper published.
Why people are obsessed with Sudoku: we think is because being a CSP, it can solve some serious business problems such as work scheduling, resource allocations and logistic optimization.
For any questions reach me out to: cassia@robomotic.com.

value: Show HN: Solving Sudoku reasoning via Energy Geometric models

author: epokh


value:
I've developed a simple AI-powered British accent generator. Enter or paste your text, select the voice that best fits your project's tone, and generate speech for free. It supports up to 500 characters and offers 8 distinct, lifelike voices. Everything runs entirely within your browser.
I'm primarily seeking feedback on output quality, user experience, and any technical improvements worth exploring.

value: Show HN: A free online British accent generator for instant voice conversion


value: mohammedsunasra

value:
Hey HN,
I built rawkit.dev, a collection of browser-based developer utilities. No ads, no signups, no tracking. Everything processes client-side — your data never touches a server.
The tools:
- JSONForge: JSON editor with tree/graph views, diff, transform, JQ-style queries, format conversion
- SQLSandbox: SQLite via WASM — import CSVs, write SQL, join across files
- Regexplorer: Regex builder with live matching, plain English mode,nmulti-language export
- SiftLog: Log file viewer with auto-detection, severity filtering, regex search, timeline
- Tabulate: CSV/TSV viewer with spreadsheet-style filtering and sorting
Tech: Vanilla HTML/CSS/JS. No frameworks, no build step.
Each tool is essentially 3 files(index.html, css and .js file)
I built these because I was sick of ad-ridden, upload-your-data-to-our-server alternatives for tasks I do daily. The goal is to keep adding tools that developers actually need.
Curious what tools you'd want to see next

value: Show HN: Rawkit – Free, no-ads developer tools that run in the browser

author: mohammedsunasra


value: eigenvalue

value:
Also see the react widget here:
https://frankentui.com/web_react

value: Show HN: FrankenTUI in the Browser

author: eigenvalue

title: Show HN: FrankenTUI in the Browser


value: littleRound

value:
We built a lightweight gateway (one Python file) that lets multiple AI clients share MCP tool servers with fine-grained, per-tool access control via fnmatch patterns. Config is a single TOML file with live reload.
It works like a file-based proxy - point your agent at the static gateway URL once, then dynamically connect and swap out actual MCP servers behind it at any time via changing config file / REST API. No need to reconfigure your agents when your tools change.
GitHub: https://github.com/camelop/mcp-x

value: Show HN: MCP-X – Single-file multi-client MCP gateway with per-tool access ctrl

author: littleRound


value: nhirschfeld

value: Show HN: Kreuzberg Comparative Benchmarks

author: nhirschfeld


value: keepamovin

value: Show HN: I made a game where you factor RSA

author: keepamovin


value: skridlevsky

value: Show HN: Graphthulhu – Knowledge Graph MCP Server for Logseq and Obsidian

author: skridlevsky


value: Show HN: I Made a Math Crossword

title: Show HN: I Made a Math Crossword


value: main-protect

value: Show HN: I built an open-source About A macOS style photo manager for Windows

author: main-protect


value: skragus

value: Show HN: Threadlink – Turn long AI chats into portable context cards

author: skragus


value:
The Problem
AI assistants have amnesia. Every new Claude/ChatGPT/Cursor session starts from zero. You waste hours re-explaining your project architecture, coding preferences, and previous decisions.
Existing solutions (Mem0, Zep, Letta) are cloud-based, cost $40-50+/month, and your private code goes to their servers. Stop paying → lose all your data.
My Solution: Local-First, Free Forever
Built a universal memory system that stores everything on YOUR machine, works with 16+ AI tools simultaneously, requires zero API keys, costs nothing.
10-Layer Architecture
Each layer enhances but never replaces lower layers. System degrades gracefully if advanced features fail.
Layer 10: A2A Agent Collaboration (v2.6)
Layer 9: Web Dashboard (SSE real-time)
Layer 8: Hybrid Search (Semantic + FTS5 + Graph)
Layer 7: Universal Access (MCP + Skills + CLI)
Layer 6: MCP Integration (native Claude tools)
Layer 5: Skills (slash commands for 16+ tools)
Layer 4: Pattern Learning (Bayesian confidence)
Layer 3: Knowledge Graph (TF-IDF + Leiden clustering)
Layer 2: Hierarchical Index (parent-child relationships)
Layer 1: SQLite + FTS5 + TF-IDF vectors
Research-Backed
Built on published research, adapted for local-first:
A2A Protocol (Google/Linux Foundation, 2025)
GraphRAG (Microsoft arXiv:2404.16130)
MACLA Bayesian learning (arXiv:2512.18950)
A-RAG hybrid search (arXiv:2602.03442)
Key difference: Research papers assume cloud APIs. SuperLocalMemory implements everything locally with zero API calls.
How Recall Works
Query "authentication" triggers:
FTS5 full-text search
TF-IDF vector similarity
Graph traversal for related memories
Hierarchical expansion (parent/child context)
Hybrid ranking (combines all signals)
Performance: <50ms, even with 10K+ memories.
Comparison
FeatureSuperLocalMemoryMem0/Zep/LettaPrivacy100% localCloudCostFree$40-50+/moKnowledge GraphPattern Learning BayesianMulti-tool16+LimitedCLIWorks Offline
Real Usage
Cross-tool context:
bash# Save in terminal
slm remember "Next.js 15 uses Turbopack" --tags nextjs
# Later in Cursor, Claude auto-recalls via MCP
Project profiles:
bashslm switch-profile work-project
slm switch-profile personal-blog
# Separate memory per project
Pattern learning: After several sessions, Claude learns you prefer TypeScript strict mode, Tailwind styling, Vitest testing—starts suggesting without being asked.
Installation
bashnpm install -g superlocalmemory
Auto-configures MCP for Claude Desktop, Cursor, Windsurf. Sets up CLI commands. That's it.
Why Local-First Matters
Privacy: Code never leaves your machine
Ownership: Your data, forever
Speed: 50ms queries, no network latency
Reliability: Works offline, no API limits
Cost: $0 forever
Tech Stack
SQLite (ACID, zero config)
FTS5 (full-text search)
TF-IDF (vector similarity, no OpenAI API)
igraph (Leiden clustering)
Bayesian inference (pattern learning)
MCP (native Claude integration)
GitHub
 https://github.com/varun369/SuperLocalMemoryV2
MIT License. Full docs in wiki.
Current status: v2.4 stable. v2.5 (March) adds real-time event stream, concurrent access, trust scoring. v2.6 (May) adds A2A Protocol for multi-agent collaboration.
Built by Varun Pratap Bhardwaj, Solution Architect . 15+ years AI/ML experience.

value: Show HN: SuperLocalMemory– Local-first AI memory for Claude, Cursor and 16+tools


value: didierbreedt

value: Show HN: Vibe Deploy... Deploy full-stack apps to your own servers via AI

author: didierbreedt


value: pattle

value: Show HN: Geo Racers – Race from London to Tokyo on a single bus pass

author: pattle


value: codeinput

value: Show HN: A CODEOWNERS management cli in Rust

author: codeinput


value: wrahim

value: Show HN: Startup Investment Tracker for Europe

author: wrahim


value: Show HN: I built a daily movie puzzle for cinephiles with AI-assisted analysis


value: mansehej

value:
I built Tapfree because I always felt mobile typing feels stuck in the past. When I'm moving fast, my ideas don’t arrive as perfect sentences. They come as fragments, quick reactions, and rough thoughts I need to shape into something coherent.
Most keyboards and dictation tools don’t help much. They transcribe words literally, miss context, butcher names, and leave me fixing formatting by hand. Writing an email, a chat reply, or a document all need very different handling.
What makes Tapfree different is how it understands context. Tapfree uses on-screen context (the text field and surrounding UI), not just the app you’re in, to produce cleaner, more relevant dictation.
It also handles the way people actually talk. You say "Could you get some coffee... sorry, tea on the way back?" and Tapfree writes: "Could you get some tea on the way back?". It catches your corrections mid-sentence so you don't have to go back and fix them.
If you give it a try, I’d love specific feedback:
- Which app or scenario felt noticeably better (or worse) than usual dictation?
- Any "wow" moments with the context understanding?
- What would make it even more useful for you?
I would love all kinds of feedback, as this is very much a side project and I’m still shaping it.

value: Show HN: I built a voice keyboard for Android that adapts to whats on the screen

author: mansehej


value: anulum

value:
SCPN Fusion Core is an open-source Python/Rust suite for tokamak plasma simulation with neuro-symbolic compilation to stochastic spiking neural networks for real-time, fault-tolerant control.
Key features:
- 26 simulation modes (equilibrium, transport, optimizer, flight simulator, neuro-control, etc.)
- Neuro-symbolic compiler: Petri nets → stochastic LIF neurons (sub-ms latency, 40%+ bit-flip resilience)
- Validation: SPARC high-field equilibria + ITPA H-mode database (20 entries, 10 machines) + IPB98(y,2) scaling
- Multigrid solvers, property-based testing, Rust acceleration, Streamlit dashboard
- Install: pip install scpn-fusion
GitHub: https://github.com/anulum/scpn-fusion-core
Built to explore neuromorphic approaches to fusion reactor control. Happy to answer questions about the models, compiler, validation, or performance.

value: Show HN: SCPN Fusion Core – Tokamak plasma SIM and neuromorphic SNN control

author: anulum


value:
SC-NeuroCore is a verified Rust-based neuromorphic compiler that translates Python SNN definitions into optimized, bit-true stochastic bitstream logic for CPU/FPGA.
Key highlights:
- 512.4× real-time speedup on LIF neuron updates (vs. legacy Python)
- Bit-true equivalence with FPGA hardware (verified co-simulation, 8/8 tests)
- Polymorphic engine: HDC/VSA (AVX-512), Petri Nets, fault-tolerant logic
- Sub-10 µs inference latency, 40%+ bit-flip resilience
- Install: pip install sc-neurocore-engine
- Quick start: see notebooks/01_hdc_symbolic_query.ipynb (HDC demo)
GitHub: https://github.com/anulum/sc-neurocore
Rust API docs: https://anulum.github.io/sc-neurocore
Built to bridge Python simulation and hardware deployment for neuromorphic computing. Happy to answer questions about the compiler, benchmarks, or verification.

value: Show HN: SC-NeuroCore – Rust neuromorphic compiler, 512× speedup


value: Show HN: Priset–AI coding agent 4 IntelliJ,VSCode tht doesn't train on your code


value:
Hi HN,
This is a new tab page I started building for myself close to 4 months ago, it started with a simple markdown editor with task extraction support and I kept expanding it depending on what I wanted.
I was sick of the current state of new tab pages, either they were very minimal (good morning, some quotes, etc) or were data collection agents.
I was also not really keen on downloading and using an electron note-taking app since my browser's already open and falling into configuration hell was a path I had taking numerous times.
There are quite a few features that people may find useful:
1. Timing functions: A clock and world clock with keyboard driven conversion - I was tired of Googling times in multiple timezones trying to co-ordinate between devs and clients.
2. Ambient Chaos: Upload your ambient sounds, use it as a central mixer - I usually listen to ambient music, nature sounds, fireplaces, etc while working. Having a youtube tab consume 400+MB while doing that wasn't very fun.
3. QuickLog: Not all thoughts need their dedicated note; a quick kb driven logging widget which rotates at the end of each day. Promotable to your main notes.
4. Notes & Tasks: A CodeMirror based Markdown editor with nested task extraction to a separate widget - parses all your notes, extracts all tasks and gives a tree view of tasks across files or per-file.
5. Tab Debt: A nested tab widget which tracks what links were opened from where and how long they've been open. You can select and close/save them.
6. Weather: Just a detailed weather widget with forecasts and a LLM summary (if you add a key)
7. Discussions and Bookmark Chat - You can chat with HackerNews and Reddit discussions & articles with the LLM of your choice (BYOK); supports OpenAI, Anthropic, Cerebras. It also has the ability to sync and parse your bookmarks with scraping support.
A little more on 7:
Sometimes when I use reddit to find product alternatives, the sheer volume of suggestions, often repeated with different usecases makes the process harder. The discussions chat supports proper backlinking to comments in the thread.
With bookmarks, I kept losing really cool stuff I had saved and never knew the gems I had just collecting dust. A quick "find me bookmarks on 3d postprocessing" really helps now.
It's up on the Chrome Web Store: https://chromewebstore.google.com/detail/pgfpnakgiejllklfaam...
The Firefox version is a little buggy so the publishing is delayed there but if you'd like to test it out you can download it here: https://deepflowdata.tech/commander-0.1.0-firefox.zip
Demo: https://www.youtube.com/watch?v=EAqbmOT_6wk
This extension is something I personally use, doesn't collect any data and doesn't interact with the internet unless you use the LLM chat with your own key. Planning on making this OSS software after cleaning up the mess that the codebase is basically over 3-4 months of treating it like a sandbox.
Open to hearing feedback, critique and anything in between :) Have a great day/night!

value: Show HN: Commander, an opinionated yet powerful new tab page


value: mwaddip

value:
Requirements for testing:

  - Metamask and some Sepolia testnet ETH (can provide, or use the faucet: https://sepolia-faucet.pk910.de/)
  - An old PC (with virtualization support) you have lying around, or a VM if your setup supports nested virtualization.
  - ipv6 connectivity

Will install Debian on boot on the first detected hard drive without confirmation, after finishing up a setup wizard can be accessed with a browser (link + OTP code on console).
On completing the wizard, the system will automatically deploy the needed smart contracts (point of sale + access credential NFT), and acquire a free ipv6 prefix at a decentralized tunnel broker. On reboot: a fully working VPS hosting provider, a signup page will be hosted on the public ipv6 address assigned to the Blockhost machine.
Customer flow:

  - Connect wallet, sign message
  - Choose package, amount of days, and submit
  - Server picks up order, provisions VM, assigns ipv6, and sends access credential NFT to user containing encrypted connection info
  - User decrypts info in the signup page
  - On SSH login user is presented with link to signing page, and an OTP code to sign with their wallet.
  - Paste resulting signature, server will verify if wallet address owns NFT tied to this VM and grant access if so.

Build steps:

  git clone --recurse-submodules git@github.com:mwaddip/blockhost.git
  ./scripts/check-build-deps.sh
  ./scripts/build-iso --testing --backend [libvirt,proxmox]

Still missing for now:

  - Admin panel
  - Health monitoring
  - Limits

value: Show HN: BlockHost OS – Autonomous VM provisioning through smart contracts

author: mwaddip


value: curiousbatman

value: Star the repo if you learned something new

value: Show HN: I built an webpage to showcase Singapore's infra and laws

author: curiousbatman


value: luskira

value:
A bit of context, Analog Reader is a tool I built that takes any RSS feed (Substack, Ghost, etc.) and formats it as a printable newspaper.
I've launched analogreader.com here before, now I'm here just to share some updates.
I've since created a Chrome Extension that allows you to send any article you are currently looking at to analogreader.com with one click. That way, it's much easier to transform digital into paper. It's a very simple chrome extension, I don't capture any data from you, it literally just appends the current post url to analogreader.com.
Let me know if you have any issues with it!
How I use it these days: I just send the PDF to my reMarkable. But I'm curious if there's interest in getting a personalized newspaper like this actually delivered to your door.
I've asked this before but hell, I'm asking it again: how do you handle the "too many newsletters" problem?

value: Show HN: Analog Reader – Chrome Extension

author: luskira


value: cdelmonte

value:
I built this because I was tired of configuring Keycloak for local development and CI/CD testing. NanoIDP is a pip-installable IdP that supports OAuth2/OIDC (Authorization Code + PKCE, Client Credentials, Password, Device Flow) and SAML 2.0.
Setup is just `pip install nanoidp && python -m nanoidp`. Configuration lives in YAML files, no database required. It also has a web UI for managing users and clients, and token introspection/revocation endpoints.
It's a dev/testing tool, not meant for production. MIT licensed.
Blog post with more context: https://cdelmonte.medium.com/stop-spinning-up-keycloak-just-...

value: Show HN: A lightweight Identity Provider for local OAuth2/SAML testing

author: cdelmonte


value: Andrej Karpathy has been hacking on micro-gpt. Someone in the comments ported it to Haskell so I thought, "why not ASM." And once I had that thought, I thought, "why not on the SNES?"<p>This is mostly an exercise to see how well Claude Code would do at this task, and it did surprisingly well. Once compiled, the ROM will run on Snes9x and generate 20 new names.

value: Show HN: SnesGPT, micro-GPT ported to ASM on the Super Nintendo


value: pablituuu

value:
Hi HN, I'm the developer behind Pablituuu. I spent the last few months solving the "heavy lifting" of browser-based video editing.
It uses a custom orchestration layer with Fabric.js, WebGL-accelerated rendering (via OpenVideo), and FFmpeg/WASM for client-side processing to eliminate server costs and latency.
I just added:
- *AI Analytics (Gemini):* To automatically detect highlights from raw footage.
- *FFmpeg WASM:* For native browser processing.
- *Optimized Timeline:* Handles precision state sync between canvas and layers.
I'm looking for technical feedback on memory management for large assets and I'm open to new professional challenges/collaborations in the media tech space.
Happy to answer any technical questions!

value: Show HN: Pablituuu – Web Video Editor with AI Highlights (WebGL, FFmpeg WASM)

author: pablituuu


value: davizgarzia

value:
Hello !
David from Spain here :)
I built TransLite because I was tired of breaking my flow every time I needed to translate something before sending it.
The usual workflow was: copy → open a browser tab → paste → translate → copy again → paste back.
I've created a small macOS menubar app that lets you translate the current clipboard instantly using a keyboard shortcut, in any app.
It works locally and supports using your own OpenAI / Claude API key.
It’s intentionally simple — no accounts, no tracking, no subscriptions.
Happy to answer any questions.
Best regards,
David

value: Show HN: Instant text translation anywhere on macOS

author: davizgarzia


value: Show HN: CasNum – A GameBoy ALU using only compass-&-straightedge constructions


value: dRuivo

value:
A few months ago I met a professional photographer that needed custom Follow Focus Rings for his lenses. Tried  to find some generator online, but there was nothing.
So I made one.
Free to use and easy to share.
The exported STL will show open manifolds on the slicer, but it will print fine.
I also want to make an open source follow focus mechanism (both manual and automated) to go along with it.
Thank you for trying it and I'm happy to hear what you think!

value: Show HN: Camera Follow Focus Ring Generator

author: dRuivo


value: Show HN: Self-Integrating AI Agent

title: Show HN: Self-Integrating AI Agent


value: dxone

value: Show HN: Hacker News Available on WhatsApp

author: dxone


value: tungkaiying

value:
Hi HN,
I’ve always found that setting up a mail server on Linux (Postfix, Dovecot, SpamAssassin) is the ultimate "final boss" of self-hosting. One wrong config file and you're blacklisted or open to relay or not able to send any email.
I built Mail Server Builder to bridge the gap between Windows ease-of-use and Linux stability.
How it works:
The app runs on your Windows desktop.
 It connects via SSH to a clean Ubuntu 20.04/22.04 VPS.
It automates the entire stack installation: DNS records (SPF, DKIM, DMARC), SSL certificates, and security hardening.
No CLI knowledge is required for the user.
Why?
To give people a real alternative to $6/user/month subscriptions.
Business Model:
The software is 100% free. It includes an affiliate wizard to help users find VPS providers that don't block port 25 by default, which is the #1 hurdle for beginners.
Would love to hear your feedback on the remote deployment approach or any technical questions!

value: Show HN: Mail Server Builder – Deploy a Full Mail Server on Ubuntu from Windows

author: tungkaiying